newyaccc.c

編譯器的虛擬yacc工具

  (*reg)->node = NIL;
}

ny__dobeg()
{
  struct ny_RStack *temp;

  temp = ny_rstack;
  ny_rstack = NEW_RS();
  ny_rstack->next = temp;
  ny_rstack->top = NIL;
}

ny__doend()
{
  struct ny_RStack *rs;
  struct ny_RStackElem *rse,*temp;

  if(ny_rstack == NIL) return;
  rse = ny_rstack->top;
  while(rse != NIL) {
    *rse->myaddress = rse->reg;
    temp = rse;
    rse = rse->next;
    FREE_M(temp);
  }
  rs = ny_rstack;
  ny_rstack = ny_rstack->next;
  FREE_M(rs);
}

ny__orderf(n,f)
unsigned n;
char *(*f)();
{
  struct ny_Node *temp;
  struct ny_CNStack *t;
  struct ny_Order *tord;

  temp = ny_cnode;
  t = ny_cnstack;
  ny_cnode = ny_cnstack->node;
  ny_cnstack = ny_cnstack->next;
  FREE_CNSTACK(t);
  tord = ny_cnode->translations->order;
  ny_cnode->translations->order = NEW_ORDER();
  ny_cnode->translations->order->u.func = NEW_FUNC();
  ny_cnode->translations->order->next = tord;
  ny_cnode->translations->order->u.func->f = f;
  ny_cnode->translations->order->u.func->args = temp->translations->order;
  ny_cnode->translations->order->op = ny_udf;
}

ny__assignf(n,ref,f)
unsigned n;
struct ny_Register **ref;
char *(*f)();
{
  struct ny_Node *temp;
  struct ny_CNStack *t;
  struct ny_Order *tord;

  temp = ny_cnode;
  t = ny_cnstack;
  ny_cnode = ny_cnstack->node;
  ny_cnstack = ny_cnstack->next;
  FREE_CNSTACK(t);
  tord = ny_cnode->translations->order;
  ny_cnode->translations->order = NEW_ORDER();
  ny_cnode->translations->order->u.func = NEW_FUNC();
  ny_cnode->translations->order->next = tord;
  ny_cnode->translations->order->reg = ref;
  ny_cnode->translations->order->u.func->f = f;
  ny_cnode->translations->order->u.func->args = temp->translations->order;
  ny_cnode->translations->order->op = ny_assign;
  ny_cnode->translations->order->op2 = ny_udf;
}

ny__begf()
{
  struct ny_CNStack *temp;

  temp = ny_cnstack;
  ny_cnstack = NEW_CNS();
  ny_cnstack->node = ny_cnode;
  ny_cnstack->next = temp;
  ny_cnode = NEW_NODE();
  ny_cnode->nchildren = 0;
  ny_cnode->children = NIL;
  ny_cnode->translations = NEW_TRANS();
  ny_cnode->translations->mask = 0;
  ny_cnode->translations->order = NIL;
  ny_cnode->translations->next = NIL;
}

ny__concatf(n,ref,f)
unsigned n;
struct ny_Register **ref;
int (*f)();
{
  struct ny_Node *temp;
  struct ny_CNStack *t;
  struct ny_Order *tord;

  temp = ny_cnode;
  t = ny_cnstack;
  ny_cnode = ny_cnstack->node;
  ny_cnstack = ny_cnstack->next;
  FREE_CNSTACK(t);
  tord = ny_cnode->translations->order;
  ny_cnode->translations->order = NEW_ORDER();
  ny_cnode->translations->order->u.func = NEW_FUNC();
  ny_cnode->translations->order->next = tord;
  ny_cnode->translations->order->reg = ref;
  ny_cnode->translations->order->u.func->args = temp->translations->order;
  ny_cnode->translations->order->op = ny_concat;
  ny_cnode->translations->order->op2 = ny_udf;  
}

ny__collect(str)
char *str;
{
  unsigned slen,lsf;

  slen = (str != NIL) ? strlen(str) : 0 ;
  lsf = (ny_astack->arguments[ny_astack->carg] != NIL)
    ? strlen(ny_astack->arguments[ny_astack->carg]) : 0 ;
  if(ny_astack->carg >= ny_astack->maxargs) {
    ny_astack->arguments =
      (char **)RE_STR(ny_astack->arguments,
        sizeof(char *)*(ny_astack->maxargs+10));
    ny_astack->arglens =
      (unsigned *)RE_STR(ny_astack->arglens,
        sizeof(int)*(ny_astack->maxargs+10));
    ny_astack->maxargs += 10;
  }
  if(slen+lsf > ny_astack->arglens[ny_astack->carg]) {
    ny_astack->arglens[ny_astack->carg] += slen+10;
    if(ny_astack->arguments[ny_astack->carg] == NIL) {
      ny_astack->arguments[ny_astack->carg] =
        NEW_STR(ny_astack->arglens[ny_astack->carg]);
      ny_astack->arguments[ny_astack->carg][0] = '\0';
    } else ny_astack->arguments[ny_astack->carg] =
      RE_STR(ny_astack->arguments[ny_astack->carg],
        ny_astack->arglens[ny_astack->carg]);
  }
  if(slen > 0) strcat(ny_astack->arguments[ny_astack->carg],str);
  if(ny_astack->nargs == 0) ny_astack->nargs++;
}

ny__uncollect()
{
  struct ny_ArgStack *temp;
  unsigned i;

  for(i=0;i <= ny_astack->carg;i++) {
    FREE_M(ny_astack->arguments[i]);
    ny_astack->arguments[i] = NIL;
  }
  FREE_M(ny_astack->arguments);
  FREE_M(ny_astack->arglens);
  temp = ny_astack;
  ny_astack = ny_astack->next;
  FREE_ASTACK(temp);
}

ny__docomma()
{
  ny_astack->carg++; ny_astack->nargs++;
}

/*
 * do each argument according to the current environment,
 * collect the results into strings, call the client
 * function which returns a string and "print it" with
 * the argument function f.
 *
 */
ny__dofunc(f,order,node,msk,type,filter,matched)
int (*f)();
struct ny_Order *order;
struct ny_Node *node;
long unsigned msk;
ny_Selector type;
ny_Boolean filter;
ny_Boolean matched;
{
  struct ny_ArgStack *temp;
  char *str;
  unsigned i;

  temp = ny_astack;
  ny_astack = NEW_ARGS();
  ny_astack->next = temp;
  ny_astack->node = node;
  ny_astack->carg = 0;
  ny_astack->maxargs = 10;
  ny_astack->nargs = 0;
  ny_astack->arguments = (char **)NEW_STR(sizeof(char *)*10);
  ny_astack->arglens = (unsigned *)NEW_STR(sizeof(int)*10);
  for(i=0;i < 10;i++) {
    ny_astack->arguments[i] = NIL;
    ny_astack->arglens[i] = 0;
  }
  ny__dotrans(ny__collect,order->u.func->args,node,msk,type,filter,matched);
  str = (*order->u.func->f)(ny_astack->nargs,ny_astack->arguments);
  ny__uncollect();
  (*f)(str);
  FREE_M(str);
}

ny_Boolean
ny__evalbexp(order,node,msk,type,filter,matched)
struct ny_Order *order;
struct ny_Node *node;
long unsigned msk;
ny_Selector type;
ny_Boolean filter;
ny_Boolean matched;
{
  struct ny_ArgStack *temp;
  int i;
  char *op1,*op2;
  ny_Boolean result;
  
  switch(order->op) {
  case ny_equal:
    temp = ny_astack;
    ny_astack = NEW_ARGS();
    ny_astack->next = temp;
    ny_astack->carg = 0;
    ny_astack->maxargs = 2;
    ny_astack->nargs = 0;
    ny_astack->arguments = (char **)NEW_STR(sizeof(char *)*2);
    ny_astack->arglens = (unsigned *)NEW_STR(sizeof(int)*2);
    for(i=0;i < 2;i++) {
      ny_astack->arguments[i] = NIL;
      ny_astack->arglens[i] = 0;
    }
    ny__dotrans(ny__collect,order->u.br->ifbranch,node,msk,type,filter,matched);
    if(ny_astack->arguments[0] != NIL) {
      op1 = NEW_STR(strlen(ny_astack->arguments[0])+1);
      strcpy(op1,ny_astack->arguments[0]);
    } else { op1 = NEW_STR(1); op1[0] = '\0'; }
    ny__docomma();
    ny__dotrans(ny__collect,order->u.br->elsebranch,node,msk,type,filter,matched);
    if(ny_astack->arguments[1] != NIL) {
      op2 = NEW_STR(strlen(ny_astack->arguments[1])+1);
      strcpy(op2,ny_astack->arguments[1]);
    } else { op2 = NEW_STR(1); op2[0] = '\0'; }
    ny__uncollect();
    if(strcmp(op1,op2) == 0) result = TRUE; else result = FALSE;
    FREE_M(op1); FREE_M(op2);
    break;
  case ny_notequal:
    temp = ny_astack;
    ny_astack = NEW_ARGS();
    ny_astack->next = temp;
    ny_astack->carg = 0;
    ny_astack->maxargs = 2;
    ny_astack->nargs = 0;
    ny_astack->arguments = (char **)NEW_STR(sizeof(char *)*2);
    ny_astack->arglens = (unsigned *)NEW_STR(sizeof(int)*2);
    for(i=0;i < 2;i++) {
      ny_astack->arguments[i] = NIL;
      ny_astack->arglens[i] = 0;
    }
    ny__dotrans(ny__collect,order->u.br->ifbranch,node,msk,type,filter,matched);
    if(ny_astack->arguments[0] != NIL) {
      op1 = NEW_STR(strlen(ny_astack->arguments[0])+1);
      strcpy(op1,ny_astack->arguments[0]);
    } else { op1 = NEW_STR(1); op1[0] = '\0'; }
    ny__docomma();
    ny__dotrans(ny__collect,order->u.br->elsebranch,node,msk,type,filter,matched);
    if(ny_astack->arguments[1] != NIL) {
      op2 = NEW_STR(strlen(ny_astack->arguments[1])+1);
      strcpy(op2,ny_astack->arguments[1]);
    } else { op2 = NEW_STR(1); op2[0] = '\0'; }
    ny__uncollect();
    if(strcmp(op1,op2) == 0) result = FALSE; else result = TRUE;
    FREE_M(op1); FREE_M(op2);
    break;
  case ny_andand:
    result = ny__evalbexp(order->u.br->ifbranch,node,msk,type,filter,matched)
      && ny__evalbexp(order->u.br->elsebranch,node,msk,type,filter,matched);
    break;
  case ny_oror:
    result = ny__evalbexp(order->u.br->ifbranch,node,msk,type,filter,matched)
      || ny__evalbexp(order->u.br->elsebranch,node,msk,type,filter,matched);
    break;
  }
  return(result);
}

ny__docond(f,order,node,msk,type,filter,matched)
int (*f)();
struct ny_Order *order;
struct ny_Node *node;
long unsigned msk;
ny_Selector type;
ny_Boolean filter;
ny_Boolean matched;
{
  /*
   * evaluate the boolean expression.  If TRUE, then perform
   * (traverse) the ifbranch, else the elsebranch.  Simple.
   *
   */
  if(ny__evalbexp(order->u.br->condition,node,msk,type,filter,matched))
    ny__dotrans(f,order->u.br->ifbranch,node,msk,type,filter,matched);
  else
    ny__dotrans(f,order->u.br->elsebranch,node,msk,type,filter,matched);
}