source: trunk/minix/commands/make/macro.c@ 9

/*************************************************************************
 *
 *  m a k e :   m a c r o . c
 *
 *  Macro control for make
 *========================================================================
 * Edition history
 *
 *  #    Date                         Comments                       By
 * --- -------- ---------------------------------------------------- ---
 *   1    ??                                                         ??
 *   2 23.08.89 Error message corrected                              RAL
 *   3 30.08.89 macro flags added, indention ch.                     PSH,RAL
 *   4 03.09.89 fixed LZ eliminated, doexp(...) changed              RAL
 *   5 06.09.89 M_MAKE added, setDFmacro added                       RAL
 *   6 20.09.89 work around for Minix PC ACK bug                     BE,RAL
 * ------------ Version 2.0 released ------------------------------- RAL
 *
 *************************************************************************/

#include "h.h"


static char   buf[256];

struct macro *getmp(name)
char *name;
{
  register struct macro *rp;

  for (rp = macrohead; rp; rp = rp->m_next)
                if (strcmp(name, rp->m_name) == 0)
                        return rp;
  return (struct macro *)0;
}


char *getmacro(name)
char *name;
{
  struct macro *mp;

  if (mp = getmp(name))
                return mp->m_val;
/*      else*/
                return "";
}


struct macro *setmacro(name, val)
char *name;
char *val;
{
  register struct macro *rp;
  register char         *cp;


                /*  Replace macro definition if it exists  */
  for (rp = macrohead; rp; rp = rp->m_next)
        if (strcmp(name, rp->m_name) == 0) {
                if(rp->m_flag & M_OVERRIDE) return rp;  /* mustn't change */
                free(rp->m_val);        /*  Free space from old  */
                break;
                }

        if (!rp)                /*  If not defined, allocate space for new  */
        {
                if ((rp = (struct macro *)malloc(sizeof (struct macro)))
                                         == (struct macro *)0)
                        fatal("No memory for macro",(char *)0,0);

                rp->m_next = macrohead;
                macrohead = rp;
                rp->m_flag = FALSE;

                if ((cp = (char *) malloc(strlen(name)+1)) == (char *)0)
                        fatal("No memory for macro",(char *)0,0);
                strcpy(cp, name);
                rp->m_name = cp;
        }

        if ((cp = (char *) malloc(strlen(val)+1)) == (char *)0)
                fatal("No memory for macro",(char *)0,0);
        strcpy(cp, val);                /*  Copy in new value  */
        rp->m_val = cp;

  return rp;
}


void setDFmacro(name, val)
char *name;
char *val;
{
  char        *c,*tmp;
  int          len;
  static char  filename[]="@F";
  static char  dirname[] ="@D";

  setmacro(name,val);
  *filename = *name;
  *dirname  = *name;
  /* Null string -- not defined macro */
  if ( !(*val)) {
     setmacro(filename,"");
     setmacro(dirname,"");
     return;
  }
  if (!(c = strrchr(val,(int)'/'))) {
     setmacro(filename,val);
     setmacro(dirname,"./");
     return;
  }
  setmacro(filename,c+1);
  len = c - val + 1;
  if((tmp = (char *) malloc(len + 1)) == (char *) 0)
     fatal("No memory for tmp",(char *)0,0);
  strncpy(tmp,val,len);
  tmp[len] = '\0';
  setmacro(dirname,tmp);
  free(tmp);
  return;
}

/*
 *      Do the dirty work for expand
 */
void doexp(to, from)
struct str *to;
char  *from;
{
  register char *rp;
  register char *p;
  char *q;
  struct macro *mp;


  rp = from;
  p  = &(*to->ptr)[to->pos];
  while (*rp) {
        if (*rp != '$') {
                *p++ = *rp++;
                to->pos++;
        }
        else {
                q = buf;
                if (*++rp == '{')
                        while (*++rp && *rp != '}')
                                *q++ = *rp;
                else if (*rp == '(')
                        while (*++rp && *rp != ')')
                                *q++ = *rp;
                else if (!*rp) {
                        *p++ = '$';
                        to->pos++;
                        goto bail;
                }
                else
                        *q++ = *rp;
                *q = '\0';
                if (*rp)
                        rp++;
                if (!(mp = getmp(buf)))
                        mp = setmacro(buf, "");
                if (mp->m_flag & M_MARK)
                        fatal("Infinitely recursive macro %s", mp->m_name,0);
                mp->m_flag |= M_MARK;
                if ( mp->m_flag & M_MAKE) expmake = TRUE;
                doexp(to, mp->m_val);
                p = &(*to->ptr)[to->pos];
                mp->m_flag &= ~M_MARK;
        }
  bail:
        if (to->pos >= to->len) {
                strrealloc(to);
                p = &(*to->ptr)[to->pos];
        }
  }
  *p = '\0';
}


/*
 *      Expand any macros in str.
 */
void expand(strs)
struct str *strs;
{
  char  *a;

  if ((a = (char *) malloc(strlen(*strs->ptr)+1)) == (char *)0)
     fatal("No memory for temporary string",(char *)0,0);
  strcpy(a, *strs->ptr);
  strs->pos = 0;
  doexp(strs, a);
  free(a);
}