dag.c:/* addlocal - add local p to list of locals for the current block */
dag.c:   if (!p->defined) {
dag.c:      code(Local)->u.var = p;
dag.c:      p->defined = 1;
dag.c:      p->scope = level;
dag.c:/* code - allocate a code node of kind and append to the code list */
dag.c:      for (cp = codelist; cp->kind < Label; )
dag.c:         cp = cp->prev;
dag.c:      if (cp->kind == Jump)
dag.c:   cp->kind = kind;
dag.c:   cp->prev = codelist;
dag.c:   cp->next = 0;
dag.c:   codelist->next = cp;
dag.c:/* dagnode - allocate a dag with the given fields */
dag.c:   p->node.op = op;
dag.c:   if (p->node.kids[0] = l)
dag.c:      ++l->count;
dag.c:   if (p->node.kids[1] = r)
dag.c:      ++r->count;
dag.c:   p->node.syms[0] = sym;
dag.c:   if (sym && sym->shared) p->node.maybe_priv = 0;
dag.c:   else                    p->node.maybe_priv = 1;
dag.c:   p->node.ignore = 0;
dag.c:/* emitcode - emit code for the current function */
dag.c:   for (bp = 0, cp = &codehead; errcnt <= 0 && cp; cp = cp->next)
dag.c:      switch (cp->kind) {
dag.c:         asmcode(cp->u.acode.code, cp->u.acode.argv);
dag.c:         cp->u.block.prev = bp;
dag.c:            stabblock('{',  bp->u.block.level - LOCAL, bp->u.block.locals);
dag.c:            foreach(bp->u.block.identifiers, bp->u.block.level, typestab, (Generic)0);
dag.c:            foreach(bp->u.block.types,       bp->u.block.level, typestab, (Generic)0);
dag.c:            stabblock('}', bp->u.block.level - LOCAL, bp->u.block.locals);
dag.c:         bp = bp->u.block.prev;
dag.c:            stabsym(cp->u.var);
dag.c:         src = cp->u.point.src;
dag.c:            stabline(&cp->u.point.src);
dag.c:         if (cp->u.node == 0)
dag.c:         Pcodepar = cp->par; /* zur auxiliaeren Parameteruebergabe an emit CWK*/
dag.c:         emit(cp->u.node);
dag.c:         int i, k = cp->u.swtch.values[0];
dag.c:         defglobal(cp->u.swtch.table, CODE);
dag.c:         for (i = 0; i < cp->u.swtch.size; i++) {
dag.c:            while (k++ < cp->u.swtch.values[i])
dag.c:               defaddress(cp->u.swtch.deflab->u.l.equatedto);
dag.c:            defaddress(cp->u.swtch.labels[i]->u.l.equatedto);
dag.c:/* fixup - re-aim equated labels to the true label */
dag.c:   for ( ; p; p = p->link)
dag.c:      switch (generic(p->op)) {
dag.c:         if (p->kids[0]->op == ADDRG+P)
dag.c:            p->kids[0]->syms[0] = p->kids[0]->syms[0]->u.l.equatedto;
dag.c:         assert(p->syms[0]);
dag.c:         p->syms[0] = p->syms[0]->u.l.equatedto;
dag.c:/* gencode - generate code for the current function */
dag.c:   cp = codehead.next->next;
dag.c:      if (p->sclass != q->sclass || p->type != q->type) {
dag.c:   codelist->next = cp;
dag.c:   cp->prev = codelist;
dag.c:   for (bp = 0, cp = &codehead; errcnt <= 0 && cp; cp = cp->next)
dag.c:      switch (cp->kind) {
dag.c:          assert(cp->u.node);        /*970903*/
dag.c:          if (cp->u.node->resetshoffset) {
dag.c:         src = cp->u.point.src;
dag.c:         Symbol *p = cp->u.block.locals;
dag.c:         cp->u.block.prev = bp;
dag.c:         blockbeg(&bp->u.block.x);
dag.c:            if ((*p)->ref > 0 || (*p)->initialized || glevel) {
dag.c:               if (! (*p)->shared)
dag.c:                     typestring((*p)->type,(*p)->x.name ));
dag.c:         blockend(&bp->u.block.x);
dag.c:         bp = bp->u.block.prev;
dag.c:         assert(cp->u.var->scope == bp->u.block.level);
dag.c:         local(cp->u.var);
dag.c:         address(cp->u.addr.sym, cp->u.addr.base, cp->u.addr.offset);
dag.c:         if (cp->u.node == 0)
dag.c:         fixup(cp->u.node);
dag.c:         cp->u.node = gen(undag(cp->u.node));
dag.c:         cp->u.node = gen(cp->u.node);
dag.c:/* haskid - does p appear as an operand in t? */
dag.c:      return haskid(p, t->kids[0]) || haskid(p, t->kids[1]); 
dag.c:/* labelnode - list and return a LABEL node for label lab */
dag.c:      equatelab(findlabel(lab), nodelist->syms[0]);
dag.c:/* list - list node p unless it's already listed; return p */
dag.c:   if (p && p->link == 0) {
dag.c:         p->link = nodelist->link;
dag.c:         nodelist->link = p;
dag.c:         p->link = p;
dag.c:/* listnodes - walk tree tp, building and listing dag nodes in execution order */
dag.c:   if (tp->node)
dag.c:      return tp->node;
dag.c:   op = generic(tp->op);
dag.c:         listnodes(tp->kids[0], 0, flab);
dag.c:         r = listnodes(tp->kids[1], 0, flab);
dag.c:         listnodes(tp->kids[0], 0, flab = genlabel(1));
dag.c:         listnodes(tp->kids[1], tlab, 0);
dag.c:      return listnodes(tp->kids[0], flab, tlab);
dag.c:         listnodes(tp->kids[0], tlab, 0);
dag.c:         r = listnodes(tp->kids[1], tlab, 0);
dag.c:         listnodes(tp->kids[0], tlab = genlabel(1), 0);
dag.c:         listnodes(tp->kids[1], 0, flab);
dag.c:      if (tp->u.sym)
dag.c:         addlocal(tp->u.sym);
dag.c:      listnodes(tp->kids[0], 0, flab = genlabel(2));
dag.c:      if (q = tp->kids[1]) {
dag.c:         assert(q->op == RIGHT);
dag.c:         listnodes(q->kids[0], 0, 0);
dag.c:            equatelab(nodelist->syms[0], findlabel(flab + 1));
dag.c:      if (q && q->kids[1]) {
dag.c:         listnodes(q->kids[1], 0, 0);
dag.c:            equatelab(nodelist->syms[0], findlabel(flab + 1));
dag.c:      if (tp->u.sym) {
dag.c:         Tree t = idnode(tp->u.sym);
dag.c:         tp->u.sym->ref = 0;   /* undo idnode's setting ref */
dag.c:      Type ty = unqual(tp->type);
dag.c:      assert(op == CNST+S || ty->u.sym);
dag.c:      if (op == CNST+S || ty->u.sym->addressed)
dag.c:         p = node(tp->op, 0, 0, constant(ty, tp->u.v));
dag.c:         if (tlab && tp->u.v.i != 0)
dag.c:         else if (flab && tp->u.v.i == 0)
dag.c:      if (p) p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      if (p) p->maybe_priv = 0; /*Konstanten haengen nicht von priv.var. ab CWK*/
dag.c:      if (tp->kids[0] && generic(tp->kids[0]->op) == INDIR
dag.c:      &&  tp->kids[1] && generic(tp->kids[1]->op) == ASGN
dag.c:      &&  tp->kids[0]->kids[0] == tp->kids[1]->kids[0]) {   /* e++ */
dag.c:         p = listnodes(tp->kids[0], 0, 0);
dag.c:            for (t = nodelist; ; t = t->link)
dag.c:               if (haskid(p, t->link)) {
dag.c:                  p->link = t->link;
dag.c:                  t->link = p;
dag.c:               } else if (t->link == nodelist) {
dag.c:         listnodes(tp->kids[1], 0, 0);
dag.c:      } else if (tp->kids[1]) {
dag.c:         if (tp->kids[0] && generic(tp->kids[0]->op) == CNST)
dag.c:            tp->kids[0] = 0;
dag.c:         listnodes(tp->kids[0], 0, 0);
dag.c:         p = listnodes(tp->kids[1], tlab, flab);
dag.c:         p = listnodes(tp->kids[0], tlab, flab);
dag.c:      assert(tp->u.sym == 0);
dag.c:      assert(tp->kids[0]);
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      l->ignore = 1;
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);   /* arguments, function name */
dag.c:      r = listnodes(tp->kids[1], 0, 0);   /*function name FL*/
dag.c:      p = newnode(tp->op, l, r, 0);  /* vormals l, r, 0 */
dag.c:      p->syms[0] = (Symbol)talloc(sizeof *p->syms[0]);
dag.c:      BZERO(p->syms[0], struct symbol);
dag.c:      assert(isptr(tp->kids[0]->type) && isfunc(tp->kids[0]->type->type));
dag.c:      p->syms[0]->type = tp->kids[0]->type->type;
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      cfunc->u.f.ncalls++;
dag.c:      listnodes(tp->kids[1], 0, 0);
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      p = newnode(tp->op, l, 0, 0);
dag.c:      p->syms[0] = intconst(tp->type->size);
dag.c:      p->syms[1] = intconst(tp->type->align);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      listnodes(tp->kids[1], 0, 0);
dag.c:      assert(tp->u.sym == 0);
dag.c:         case EQ: op = NE + optype(tp->op); break;
dag.c:         case NE: op = EQ + optype(tp->op); break;
dag.c:         case GT: op = LE + optype(tp->op); break;
dag.c:         case LT: op = GE + optype(tp->op); break;
dag.c:         case GE: op = LT + optype(tp->op); break;
dag.c:         case LE: op = GT + optype(tp->op); break;
dag.c:         op = tp->op;
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      r = listnodes(tp->kids[1], 0, 0);
dag.c:      p->syms[0]->ref++;
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = tp->maybe_pr;
dag.c:      if (tp->kids[0]->op == FIELD) {
dag.c:         Tree x = tp->kids[0]->kids[0];
dag.c:         Field p = tp->kids[0]->u.field;
dag.c:         assert(generic(x->op) == INDIR);
dag.c:         if (fieldsize(p) < 8*p->type->size) {
dag.c:            Tree q = tp->kids[1];
dag.c:            if (q->op == CNST+I && q->u.v.i == 0
dag.c:            ||  q->op == CNST+U && q->u.v.u == 0)
dag.c:            else if (q->op == CNST+I && (q->u.v.i&fmask) == fmask
dag.c:            ||       q->op == CNST+U && (q->u.v.u&fmask) == fmask)
dag.c:            r = listnodes(tp->kids[1], 0, 0);
dag.c:         l = listnodes(tp->kids[0], 0, 0);
dag.c:         r = listnodes(tp->kids[1], 0, 0);
dag.c:      trash(isaddrop(tp->kids[0]->op) && !tp->kids[0]->u.sym->computed ? l : 0);
dag.c:      p = newnode(tp->op, l, r, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->syms[0] = intconst(tp->type->size);
dag.c:      p->syms[1] = intconst(tp->type->align);
dag.c:      p = listnodes(tp->kids[1], 0, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:         simplify(BCOM+U, unsignedtype, cast(tp->kids[1], unsignedtype), 0),
dag.c:         tp->kids[1]->type), 0, 0);
dag.c:      r = listnodes(tp->kids[1], 0, 0);
dag.c:      p = node(tp->op, l, r, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      if (tp->op == RSH+I)
dag.c:         r = listnodes(simplify(NEG+I, inttype, tp->kids[1], 0), 0, 0);
dag.c:         r = listnodes(tp->kids[1], 0, 0);
dag.c:      p = node(tp->op, l, r, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      r = listnodes(tp->kids[1], 0, 0);
dag.c:      p = node(tp->op, l, r, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = tp->maybe_pr;    /*CWK*/
dag.c:      if(p->op == DIV+I || p->op == MOD+I || p->op == MUL+I
dag.c:      || p->op == DIV+U || p->op == MOD+U || p->op == MUL+U)
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      r = listnodes(tp->kids[1], 0, 0);
dag.c:      p = node(tp->op, l, r, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = tp->maybe_pr;    /*CWK*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      p = newnode(tp->op, l, 0, 0);
dag.c:      p->rframes = tp->rframes;        /*CWK*/
dag.c:      p->started = tp->started;        /*CWK*/
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = tp->maybe_pr;    /*CWK*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      p = node(tp->op, l, 0, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = tp->maybe_pr;    /*CWK*/
dag.c:      Type ty = tp->kids[0]->type;
dag.c:         ty = unqual(ty)->type;
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      if (isvolatile(ty) || (isstruct(ty) && unqual(ty)->u.sym->u.s.vfields))
dag.c:         p = newnode(tp->op, l, 0, 0);
dag.c:         p = node(tp->op, l, 0, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = tp->maybe_pr;    /*CWK*/
dag.c:         shnode(LSH, tp->kids[0],
dag.c:            constnode(fieldleft(tp->u.field), inttype)),
dag.c:         constnode(8*tp->type->size - fieldsize(tp->u.field), inttype));
dag.c:      if (tp->u.sym->temporary) {
dag.c:         addlocal(tp->u.sym);
dag.c:         release(tp->u.sym);
dag.c:      p = node(tp->op, 0, 0, tp->u.sym);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = 1;    /*CWK*/
dag.c:      if (tp->u.sym->scope == LABELS)
dag.c:         tp->u.sym->ref++;
dag.c:      p = node(tp->op, 0, 0, tp->u.sym);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = 1;    /*CWK*/
dag.c:      if (tp->u.sym->temporary) {
dag.c:         addlocal(tp->u.sym);
dag.c:         release(tp->u.sym);
dag.c:      p = node(tp->op, 0, 0, tp->u.sym);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = 0;    /*CWK*/
dag.c:      p->shframedepth = shframedepth;   /*970902*/
dag.c:      if (tp->u.sym->scope == LABELS)
dag.c:         tp->u.sym->ref++;
dag.c:      p = node(tp->op, 0, 0, tp->u.sym);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = 0;    /*CWK*/
dag.c:   case ADDRREG:                            /*wie ADDRF, aber Reg-Param. CWK*/
dag.c:      p = node(tp->op, 0, 0, tp->u.sym);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->maybe_priv = 1;    /*CWK*/
dag.c:      p = newnode(tp->op, 0, 0, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:      p->resetshoffset = 0; /*970903*/
dag.c:          p->resetshoffset = 1;        /*970903*/
dag.c:      l = listnodes(tp->kids[0], 0, 0);
dag.c:      p = node(tp->op, l, 0, 0);
dag.c:      p->synchron = tp->synchron;      /*durchreichen CWK*/
dag.c:   return tp->node = p;
dag.c:/* jump - return tree for a jump to lab */
dag.c:   p->ref++;
dag.c:   hilf->ignore = 1;
dag.c:/* newnode - allocate a node with the given fields */
dag.c:   return &dagnode(op, l, r, sym)->node;
dag.c:/* node - search for a node with the given fields, or allocate it */
dag.c:   int i = (opindex(op)^((unsigned)sym>>2))&(NBUCKETS-1);
dag.c:   for (p = buckets[i]; p; p = p->hlink)
dag.c:      if (p->node.op == op && p->node.syms[0] == sym
dag.c:      && p->node.kids[0] == l && p->node.kids[1] == r)
dag.c:         return &p->node;
dag.c:   p->hlink = buckets[i];
dag.c:   return &p->node;
dag.c:/* printdag - print dag p on fd, or the node list if p == 0 */
dag.c:            p = p->link;
dag.c:/* printdag1 - recursively print dag p */
dag.c:      printdag1(p->kids[i], fd, lev + 1);
dag.c:/* printnode - print fields of dag p */
dag.c:      fprint(fd, "%s count=%d", opname(p->op), p->count);
dag.c:      for (i = 0; i < MAXKIDS && p->kids[i]; i++)
dag.c:         fprint(fd, " #%d", nodeid((Tree)p->kids[i]));
dag.c:      for (i = 0; i < MAXSYMS && p->syms[i]; i++)
dag.c:         fprint(fd, " %s", p->syms[i]->name);
dag.c:/* remove - remove node p from the node list */
dag.c:      for ( ; q->link != p && q->link != nodelist; q = q->link)
dag.c:      assert(q->link == p);
dag.c:      q->link = p->link;
dag.c:/* reset - clear the dag */
dag.c:/* trash - preclude future links to rvalue of p or all values */
dag.c:            if (generic(q->node.op) == INDIR && (!isaddrop(q->node.kids[0]->op)
dag.c:            || q->node.kids[0]->syms[0] == p->syms[0])) {
dag.c:               *r = q->hlink;
dag.c:               --nodecount;
dag.c:               r = &q->hlink;
dag.c:/* typestab - emit stab entries for p */
dag.c:   if (!isfunc(p->type) && (p->sclass == EXTERN || p->sclass == STATIC))
dag.c:   else if (p->sclass == TYPEDEF || p->sclass == 0)
dag.c:/* undag - replace multiply-referenced nodes in nodelist by temporaries, return new nodelist */
dag.c:   for (pred = &head; p = pred->link; ) {
dag.c:       * p->link == pred;
dag.c:       * undag1(x, p) adds predecessors and maintains p->link == p->link->link.
dag.c:      Node succ = p->link;
dag.c:      p->link = pred;
dag.c:      if (generic(p->op) == INDIR) {
dag.c:         assert(p->count >= 1);
dag.c:         pred = p->link;
dag.c:         pred->link = succ;
dag.c:         p->link = 0;
dag.c:      } else if (generic(p->op) == CALL && p->count > 1) {
dag.c:          * p->link is p's predecessor,
dag.c:         assert(p->link && generic(p->link->op) == ASGN && p->link->kids[1] == p);
dag.c:         pred = p->link;
dag.c:         pred->link = succ;
dag.c:          * re-insert p into the node list
dag.c:         for (q = &head; q && q->link != pred; q = q->link)
dag.c:         q->link = p;
dag.c:         p->link = pred;
dag.c:         assert(p->count == 0 || generic(p->op) == CALL && p->count == 1);
dag.c:          * advance pred so that pred->link == succ
dag.c:         p->link = succ;
dag.c:/* undag1 - return a reference to the temporary holding value of p, or p */
dag.c:   else if (p->syms[2]) {
dag.c:      e = newnode(INDIR + (isunsigned(p->syms[2]->type) ? I : ttob(p->syms[2]->type)),
dag.c:         newnode(ADDRL+P, 0, 0, p->syms[2]), 0, 0);
dag.c:      e->count = 1;
dag.c:      if (--p->count == 1) {
dag.c:         /* fprint(2, "releasing %s from ", p->syms[2]->name); printnode(p, 2, 1);
dag.c:         release(p->syms[2]); */
dag.c:         p->syms[2] = 0;
dag.c:   } else if (p->count <= 1) {
dag.c:      p->kids[0] = undag1(p->kids[0], root);
dag.c:      p->kids[1] = undag1(p->kids[1], root);
dag.c:   } else if (p->op == ADDRL+P || p->op == ADDRF+P) {
dag.c:      p = newnode(p->op, 0, 0, p->syms[0]);
dag.c:      p->count = 1;
dag.c:   } else if (generic(p->op) == INDIR
dag.c:   && (p->kids[0]->op == ADDRL+P || p->kids[0]->op == ADDRF+P)
dag.c:   && p->kids[0]->syms[0]->sclass == REGISTER && p != root) {
dag.c:      p = newnode(p->op, 
dag.c:         newnode(p->kids[0]->op, 0, 0, p->kids[0]->syms[0]), 0, 0);
dag.c:      p->count = 1;
dag.c:   } else if (p->op == INDIR+B) {
dag.c:      --p->count;
dag.c:      p = newnode(p->op, p->kids[0], 0, 0);
dag.c:      p->count = 1;
dag.c:      p->kids[0] = undag1(p->kids[0], root);
dag.c:      assert(optype(p->op) > 0 && optype(p->op) < sizeof btot/sizeof btot[0]);
dag.c:      p->syms[2] = temporary(REGISTER, *btot[optype(p->op)]);
dag.c:      /* fprint(2, "allocating %s to ", p->syms[2]->name); printnode(p, 2, 1); */
dag.c:      if (!p->syms[2]->defined) {
dag.c:         p->syms[2]->scope = LOCAL;
dag.c:         p->syms[2]->ref = 1;
dag.c:         local(p->syms[2]);
dag.c:         p->syms[2]->defined = 1;
dag.c:      p->kids[0] = undag1(p->kids[0], root);
dag.c:      p->kids[1] = undag1(p->kids[1], root);
dag.c:      e = newnode(ASGN + (isunsigned(p->syms[2]->type) ? I : ttob(p->syms[2]->type)),
dag.c:         newnode(ADDRL+P, 0, 0, p->syms[2]), p, 0);
dag.c:      e->syms[0] = intconst(p->syms[2]->type->size);
dag.c:      e->syms[1] = intconst(p->syms[2]->type->align);
dag.c:       * root->link is the root's predecessor;
dag.c:      root->link = root->link->link = e;
dag.c:      e->link = root;
dag.c:/* walk - list tree tp, generate code for current node list, reset node list */
dag.c:      codelist->u.node = nodelist->link;
dag.c:      nodelist->link = 0;
decl.c:char *declaringfunction = 0; /*CWK: zum Durchreichen des Fn-Namens an Parameterdekl*/
decl.c:/* checklab - check for undefined labels; called at ends of functions */
decl.c:   if (!p->defined)
decl.c:      error("undefined label `%s'\n", p->name);
decl.c:   p->defined = 1;
decl.c:/* checkref - check for unreferenced variables; called at ends of blocks */
decl.c:   if (p->scope >= PARAM && isvolatile(p->type))
decl.c:      p->addressed = 1;
decl.c:   if (Aflag >= 2 && p->defined && p->ref == 0) {
decl.c:      if (p->sclass == STATIC)
decl.c:         warning("static `%t %s' is not referenced\n", p->type, p->name);
decl.c:      else if (p->scope == PARAM)
decl.c:         warning("parameter `%t %s' is not referenced\n", p->type, p->name);
decl.c:      else if (p->scope > PARAM && p->sclass != EXTERN)
decl.c:         warning("local `%t %s' is not referenced\n", p->type, p->name);
decl.c:   } else if (p->scope >= PARAM + (regcount > 0) && p->sclass == AUTO
decl.c:   && !p->addressed && isscalar(p->type) && p->ref >= 3000)
decl.c:      p->sclass = REGISTER;
decl.c:   if (p->scope > PARAM && (q = lookup(p->name, externals))) {
decl.c:      q->ref += p->ref;
decl.c:   } else if (p->sclass == STATIC && !p->defined)
decl.c:      if (p->ref > 0)
decl.c:         error("undefined static `%t %s'\n", p->type, p->name);
decl.c:      else if (isfunc(p->type))
decl.c:         warning("undefined static `%t %s'\n", p->type, p->name);
decl.c:/* compound - { ( decl ; )* statement* } */
decl.c:   cp->u.block.bnumber = ++bnumber;
decl.c:   cp->u.block.level = level;
decl.c:   if (level == LOCAL && isstruct(freturn(cfunc->type))) {
decl.c:      retv = genident(AUTO, ptr(freturn(cfunc->type)), level);
decl.c:      retv->defined = 1;
decl.c:      retv->initialized = 1;
decl.c:          || t == ID && tsym && tsym->sclass == TYPEDEF
decl.c:   cp->u.block.locals = (Symbol *)ltoa(registers, (Generic *)talloc((nregs + length(autos) + 1)*sizeof(Symbol)));
decl.c:   ltoa(autos, (Generic *)&cp->u.block.locals[nregs]);
decl.c:   myp = cp->u.block.locals;
decl.c:/*        ((*myp)->ref > 0 
decl.c:         || (*myp)->initialized || glevel )
decl.c:       && (*myp)->shared )
decl.c:        k+=(*myp)->type->size;   /*980203 statt ++ */
decl.c:      hilf->par = k;  /* shspace( k );   970902 backpatchen*/
decl.c:   for (i = nregs; p = cp->u.block.locals[i]; i++) {
decl.c:      for (j = i; j > nregs && cp->u.block.locals[j-1]->ref < p->ref; j--)
decl.c:         cp->u.block.locals[j] = cp->u.block.locals[j-1];
decl.c:      cp->u.block.locals[j] = p;
decl.c:   cp->u.block.identifiers = identifiers;
decl.c:   cp->u.block.types = types;
decl.c:/* dclglobal - called from decl to declare a global */
decl.c:   if ((p = lookup(id, identifiers)) && p->scope == GLOBAL) {
decl.c:      if (p->sclass != TYPEDEF && eqtype(ty, p->type, 1))
decl.c:         ty = composite(ty, p->type);
decl.c:            p->name, &p->src);
decl.c:      if (!isfunc(ty) && p->defined && t == '=')
decl.c:            p->name, &p->src);
decl.c:      if (p->sclass == STATIC && sclass == AUTO
decl.c:      ||  p->sclass != STATIC && sclass == STATIC)
decl.c:            p->name, &p->src);
decl.c:   } else if (sclass == STATIC && !isfunc(ty) && ty->size == 0 && t != '=')
decl.c:   if (p && isfunc(ty) && (p->sync&&(sy==ASYNCF) || !p->sync&&(sy==SYNCF))) /*CWK*/
decl.c:            p->name, &p->src);
decl.c:   if (p && isfunc(ty) && (ty->u.proto) && *(ty->u.proto)
decl.c:         &&(p->sharedparameters != (*(ty->u.proto))->sharedparams))
decl.c:             p->name, &p->src);                                          /*CWK*/
decl.c:   if (p == 0 || p->scope != GLOBAL)
decl.c:   p->type = ty;
decl.c:   if (isfunc(ty) && ty->u.proto && *(ty->u.proto)) {  /*CWK*/
decl.c:      p->sharedparameters = (*(ty->u.proto))->sharedparams;   /*CWK*/
decl.c:      if (/* sy==ASYNCF && */ p->sharedparameters)
decl.c:      p->regparameters = (*(ty->u.proto))->regparams;         /*CWK*/
decl.c:   if (p->sclass == 0 || sclass != EXTERN && p->sclass != STATIC)
decl.c:      p->sclass = sclass;
decl.c:   if (p->sclass != STATIC) {
decl.c:   p->sync = (sy==SYNCF)? 1 : 0;  /*CWK, 980728*/
decl.c:   /*if (ty && isptr(ty) && isfunc(ty->type))  *CWK*
decl.c:     p->shared = (ty->sharity==1)? 1:0; else     */
decl.c:   p->shared = (styp==SHARED)? 1:0;
decl.c:   p->src = *pos;
decl.c:   if (!p->defined)
decl.c:   if (q = lookup(p->name, externals)) {
decl.c:      if ((p->sclass == AUTO ? EXTERN : p->sclass) != q->sclass
decl.c:      || isfunc(ty)&&(p->sync != q->sync)                       /*CWK*/
decl.c:      || !isfunc(ty)&&(p->shared != q->shared)   /*CWK*/
decl.c:      || !eqtype(p->type, q->type, 1))
decl.c:            p->name, &q->src);
decl.c:      p->ref += q->ref;
decl.c:   if (!isfunc(p->type))
decl.c:      error("illegal initialization for `%s'\n", p->name);
decl.c:      initializer(p->type, 0, p);
decl.c:/* dcllocal - called from decl to declare a local */
decl.c:       && (q->scope >= level || q->scope == PARAM && level == PARAM+1))
decl.c:      if (sclass == EXTERN && q->sclass == EXTERN && eqtype(q->type, ty, 1))
decl.c:         ty = composite(ty, q->type);
decl.c:            q->name, &q->src);
decl.c:   p->type = ty;
decl.c:   if (isfunc(ty) && ty->u.proto && *(ty->u.proto)) {  /*CWK*/
decl.c:      p->sharedparameters = (*(ty->u.proto))->sharedparams;   /*CWK*/
decl.c:      p->regparameters = (*(ty->u.proto))->regparams;         /*CWK*/
decl.c:   p->sclass = sclass;
decl.c:   /*if (ty && isptr(ty) && isfunc(ty->type))  *CWK*
decl.c:     p->shared = (ty->sharity==1)? 1:0; else */
decl.c:   p->shared = (styp==SHARED)? 1:0; /*CWK*/
decl.c:   p->sync = (sy==SYNCF)? 1 : 0 ;  /*980728*/
decl.c:   if (p->shared)
decl.c:   p->shframedepth = shframedepth;
decl.c:   p->src = *pos;
decl.c:      if (q && q->scope == GLOBAL && q->sclass == STATIC) {
decl.c:         p->sclass = STATIC;
decl.c:         p->scope = GLOBAL;
decl.c:         p->scope = level;
decl.c:         r = install(p->name, &externals, 1);
decl.c:         r->src = p->src;
decl.c:         r->type = p->type;
decl.c:         if (isfunc(p->type) && p->type->u.proto && *(p->type->u.proto)) {  /*CWK*/
decl.c:           r->sharedparameters = (*(p->type->u.proto))->sharedparams;   /*CWK*/
decl.c:           r->regparameters = (*(p->type->u.proto))->regparams;         /*CWK*/
decl.c:         r->sclass = p->sclass;
decl.c:              && q->sclass != TYPEDEF && q->sclass != ENUM)
decl.c:         if (q && isfunc(ty) && (p->sync != q->sync))    /*CWK*/
decl.c:                    q->name, &q->src);   /*CWK 971121*/
decl.c:         if (q && (p->shared != q->shared))    /*CWK*/
decl.c:                    q->name, &q->src);   /*CWK 971121*/
decl.c:      if (r && ((r->sclass == AUTO ? EXTERN : r->sclass) != p->sclass
decl.c:      || !eqtype(r->type, p->type, 1)))
decl.c:            r->name, &r->src);
decl.c:      if (!p->defined)
decl.c:         if (p->type->size > 0) {
decl.c:            defglobal(p, (p->shared)? GSBSS : BSS);    /*CWK*/
decl.c:            space(p->type->size);
decl.c:            error("undefined size for `%t %s'\n", p->type, p->name);
decl.c:      p->defined = 1;
decl.c:      p->defined = 1;
decl.c:      p->defined = 1;
decl.c:      if (isscalar(p->type) || isstruct(p->type) && t != '{') {
decl.c:         Type ty = p->type;
decl.c:         if (!isconst(ty) && (!isarray(ty) || !isconst(ty->type)))
decl.c:         if (isarray(p->type) && p->type->size == 0 && q->type->size > 0)
decl.c:            p->type = array(p->type->type, q->type->size/q->type->type->size, 0);
decl.c:      p->initialized = 1;
decl.c:      p->ref = 0;
decl.c:   if (p->sclass == AUTO && isarray(p->type) && p->type->type->size > 0
decl.c:   && p->type->align < STRUCT_ALIGN)
decl.c:      p->type = array(p->type->type,
decl.c:         p->type->size/p->type->type->size, STRUCT_ALIGN);
decl.c:   if (!isfunc(p->type) && p->defined && p->type->size <= 0)
decl.c:         error("undefined size for `%t %s'\n", p->type, id);
decl.c:/* dclparam - called from decl to declare a parameter */
decl.c:   if ((p = lookup(id, identifiers)) && p->scope == level
decl.c:   && (p->defined || p->type == 0 && ty == 0))
decl.c:         id, &p->src);
decl.c:   else if (p == 0 || p->scope < level)
decl.c:   if (ty && isfunc(ty) && ty->u.proto && *(ty->u.proto)) {  /*CWK*/
decl.c:      p->sharedparameters = (*(ty->u.proto))->sharedparams;   /*CWK*/
decl.c:      p->regparameters = (*(ty->u.proto))->regparams;         /*CWK*/
decl.c:   p->sclass = sclass;
decl.c:   /*if (ty && isptr(ty) && isfunc(ty->type))
decl.c:     p->shared = (ty->sharity==1)? 1:0; else*/
decl.c:   p->shared = (styp==SHARED)? 1:0;
decl.c:   p->sync = (sy==SYNCF)? 1 :0;   /*980728*/
decl.c:   p->src = *pos;
decl.c:   if (p->type = ty)
decl.c:      p->defined = 1;
decl.c:/* dclr - declarator */
decl.c:   for (ty = dclr1(id, lev); ty; ty = ty->type)
decl.c:      switch (ty->op) {
decl.c:         if (isfunc(basety->type) || basety->synchronicity) {   /*CWK*/
decl.c:            basety->synchronicity = ty->synchronicity;
decl.c:            warning("uebertrage synchronicity: %d\n", ty->synchronicity); } /**/
decl.c:         basety = func(basety, ty->u.proto);
decl.c:         basety = array(basety, ty->size, 0);
decl.c:         basety = qual(ty->op, basety);
decl.c:   if (Aflag >= 2 && basety->size > 32767)
decl.c:/* dclr1 - ( id |  * ( const | volatile )* | '(' dclr1 ')' ) ( (...) | [...] )* */
decl.c:         ty->type = dclr1(id, lev);
decl.c:          || t == ID && tsym && tsym->sclass == TYPEDEF) {
decl.c:         ty->u.proto = parameters(lev);
decl.c:         ty->u.proto = parameters(lev);
decl.c:         ty->size = n;
decl.c:/* decl - type [ dclr ( , dclr )* ] ; */
decl.c:                      || t == ID && tsym && tsym->sclass == TYPEDEF)) {
decl.c:/* doextern - import external declared in a block, if necessary, propagate flags */
decl.c:   if (q = lookup(p->name, identifiers))
decl.c:      q->ref += p->ref;
decl.c:/* doglobal - finalize tentative definitions, check for imported symbols */
decl.c:   if (p->sclass == TYPEDEF || p->sclass == ENUM || p->defined) {
decl.c:      if (Pflag && !isfunc(p->type) && !p->generated)
decl.c:         printdecl(p, p->type);
decl.c:   if (p->sclass == EXTERN || isfunc(p->type))
decl.c:   else if (!isfunc(p->type)) {
decl.c:      if (p->type->size > 0) {
decl.c:         /*if (p->generated) printdecl(p, p->type);testweise980721*/
decl.c:         defglobal(p, (p->shared)? GSBSS : BSS);    /*CWK*/
decl.c:         space(p->type->size);
decl.c:         error("undefined size for `%t %s'\n", p->type, p->name);
decl.c:      p->defined = 1;
decl.c:      if (Pflag && !p->generated)
decl.c:         printdecl(p, p->type);
decl.c:/* enumdecl - enum [ id ] [ { id [ = cexpr ] ( , id [ = cexpr ] )* } ] */
decl.c:      int n = 0, min, max, k = -1;
decl.c:         if (tsym && tsym->scope == level)
decl.c:               token, &tsym->src);
decl.c:               error("overflow in value for enumeration constant `%s'\n", p->name);
decl.c:         p->src = s;
decl.c:         p->type = ty;
decl.c:         p->sclass = ENUM;
decl.c:         p->u.value = k;
decl.c:            warning("non-ANSI trailing comma in enumerator list\n");
decl.c:         ty->type = unsignedchar;
decl.c:      else if (min >= -128 && max <= 127)
decl.c:         ty->type = signedchar;
decl.c:      else if (min >= 0 && max <= 65535 && unsignedshort->size >= 2)
decl.c:         ty->type = unsignedshort;
decl.c:      else if (min >= -32768 && max <= 32767 && shorttype->size >= 2)
decl.c:         ty->type = shorttype;
decl.c:         ty->type = inttype;
decl.c:      ty->size = ty->type->size;
decl.c:      ty->align = ty->type->align;
decl.c:      ty->u.sym->u.idlist = (Symbol *)ltoa(idlist, (Generic *)alloc((length(idlist) + 1)*sizeof(Symbol)));
decl.c:      ty->u.sym->defined = 1;
decl.c:   } else if ((p = lookup(tag, types)) && p->type->op == ENUM) {
decl.c:      ty = p->type;
decl.c:      ty->type = inttype;
decl.c:/* fields - ( type dclr ( , dclr )* ; )* */
decl.c:        || t == ID && tsym && tsym->sclass == TYPEDEF) {
decl.c:               fty = fty->type;
decl.c:               error("`%t' is an illegal bit field type\n", p->type);
decl.c:               p->type = inttype;
decl.c:            p->to = intexpr(0, 0);
decl.c:            if (p->to > 8*inttype->size || p->to < 0) {
decl.c:               error("`%d' is an illegal bit field size\n", p->to);
decl.c:               p->to = 8*inttype->size;
decl.c:            } else if (p->to == 0 && id) {
decl.c:               warning("extraneous 0-width bit field `%t %s' ignored\n",
decl.c:                  p->type, id);
decl.c:               p->name = stringd(genlabel(1));
decl.c:            p->to++;
decl.c:         } else if (id == 0 && isstruct(p->type)) {
decl.c:               warning("non-ANSI unnamed substructure in `%t'\n", ty);
decl.c:            if (p->type->size == 0)
decl.c:               error("undefined size for field `%t'\n", p->type);
decl.c:            p->name = 0;
decl.c:            else if (p->type->size == 0)
decl.c:               error("undefined size for field `%t %s'\n", p->type, id);
decl.c:   ty->align = STRUCT_ALIGN;
decl.c:#define add(x,n) (x > INT_MAX - (n) ? (overflow = 1, x) : x + n)
decl.c:   q = &ty->u.sym->u.s.flist;
decl.c:   for (p = *q; p; p = p->link) {
decl.c:      int a = p->type->align ? p->type->align : 1;
decl.c:      if (ty->op == UNION) {
decl.c:         if (p->to)
decl.c:            a = unsignedtype->align;
decl.c:      } else if (bits == 0 || p->to <= 1
decl.c:      || bits - 1 + p->to - 1 > 8*unsignedtype->size) {
decl.c:         if (p->to)
decl.c:            a = unsignedtype->align;
decl.c:         add(off, a - 1);
decl.c:      if (a > ty->align)
decl.c:         ty->align = a;
decl.c:      p->offset = off;
decl.c:      if (p->to) {
decl.c:         p->from = bits - 1;
decl.c:         p->to = p->from + p->to - 1;
decl.c:         bits += p->to - p->from;
decl.c:         if (ty->op == UNION && (bits + 6)/8 > ty->size)
decl.c:            ty->size = (bits + 6)/8;
decl.c:      } else if (ty->op == STRUCT)
decl.c:         off = add(off, p->type->size);
decl.c:      else if (p->type->size > ty->size)
decl.c:         ty->size = p->type->size;
decl.c:      if (isconst(p->type))
decl.c:         ty->u.sym->u.s.cfields = 1;
decl.c:      if (isvolatile(p->type))
decl.c:         ty->u.sym->u.s.vfields = 1;
decl.c:      if (p->name == 0 || *p->name > '9') {
decl.c:         q = &p->link;
decl.c:   if (ty->op == STRUCT)
decl.c:      ty->size = off;
decl.c:   else if (off > ty->size)
decl.c:      ty->size = off;
decl.c:   add(ty->size, ty->align - 1);
decl.c:   ty->size = roundup(ty->size, ty->align);
decl.c:      ty->size = INT_MAX&(~(ty->align - 1));
decl.c:/* finalize - finalize tentative definitions, constants, check unref'd statics */
decl.c:/* funcdecl - ... ( ... ) decl* compound */
decl.c:   if (isstruct(freturn(ty)) && freturn(ty)->size == 0)
decl.c:      callee[--n] = p;
decl.c:      if (*p->name >= '1' && *p->name <= '9')
decl.c:   if (ty->u.proto) {
decl.c:      /*fprint(2,"vor newstyle(%s): u.proto->sharedparams = %d\n", id, (*(ty->u.proto))->sharedparams);  *CWK*/
decl.c:      if (p->type->size == 0) {
decl.c:         error("undefined size for parameter `%t %s'\n", p->type, p->name);
decl.c:         caller[i]->type = p->type = inttype;
decl.c:   if ((p = lookup(id, identifiers)) && isfunc(p->type)) {
decl.c:      if (p->defined)
decl.c:            p->name, &p->src);
decl.c:         use(p, p->src);
decl.c:   if (sy==ASYNCF) { cfunc->sync = 0; }  /*CWK*/
decl.c:   else            { cfunc->sync = 1; }
decl.c:   cfunc->u.f.pt[0] = pt;
decl.c:      cfunc->u.f.label = genlabel(1);
decl.c:   cfunc->u.f.callee = callee;
decl.c:   cfunc->defined = 1;
decl.c:      printproto(cfunc, cfunc->u.f.callee);
decl.c:   bnumber = -1;
decl.c:   codelist->next = 0;
decl.c:      ncalled = findfunc(cfunc->name, pt.file);
decl.c:   cfunc->u.f.pt[2] = definept(0)->u.point.src;
decl.c:   for (rp = codelist; rp->kind < Label; rp = rp->prev)
decl.c:   if (rp->kind != Jump) {
decl.c:      if (cfunc->u.f.label == 0)
decl.c:      if (freturn(cfunc->type) != voidtype
decl.c:      && (freturn(cfunc->type) != inttype || Aflag >= 1))
decl.c:   if (cfunc->u.f.label) {
decl.c:      definelab(cfunc->u.f.label);
decl.c:   if (cfunc->sclass != STATIC)
decl.c:         callee[i]->sclass = AUTO;
decl.c:      if (isstruct(caller[i]->type)) {
decl.c:         caller[i]->type = ptr(caller[i]->type);
decl.c:         callee[i]->type = ptr(callee[i]->type);
decl.c:         caller[i]->structarg = callee[i]->structarg = 1;
decl.c:   function(cfunc, caller, callee, cfunc->u.f.ncalls);
decl.c:   cfunc->u.f.pt[1] = src;
decl.c:/* newstyle - process function arguments for new-style definition */
decl.c:      caller[i]->type = promote(callee[i]->type);
decl.c:      if (callee[i]->sclass == REGISTER) {
decl.c:         caller[i]->sclass = AUTO;
decl.c:/* oldparam - check that p is an old-style parameter, and patch callee[i] */
decl.c:      if (p->name == callee[i]->name) {
decl.c:   error("declared parameter `%s' is missing\n", p->name);
decl.c:/* oldstyle - process function arguments for old-style definition */
decl.c:         || t == ID && tsym && tsym->sclass == TYPEDEF)
decl.c:      if (p->type == 0) {
decl.c:         p->type = inttype;
decl.c:         p->defined = 1;
decl.c:      if (p->sclass == REGISTER) {
decl.c:         caller[i]->sclass = AUTO;
decl.c:      if (unqual(p->type) == floattype)
decl.c:         caller[i]->type = doubletype;
decl.c:         caller[i]->type = promote(p->type);
decl.c:   if ((p = lookup(name, identifiers)) && p->scope == GLOBAL
decl.c:   && isfunc(p->type) && p->type->u.proto) {
decl.c:      Type *proto = p->type->u.proto;
decl.c:         if (eqtype(unqual(*proto), unqual(caller[i]->type), 1) == 0)
decl.c:      if (*proto && (*proto != voidtype || proto != p->type->u.proto) || caller[i])
decl.c:      ty = func(freturn(ty), p->type->u.proto);
decl.c:/* parameters - [id ( , id )* | type dclr ( , type dclr )*] */
decl.c:   int akt_parreg = 1;  /*Nummer des ersten Parameter-Registers. CWK*/
decl.c:       || t == ID && tsym && tsym->sclass == TYPEDEF) {
decl.c:                  sharedpar = sharedpar | (1<<(k-1));
decl.c:         if (t == ID && (tsym == 0 || tsym->sclass != TYPEDEF)
decl.c:            p->parreg = 0;  /*CWK: default*/
decl.c:               sharedpar = sharedpar | (1<<(n-1)); /*CWK*/
decl.c:                  p->parreg = akt_parreg++;  /*CWK*/
decl.c:                  regpar = regpar | (1<<(n-1));  /*CWK*/
decl.c:            list = append(p->type, list);
decl.c:      (*proto)->sharedparams = sharedpar;   /*CWK*/
decl.c:      (*proto)->regparams = regpar;  /*CWK*/
decl.c:/* checkparam - check for old-style param list; called at ends of parameters */
decl.c:   if (p->type == 0)
decl.c:      error("extraneous specification for formal parameter `%s'\n", p->name);
decl.c:/* program - decl* */
decl.c:/* structdcl - ( struct | union )  ( [ id ] { ( field; )+ } | id ) */
decl.c:         ty->u.sym->src = pos;
decl.c:      if (kind[t] == CHAR || t == ID && tsym && tsym->sclass == TYPEDEF)
decl.c:      ty->u.sym->defined = 1;
decl.c:   } else if (*tag && (p = lookup(tag, types)) && p->type->op == op) {
decl.c:      if (t == ';' && p->scope < level)
decl.c:      ty = p->type;
decl.c:         use(ty->u.sym, pos);
decl.c:/* tnode - allocate a type node */
decl.c:   ty->op = op;
decl.c:   ty->type = type;
decl.c:      ty->sharedparams = type->sharedparams;
decl.c:      ty->regparams = type->regparams;
decl.c:   else ty->sharedparams = ty->regparams = 0;
decl.c:/* type - parse basic storage class and type specification */
decl.c:         ty = tsym->type;
decl.c:         if (tsym && tsym->sclass == TYPEDEF
decl.c:            ty = tsym->type;
decl.c:            t = tt = ty->op;
decl.c:/* typename - type dclr */
enode.c:/* C compiler: type-checking and tree construction for expressions */
enode.c:/* addnode - construct tree for l + r */
enode.c:   if (isarith(l->type) && isarith(r->type)) {
enode.c:      ty = binary(l->type, r->type);
enode.c:   } else if (isptr(l->type) && isint(r->type))
enode.c:   else if (isptr(r->type) && isint(l->type)) {
enode.c:      ty = unqual(r->type);
enode.c:      if ((n = ty->type->size) == 0)
enode.c:         error("unknown size of type `%t'\n", ty->type);
enode.c:      l = cast(l, promote(l->type));
enode.c:/* andnode - construct tree for l [&& ||] r */
enode.c:   if (!isscalar(l->type) || !isscalar(r->type))
enode.c:/* asgnnode - construct tree for l = r */
enode.c:   if (isptr(l->type) && isfunc(l->type->type) && isfunc(r->type)) {  /*CWK*/
enode.c:     if (l->kids[0]->u.sym->sync != r->u.sym->sync)
enode.c:   /*if (l->kids[0]->u.sym->shared != r->u.sym->shared)
enode.c:     if (l->kids[0]->u.sym->sharedparameters != r->u.sym->sharedparameters)
enode.c:     if (l->kids[0]->u.sym->regparameters != r->u.sym->regparameters)
enode.c:   if ((ty = assign(l->type, r)) == 0) {
enode.c:      if (r->type == voidtype)
enode.c:      ty = r->type;
enode.c:   if (l->op != FIELD)
enode.c:   aty = l->type;
enode.c:      aty = unqual(aty)->type;
enode.c:   if (isconst(aty) || (isstruct(aty) && unqual(aty)->u.sym->u.s.cfields))
enode.c:      if (isaddrop(l->op) && !l->u.sym->computed && !l->u.sym->generated)
enode.c:         error("assignment to const identifier `%s'\n", l->u.sym->name);
enode.c:   if (l->op == FIELD && fieldsize(l->u.field) < 8*l->u.field->type->size)
enode.c:      if (isunsigned(l->u.field->type))
enode.c:            constnode(fieldmask(l->u.field), unsignedtype));
enode.c:         int n = 8*l->u.field->type->size - fieldsize(l->u.field);
enode.c:         if (r->op == CNST+I)
enode.c:            r = constnode(r->u.v.i<<n, inttype);
enode.c:      if (r->op == RIGHT && r->kids[0] && r->kids[0]->op == CALL+B
enode.c:      && isaddrop(l->op)) {
enode.c:         r = r->kids[0];   /* CALL+B node */
enode.c:         release(r->kids[1]->u.sym);
enode.c:         r = tree(RIGHT, l->type,
enode.c:            tree(CALL+B, r->kids[0]->type, r->kids[0], l),
enode.c:            retype(isarray(l->u.sym->type) ? idnode(l->u.sym) : addrof(idnode(l->u.sym)), l->type));
enode.c:      if (r->op == INDIR+B)
enode.c:/* binary - usual arithmetic conversions, return target type */
enode.c:/* bitnode - construct tree for l [& | ^ %] r */
enode.c:   if (isint(l->type) && isint(r->type)) {
enode.c:       ty = binary(l->type, r->type);
enode.c:/* callnode - construct call node to f, return type ty, arguments args */
enode.c:   int maybepr = f->maybe_pr;  /*CWK*/
enode.c:      f = tree(RIGHT, f->type, args, f);
enode.c:      if (ty->size == 0)
enode.c:         rty = unqual(ty)->type;
enode.c:   p->maybe_pr = maybepr;   /*CWK*/
enode.c:/* cmpnode - construct tree for l [< <= >= >] r */
enode.c:   if (isarith(l->type) && isarith(r->type)) {
enode.c:      ty = binary(l->type, r->type);
enode.c:   } else if (compatible(l->type, r->type)) {
enode.c:/* compatible - are ty1 & ty2 sans qualifiers pointers to compatible object or incomplete types? */
enode.c:         ty1 = unqual(ty1->type);
enode.c:         ty2 = unqual(ty2->type);
enode.c:/* condnode - build a tree for e ? l : r */
enode.c:   Type ty = 0, lty = l->type, rty = r->type;
enode.c:      lty = lty->type;
enode.c:      rty = rty->type;
enode.c:   } else if (e->op == CNST+D || e->op == CNST+F) {
enode.c:      return retype(e->u.v.d != 0.0 ? l : r, ty);
enode.c:   } else if (generic(e->op) == CNST) {
enode.c:      return retype(e->u.v.u ? l : r, ty);
enode.c:   } else if (ty != voidtype && ty->size > 0) {
enode.c:      Opcode op = generic(e->op);
enode.c:      && r->op == CNST+I && r->u.v.i == 0
enode.c:      && assign(e->type, r)) {
enode.c:   p->u.sym = t1;
enode.c:/* constnode - return a tree for a constant n of type ty (int or unsigned) */
enode.c:   p->u.v.u = n;
enode.c:/* eqnode - construct tree for l [== !=] r */
enode.c:   if (isint(l->type) && isptr(r->type))
enode.c:   if (isptr(l->type) && isint(r->type)) {
enode.c:      if (r->op != CNST+U || r->u.v.u)
enode.c:   if (isptr(l->type) && !isfunc(l->type->type)
enode.c:   && (r->type == voidptype || unqual(r->type->type) == voidtype)
enode.c:   ||  isptr(r->type) && !isfunc(r->type->type)
enode.c:   && (l->type == voidptype || unqual(l->type->type) == voidtype)) {
enode.c:/* mulnode - construct tree for l [* /] r */
enode.c:   if (isarith(l->type) && isarith(r->type)) {
enode.c:      ty = binary(l->type, r->type);
enode.c:/* shnode - construct tree for l [>> <<] r */
enode.c:   if (isint(l->type) && isint(r->type)) {
enode.c:      ty = promote(l->type);
enode.c:/* subnode - construct tree for l - r */
enode.c:   if (isarith(l->type) && isarith(r->type)) {
enode.c:      ty = binary(l->type, r->type);
enode.c:   } else if (isptr(l->type) && isint(r->type)) {
enode.c:      ty = unqual(l->type);
enode.c:      if ((n = ty->type->size) == 0)
enode.c:         error("unknown size of type `%t'\n", ty->type);
enode.c:      r = cast(r, promote(r->type));
enode.c:   } else if (compatible(l->type, r->type)) {
enode.c:      if ((n = deref(l->type)->size) == 0)
enode.c:         error("unknown size of type `%t'\n", deref(l->type));
enode.c:/* typeerror - issue "operands of op have illegal types `l' and `r'" */
enode.c:      ASGN, "=",   INDIR, "*",   NEG,  "-",
enode.c:      ADD,  "+",   SUB,   "-",   LSH,  "<<",
enode.c:         ops[i].name, l->type, r->type);
enode.c:         l->type);
error.c:/* error - issue error message */
error.c:      errcnt = -1;
error.c:/* expect - advance if t is tok, otherwise issue message */
error.c:   errcnt--;
error.c:/* fatal - issue fatal error message and exit */
error.c:   error("compiler error in %s--", name);
error.c:/* printtoken - print current token preceeded by a space */
error.c:         for (s = token; *s && s - token < 20; s++)
error.c:/* skipto - skip input up to tok U set, for a token where kind[t] is in set */
error.c:         errcnt--;
error.c:      errcnt--;
error.c:/* test - check for token tok, skip to tok U set, if necessary */
error.c:/* warning - issue warning error message */
error.c:      errcnt--;   /* compensate for increment in error */
expr.c:/* addrof - address of p */
expr.c:      switch (generic(q->op)) {
expr.c:         assert(q->kids[0] || q->kids[1]);
expr.c:         q = q->kids[1] ? q->kids[1] : q->kids[0];
expr.c:         q = q->kids[1];
expr.c:         Symbol t1 = q->u.sym;
expr.c:         q->u.sym = 0;
expr.c:            return q->kids[0];
expr.c:         q = q->kids[0];
expr.c:         return tree(RIGHT, q->type, root(p), q);
expr.c:/* asgn - generate tree for assignment of expr e to symbol p sans qualifiers */
expr.c:   if (isarray(p->type))
expr.c:      e = tree(ASGN+B, p->type, idnode(p),  /*neu 950320 CWK: e );wieder weg */
expr.c:           tree(INDIR+B, e->type, e, 0));
expr.c:      Type ty = p->type;
expr.c:      p->type = unqual(p->type);
expr.c:      if (isstruct(p->type) && p->type->u.sym->u.s.cfields) {
expr.c:         p->type->u.sym->u.s.cfields = 0;
expr.c:         p->type->u.sym->u.s.cfields = 1;
expr.c:      p->type = ty;
expr.c:/* assign - perform type-checking of assignment of p to variable of type xty */
expr.c:   Type yty = unqual(p->type);
expr.c:   if (yty->size == 0)
expr.c:      xty = xty->type;
expr.c:      Type lty = xty->type, rty = yty->type;
expr.c:            warning("assignment between `%t' and `%t' is compiler-dependent\n",
expr.c:   if (isptr(xty) && isint(p->type) && generic(p->op) == CNST
expr.c:   && cast(p, unsignedtype)->u.v.u == 0)
expr.c:/* call - parse function call to f, type fty */
expr.c:   Type *proto = fty->u.proto;
expr.c:   long sharedpar = 0, regpar = 0; /*CWK, callee-Werte*/
expr.c:   if (f->u.sym) {
expr.c:       sharedpar = f->u.sym->sharedparameters;    /*CWK*/
expr.c:       regpar = f->u.sym->regparameters;    /*CWK*/
expr.c:       issync = f->u.sym->sync;           /*CWK*/
expr.c:     if (isptr(f->type) && isfunc(f->type->type)) {
expr.c:       Symbol symb; /*950522 =  f->kids[0]->u.sym;   /*CWK*/
expr.c:       Tree myf = f->kids[0];  /*CWK 950522*/
expr.c:       while (myf && !myf->u.sym)  myf = myf->kids[0];   /*950522*/
expr.c:       symb = myf->u.sym;
expr.c:         sharedpar = symb->sharedparameters;    /*CWK*/
expr.c:         regpar = symb->regparameters;    /*CWK*/
expr.c:         issync = symb->sync;
expr.c:      error("call to a control-synchronous function from an asynchronous caller\n");
expr.c:    if (issync && isptr(f->type) && isfunc(f->type->type))      /*CWK*/
expr.c:      if (f->kids[0] && f->kids[0]->u.sym)                      /*CWK*/
expr.c:        if (!(f->kids[0]->u.sym->shared) )                      /*CWK*/
expr.c:          error("call to control-synchronous function via private pointer is forbidden!\n"); 
expr.c:      if (isptr(f->type) && isfunc(f->type->type)) {
expr.c:        // CWK: 980811  AsyncFn-Call ohne farm laesst Synchr. weg
expr.c:        //warning("control-synchronous call to asynchronous function without barrier\n");
expr.c:        warning("call to asynchronous function may destroy control-synchronity\n");
expr.c:               if ((isint(q->type) || isenum(q->type))
expr.c:               && q->type->size != inttype->size)
expr.c:                  q = cast(q, promote(q->type));
expr.c:                  n + 1, funcname(f), q->type, *proto);
expr.c:            if (fty->u.proto && *proto == 0)
expr.c:            if (q->type == floattype)
expr.c:            else if ((isint(q->type) || isenum(q->type))
expr.c:            && q->type->size != inttype->size)
expr.c:               q = cast(q, promote(q->type));
expr.c:            else if (isarray(q->type) || q->type->size == 0)
expr.c:                  n + 1, funcname(f), q->type);
expr.c:         if (isstruct(q->type)) {
expr.c:            if (q->op == RIGHT && q->kids[0]
expr.c:            && q->kids[0]->op == CALL+B) {
expr.c:               assert(q->kids[0]->kids[1]);
expr.c:               t1 = q->kids[0]->kids[1]->u.sym;
expr.c:               q = q->kids[0];
expr.c:               t1 = temporary(AUTO, unqual(q->type));
expr.c:            q = tree(RIGHT, ptr(q->type), root(q), lvalue(idnode(t1)));
expr.c:            args = tree(SARG + widen(q->type), q->type, q, args);
expr.c:                    /*varargflag||freeparregs<=0||!is_in_libfnames(f->u.sym->name))*/
expr.c:                   args = tree(RARG + widen(q->type), q->type, q, args);
expr.c:              else args = tree(ARG + widen(q->type), q->type, q, args);
expr.c:              /*else { freeparregs--;
expr.c:                      args = tree(RARG + widen(q->type), q->type, q, args); } */
expr.c:   if (converttofarm) f->synchron = 1;  /*CWK: erzwinge ein synchro nach call*/
expr.c:   else               f->synchron = 0;
expr.c:/* cast - cast expression p to type */
expr.c:   if (p->type == type)
expr.c:   pty = unqual(p->type);
expr.c:      if (isstruct(pty->type) && isptr(ty) && isstruct(ty->type)
expr.c:      && (q = extends(pty->type, ty->type)))
expr.c:         return simplify(ADD+P, ty, p, constnode(q->offset, inttype));
expr.c:         if (isfunc(pty->type) && !isfunc(ty->type)
expr.c:         || !isfunc(pty->type) &&  isfunc(ty->type))
expr.c:            warning("conversion from `%t' to `%t' is compiler-dependent\n",
expr.c:               p->type, ty);
expr.c:         constnode(q->offset, inttype)));
expr.c:   pty = unqual(p->type);
expr.c:          * d >= INT_MAX+1 ? (unsigned)(int)(d-(INT_MAX+1)) + INT_MAX+1 :
expr.c:         c->u.v.d = (double)INT_MAX + 1;
expr.c:         p->u.v.d = utod(UINT_MAX) + 1;
expr.c:/* cond - check for conditional operator, add comparison if necessary */
expr.c:   Opcode op = generic(rightkid(p)->op);
expr.c:   p = cast(p, promote(p->type));
expr.c:/* conditional - parse expression and cast to conditional */
expr.c:   if (Aflag > 1 && isfunc(p->type))
expr.c:/* constexpr - parse a constant expression */
expr.c:   needconst--;
expr.c:   p->maybe_pr = 0;     /*CWK*/
expr.c:/* expr0 - parse an expression for side effect */
expr.c:/* expr - parse an expression */
expr.c:      if (generic(p->op) != CNST)
expr.c:      p = tree(RIGHT, q->type, p, q);
expr.c:/* expr1 - parse assignments */
expr.c:/* expr2 - parse conditional expressions */
expr.c:      if (Aflag > 1 && isfunc(p->type))
expr.c:        warning("private condition in ?: operator in control-synchronous mode may destroy synchronicity or cause deadlock!\n");
expr.c:/* expr3 - parse expressions at precedence level k */
expr.c:   for (k1 = prec[t]; k1 >= k; k1--)
expr.c:/* field - construct tree for reference to field name via p */
expr.c:   Type ty1, ty = p->type;
expr.c:      ty = q->type;
expr.c:      if (!isarray(q->type))
expr.c:      p = simplify(ADD+P, ty, p, constnode(q->offset, inttype));
expr.c:      if (q->to) {
expr.c:         p = tree(FIELD, q->type, rvalue(p), 0);
expr.c:         p->u.field = q;
expr.c:      } else if (!isarray(q->type))
expr.c:/* funcname - return name of function f or `a function' */
expr.c:   if (isaddrop(f->op))
expr.c:      return stringf("`%s'", f->u.sym->name);
expr.c:/* idnode - construct tree for reference to r-value of identifier p */
expr.c:   Type ty = p->type ? unqual(p->type) : voidtype;
expr.c:   p->ref += refinc;
expr.c:   p->initialized = 1;   /* in case p->ref overflows */
expr.c:   if (p->scope == PARAM) {
expr.c:%    if ( 1 || !p->parreg) {   /*CWK: vorlaeufig Standardfall. Spaeter s.u. */
expr.c:      if (isstruct(p->type)) {
expr.c:         e = tree((p->shared)? ADDRSF+P: ADDRF+P, ptr(ptr(p->type)), 0, 0); /*CWK*/
expr.c:         e->u.sym = p;
expr.c:      {   e = tree((p->shared)? ADDRSF+P: ADDRF+P, ptr(p->type), 0, 0);  /*CWK*/
expr.c:         e->u.sym = p;
expr.c:      if (p->shared) e->maybe_pr = 0; else e->maybe_pr = 1;  /*CWK*/
expr.c:%     e = tree( ADDRREG + (isunsigned(p->type) ? I : ttob(p->type)),
expr.c:%                p->type, 0, 0);
expr.c:%     /* ADDRREG braucht kein eigenes Register. Es nimmt das Register p->parreg
expr.c:%     e->u.sym = p;
expr.c:%     e->maybe_pr = 1;
expr.c:   if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
expr.c:      op = (p->shared||isfunc(ty))? ADDRSG+P:ADDRG+P;  /*CWK*/
expr.c:         p->addressed = 1;
expr.c:      op = (p->shared)? ADDRSL+P:ADDRL+P;  /*CWK*/
expr.c:      e = tree(op, p->type ? p->type : voidtype, 0, 0);
expr.c:      e->u.sym = p;
expr.c:      if (p->shared) e->maybe_pr = 0; else e->maybe_pr = 1;  /*CWK*/
expr.c:      e = tree(op, ptr(p->type), 0, 0);
expr.c:      e->u.sym = p;
expr.c:      if (p->shared) e->maybe_pr = 0; else e->maybe_pr = 1;  /*CWK*/
expr.c:/* incr - construct tree for e1 op= e2 */
expr.c:/* intexpr - parse a constant expression and return int value, default n */
expr.c:   if (generic(p->op) == CNST && isint(p->type))
expr.c:      n = cast(p, inttype)->u.v.i;
expr.c:   needconst--;
expr.c:/* lvalue - check for lvalue, return pointer to lvalue tree */
expr.c:   if (generic(p->op) == INDIR) {
expr.c:      if (unqual(p->type) == voidtype)
expr.c:         warning("`%t' used as an lvalue\n", p->type);
expr.c:      return p->kids[0];
expr.c:   if (generic(p->op) == ADDRREG) {      /*CWK*/
expr.c:/* nullcheck - test if p null; build ((!p ? _YYnull(lineno) : ), p) */
expr.c:   return tree(RIGHT, p->type, q, p);
expr.c:/* pointer - re-type `array of T', `T function' to `ptr to T', `ptr to T function', resp. */
expr.c:   if (isarray(p->type) && (p->op != RIGHT || p->u.sym == 0))
expr.c:      p = retype(p, atop(p->type));
expr.c:   else if (isfunc(p->type))
expr.c:      p = retype(p, ptr(p->type));
expr.c:/* postfix - parse a postfix expresssion; p is the primary dag */
expr.c:         p = tree(RIGHT, p->type,
expr.c:            tree(RIGHT, p->type, p, root(incr(t, p, constnode(1, inttype)))),
expr.c:            if (isptr(p->type))
expr.c:            else if (isptr(q->type))
expr.c:         if (isptr(p->type) && isarray(p->type->type))
expr.c:            p = retype(p, p->type->type);
expr.c:         if (isptr(p->type) && isfunc(p->type->type))
expr.c:            ty = p->type->type;
expr.c:            error("found `%t' expected a function\n", p->type);
expr.c:            if (isstruct(p->type)) {
expr.c:               if (isaddrop(q->op) && q->u.sym->temporary) {
expr.c:                  p = tree(RIGHT, p->type, p, 0);
expr.c:                  p->u.sym = q->u.sym;
expr.c:               /*p->maybe_pr = p->kids[0]->maybe_pr;  *CWK*/
expr.c:                  p->type);
expr.c:            if (isptr(p->type))
expr.c:               ty = deref(p->type);
expr.c:            if (isptr(p->type) && isstruct(ty)) {
expr.c:               error("left operand of -> has incompatible type `%t'\n",
expr.c:                  p->type);
expr.c:            /*p->maybe_pr = 1;   /*CWK, auskomm. 950522*/
expr.c:/* prefix - parse a prefix expression */
expr.c:      if (isptr(p->type) && (isfunc(p->type->type) || isarray(p->type->type))) {
expr.c:         p = retype(p, p->type->type);
expr.c:      /*p->maybe_pr = 1;    * dereferenzierter Pointer kann ueberallhin zeigen */
expr.c:      if (isarray(p->type) || isfunc(p->type))
expr.c:         p = retype(p, ptr(p->type));
expr.c:      if (isaddrop(p->op))
expr.c:         if (p->u.sym->sclass == REGISTER)
expr.c:               p->u.sym->name);
expr.c:            p->u.sym->addressed = 1;
expr.c:      if (isarith(p->type))
expr.c:         p = cast(p, promote(p->type));
expr.c:   case '-':
expr.c:      if (isarith(p->type)) {
expr.c:         p = cast(p, promote(p->type));
expr.c:         if (isunsigned(p->type)) {
expr.c:            warning("unsigned operand of unary -\n");
expr.c:            p = simplify(NEG + ttob(p->type), p->type, p, 0);
expr.c:      if (isint(p->type)) {
expr.c:         Type ty = promote(p->type);
expr.c:      if (isscalar(p->type))
expr.c:      /*if (lvar->type != inttype)  error("integer variable expected\n");*/
expr.c:      if (lvar->u.sym->scope != GLOBAL)  error("global variable required\n");
expr.c:      if (!(lvar->u.sym->shared))  error("shared variable required\n");
expr.c:      if (rexpr->type != inttype)  error("integer expression expected\n");
expr.c:      ty = p->type;
expr.c:      p->stabilized = 1;
expr.c:         && tsym && tsym->sclass == TYPEDEF) {
expr.c:            ty = tsym->type;
expr.c:         ty = tsym->type;
expr.c:         ty = p->type;
expr.c:      if (isfunc(ty) || ty->size == 0)
expr.c:      else if (p && p->op == FIELD)
expr.c:      p = constnode(ty->size, unsignedtype);
expr.c:      && tsym && tsym->sclass == TYPEDEF) {
expr.c:            Type ty2 = ty->type;
expr.c:            ty = ty->type;
expr.c:               warning("non-ANSI constructor for `%t'\n", ty);
expr.c:         if ((isarith(p->type) || isenum(p->type)) && isarith(ty)
expr.c:         || isptr(ty) && (isptr(p->type) || isint(p->type) || isenum(p->type)))
expr.c:         else if (isint(ty) &&  isptr(p->type)) {
expr.c:            if (Aflag >= 1 && ty->size < p->type->size)
expr.c:               warning("conversion from `%t' to `%t' is compiler-dependent\n",
expr.c:                  p->type, ty);
expr.c:               p->type, ty1);
expr.c:         if (/* ty != ty1 && generic(p->op) == CNST
expr.c:         || */ generic(p->op) == INDIR)
expr.c:/* primary - parse a primary expression */
expr.c:         q->src = src;
expr.c:            q->sclass = EXTERN;
expr.c:            q->type = func(inttype, 0);
expr.c:             if (r = lookup(q->name, externals)) {
expr.c:               q->defined = r->defined;
expr.c:               q->temporary = r->temporary;
expr.c:               q->generated = r->generated;
expr.c:               q->computed = r->computed;
expr.c:               q->addressed = r->addressed;
expr.c:               q->initialized = r->initialized;
expr.c:               q->shared = r->shared;          /*CWK*/
expr.c:               r = install(q->name, &externals, 1);
expr.c:               r->src = q->src;
expr.c:               r->type = q->type;
expr.c:               r->sclass = EXTERN;
expr.c:            error("undeclared identifier `%s'\n", q->name);
expr.c:            q->sclass = AUTO;
expr.c:            q->type = inttype;
expr.c:            if (q->scope == GLOBAL)
expr.c:      if (tsym->sclass == ENUM)
expr.c:         p = constnode(tsym->u.value, inttype);
expr.c:         if (tsym->sclass == TYPEDEF)
expr.c:            error("illegal use of type name `%s'\n", tsym->name);
expr.c:      p->maybe_pr = 1;
expr.c:      p->maybe_pr = 0;
expr.c:      p = tree(CNST + ttob(tsym->type), tsym->type, 0, 0);
expr.c:      p->u.v = tsym->u.c.v;
expr.c:      p->maybe_pr = 0;  /*CWK*/
expr.c:      tsym->u.c.v.p = stringn(tsym->u.c.v.p, tsym->type->size);
expr.c:      tsym = constant(tsym->type, tsym->u.c.v); 
expr.c:      if (tsym->u.c.loc == 0)
expr.c:         tsym->u.c.loc = genident(STATIC, tsym->type, GLOBAL);
expr.c:      p = idnode(tsym->u.c.loc);
expr.c:      p->maybe_pr = 0;  /*CWK*/
expr.c:/* promote - the usual integral promotions */
expr.c:/* right - return (RIGHT, q->type, root(p), q) or just root(p/q) if q/p==0 */
expr.c:      return tree(RIGHT, q->type, root(p), q);
expr.c:/* rightkid - dereference RIGHT nodes to find ultimate offspring */
expr.c:   while (p && p->op == RIGHT) {
expr.c:      assert(p->kids[0] || p->kids[1]);
expr.c:      p = p->kids[1] ? p->kids[1] : p->kids[0];
expr.c:/* rvalue - convert p to an rvalue */
expr.c:   Type ty = deref(p->type);
expr.c:/* value - convert p from a conditional to a value, if necessary */
expr.c:   Opcode op = generic(rightkid(p)->op);
flcc.c:/* fcc.c  Source fuer fcc - Driver  (c)29.11.1994 C.W. Kessler */
flcc.c:   if (s[0]=='-') {  /*Option*/
flcc.c:       case 'S': Sflag = 1;   /*behalte .s-Files*/
flcc.c:       case 'o': /* -o outfilename: */
flcc.c:       case 'l': /* -lm Linkoptionen */
flcc.c:   else                /* kein - */
flcc.c:     if (s[n-3]=='.' && s[n-2]=='f' && s[n-1]=='l') {
flcc.c:        s[n-3]='\0';
flcc.c:     if (s[n-2]=='.' && s[n-1]=='o')
flcc.c:  printf("ForkLight Compiler flcc by C.W.Kessler, kessler@psi.uni-trier.de\n");
flcc.c:   sprintf(prepr, "%s %s -o %s.i -x c %s.fl",
flcc.c:   sprintf(prepr, "%s %s -o %s.f -x c %s.fl", 
flcc.c:  sprintf(adapt,"%s -I%s -x c -o %s.i %s.s",
flcc.c:  sprintf(prass,"%s %s -o %s.o %s.i; rm %s.i",
gen.c:extern int STARTED_PROCS;  /*CWK: compile-time constant, set by -nprocs option */
gen.c:int shglobalptr = 0;       /*stack-like allocation of sh global variables*/
gen.c:#define typecode(p) (optype(p->op) == U ? I : optype(p->op) == B ? P : optype(p->op))
gen.c:#define sets(p) ((p)->x.rmask<<(p)->x.reg)
gen.c:/* firstfreeparreg() - gibt erstes freies Parameter-Register.  CWK */
gen.c:/* freeallparregs() - gib alle Parameter-Register wieder frei.  CWK */
gen.c:/* address - initialize q for addressing expression p+n */
gen.c:   if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN)
gen.c:      q->x.name = stringf("%s%s%d", p->x.name, n >= 0 ? "+" : "", n);
gen.c:      q->x.offset = p->x.offset + n;
gen.c:      if (p->scope == PARAM) {       /* formaler Parameter */
gen.c:         q->x.name = stringf("%d(ap)", q->x.offset);  /*CWK*/
gen.c:        if (p->shared) {
gen.c:          q->x.name = stringf("fps+%d /*via address*/", 2+q->x.offset ); /*CWK*/
gen.c:          q->x.name = stringf("%s+%d /*via address*/", p->x.name , n );
gen.c:/* asmcode - emit assembly language specified by asm */
gen.c:         print("%s", argv[*++str]->x.name);
gen.c:/* blockbeg - begin a compound statement */
gen.c:   e->rmask = rmask;
gen.c:   e->proffset = proffset;  /* statt offset CWK */
gen.c:   e->shoffset = shoffset; /*CWK*/
gen.c:   e->framedepth = shframedepth;  /*970902*/
gen.c:/* blockend - end a compound statement */
gen.c:   //proffset = e->proffset;
gen.c:   shoffset = e->shoffset;
gen.c:   shframedepth = e->framedepth;  /*970902*/
gen.c:   rmask = e->rmask;
gen.c:/* defconst - define a constant */
gen.c:/* defstring - emit a string constant */
gen.c:   while (len-- > 0)
gen.c:            default: print("\\%o", *(s-1) ); break;  /*control characters*/
gen.c:/* defsymbol - initialize p's Xsymbol fields */
gen.c:   if (p->scope == CONSTANTS)
gen.c:      p->x.name = p->name;
gen.c:   else if (p->scope >= LOCAL && p->sclass == STATIC)
gen.c:      p->x.name = stringf("L%d", genlabel(1));
gen.c:   else if (p->generated)  // jump labels and outofline constants
gen.c:      p->x.name = stringf("L%s", p->name);
gen.c:      p->x.name = stringf("%s", p->name); /*FL*/
gen.c:      /* vorher p->x.name = stringf("_%s", p->name);*/
gen.c:#define suffix(p)    ".fdbwllll."[optype((p)->op)]
gen.c:                        a->x.reg+ROFF, b->x.reg+ROFF)
gen.c:                        a->x.reg+ROFF, b->x.reg+ROFF)
gen.c:#define binary(inst) print("r%d = r%d %s r%d;\n", r, a->x.reg+ROFF, inst, b->x.reg+ROFF)
gen.c:#define fbinary(inst) print("fr%d = fr%d %s fr%d;\n", r, a->x.reg+ROFF, inst, b->x.reg+ROFF)
gen.c:#define dbinary(inst) print("dr%d = dr%d %s dr%d;\n", r, a->x.reg+ROFF, inst, b->x.reg+ROFF)
gen.c:/*#define unary(inst)  print("%s%c r%d,r%d\n", inst, suffix(p), a->x.reg, r)CWK*/
gen.c:#define unary(inst)  print("r%d = %s r%d;\n", r, inst, a->x.reg+ROFF)
gen.c:#define funary(inst)  print("fr%d = %s r%d;\n", r, inst, a->x.reg+ROFF)
gen.c:#define funaryf(inst)  print("fr%d = %s fr%d;\n", r, inst, a->x.reg+ROFF)
gen.c:                        /*a->x.reg, b->x.reg, cp, p->syms[0]->x.name)*/
gen.c:                        a->x.reg+ROFF, cp, b->x.reg+ROFF, p->syms[0]->x.name)
gen.c:                        a->x.reg+ROFF, fcp, b->x.reg+ROFF, p->syms[0]->x.name)
gen.c:                        a->x.reg+ROFF, dcp, b->x.reg+ROFF, p->syms[0]->x.name)
gen.c:/*PRAM: sub b,a,x bedeutet x = a - b. CWK*/
gen.c:/* emit - emit the dags on list p */
gen.c:   for (; p; p = p->x.next) {
gen.c:      Node a = p->kids[0], b = p->kids[1];
gen.c:      int r = p->x.reg+ROFF;  /*CWK: Registernummer - Offset*/
gen.c:      if (p->ignore) {  /*CWK 980716*/
gen.c:      switch (p->op) {
gen.c:      case ADDP:  if (ismyaddrop(p->kids[0]->op) && ismyaddrop(p->kids[1]->op))
gen.c:                       r, a->x.reg+ROFF, b->x.reg+ROFF); 
gen.c:                  if (ismyaddrop(p->kids[0]->op) && !ismyaddrop(p->kids[1]->op))
gen.c:                       r, a->x.reg+ROFF, b->x.reg+ROFF); 
gen.c:                  if (!ismyaddrop(p->kids[0]->op) && ismyaddrop(p->kids[1]->op))
gen.c:                       r, b->x.reg+ROFF, a->x.reg+ROFF); 
gen.c:                  else { // (!ismyaddrop(p->kids[0]) && !ismyaddrop(p->kids[1]))
gen.c:                       r, a->x.reg+ROFF, b->x.reg+ROFF); 
gen.c:      case SUBD:                          dbinary("-");   break;
gen.c:      case SUBF:        		  fbinary("-");   break;
gen.c:      case SUBI:  case SUBU:  binary("-");   break;
gen.c:      case SUBP:  print("pr%d = pr%d - r%d;   /*SUBP*/\n", 
gen.c:                           r,    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         print("dr%d = dr%d / dr%d;\t /*DIVD*/\n", r, a->x.reg+ROFF, b->x.reg+ROFF); 
gen.c:         print("fr%d = fr%d / fr%d;\t /*DIVF*/\n", r, a->x.reg+ROFF, b->x.reg+ROFF); 
gen.c:         print("r%d = r%d / r%d;\t /*DIVI*/\n", r, a->x.reg+ROFF, b->x.reg+ROFF); 
gen.c:      case MODI:  /* a%b == a - (a/b)*b  */
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:      case MODU:  /* a%b == a - (a/b)*b  */
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         print("r%d = _ilog2(r%d);  \t /*ILOG2*/\n", r, a->x.reg+ROFF);
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF);            /*CWK*/
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF);            /*CWK*/
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF);            /*CWK*/
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF);            /*CWK*/
gen.c:            b->x.reg, b->x.reg, a->x.reg, r); */
gen.c:            r, a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:                r, a->x.reg+ROFF, b->x.reg+ROFF );
gen.c:         print("r%d = r%d << r%d;\t /*LSHI*/\n", r, a->x.reg+ROFF, b->x.reg+ROFF );
gen.c:         print("r%d = r%d << r%d;\t /*LSHU*/\n", r, a->x.reg+ROFF, b->x.reg+ROFF );
gen.c:         /*print("moval (r%d),r%d\n", a->x.reg+ROFF, r);*/
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                  r, a->x.reg+ROFF, p->syms[0]->x.name );
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    r, a->x.reg+ROFF, p->syms[0]->x.name );
gen.c:                  r, a->x.reg+ROFF, p->syms[0]->x.name );
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:           print("_SMread( (void **)&dr%d, (void *)pr%d, 8);\t /*INDIRD shared*/\n", r, a->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:             print("_SMread( (void **)&dr%d, (void *)pr%d, 8);\t /*INDIRD if shared*/\n", r, a->x.reg+ROFF);
gen.c:           print("dr%d = *((double *)pr%d);\t /*INDIRD private*/\n", r, a->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:           print("_SMread( (void **)&fr%d, (void *)pr%d, 4);\t /*INDIRF shared*/\n", r, a->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:             print("_SMread( (void **)&fr%d, (void *)pr%d, 4);\t /*INDIRF if shared*/\n", r, a->x.reg+ROFF);
gen.c:           print("fr%d = *((float *)pr%d);\t /*INDIRF private*/\n", r, a->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:           print("_SMread( (void **)&r%d, (void *)pr%d, 1);\t /*INDIRC shared*/\n", r, a->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:             print("_SMread( (void **)&r%d, (void *)pr%d, 1);\t /*INDIRC if shared*/\n", r, a->x.reg+ROFF);
gen.c:           print("r%d = (char)*((char *)pr%d);\t /*INDIRC private*/\n", r, a->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:           print("_SMread( (void **)&r%d, (void *)pr%d, 4);\t /*INDIRI shared*/\n", r, a->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:             print("_SMread( (void **)&r%d, (void *)pr%d, 4);\t /*INDIRI if shared*/\n", r, a->x.reg+ROFF);
gen.c:           print("r%d = (int)*((void **)pr%d);\t /*INDIRI private*/\n", r, a->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:           print("_SMread( (void **)&pr%d, (void *)pr%d, 4);\t /*INDIRP shared*/\n", r, a->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:             print("_SMread( (void **)&pr%d, (void *)pr%d, 4);\t /*INDIRP if shared*/\n", r, a->x.reg+ROFF);
gen.c:           print("pr%d = *((void **)pr%d);\t /*INDIRP private*/\n", r, a->x.reg+ROFF);/*CWK*/
gen.c:         print("r%d = ~r%d;\n", r, a->x.reg+ROFF); 
gen.c:         print("fr%d = ((double)fr%d<0.0000001);\t /*NEGF*/\n", r, a->x.reg+ROFF);
gen.c:         print("r%d = !r%d;\t /*NEGI*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVDI: print("r%d = (int)dr%d;\t /*CVDI*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVID: print("dr%d = (double)r%d;\t /*CVID*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVCI: print("r%d = (int)r%d;\t /*CVCI*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVCU: print("r%d = (unsigned int)r%d;\t /*CVCU*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVSI: print("r%d = (int)r%d;\t /*CVSI*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVSU: print("r%d = (unsigned int)r%d;\t /*CVSU*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVDF: print("fr%d = (float)dr%d;\t /*CVDF*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVFD: print("dr%d = (double)fr%d;\t /*CVFD*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVUC: print("r%d = (char)r%d;\t /*CVUC*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVUS: print("r%d = (int)r%d;\t /*CVUS*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVIC: print("r%d = (char)r%d;\t /*CVIC*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVIS: print("r%d = (int)r%d;\t /*CVIS*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVIU: print("r%d = (unsigned int)r%d;\t /*CVIU*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVUI: print("r%d = (int)r%d;\t /*CVUI*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVPU: print("r%d = pr%d;\t /*CVPU*/\n", r, a->x.reg+ROFF); break;
gen.c:      case CVUP: print("pr%d = (void *)r%d;\t /*CVUP*/\n", r, a->x.reg+ROFF); break;
gen.c:         retflush(p);    if (!cfunc->sync) assert(p->rframes==0);
gen.c:         Epilog(cfunc->sync);                            /*endet auf mo==0*/
gen.c:         print("return dr%d;\t /*RETD*/\n", a->x.reg+ROFF);
gen.c:         retflush(p);    if (!cfunc->sync) assert(p->rframes==0);
gen.c:         Epilog(cfunc->sync);                            /*endet auf mo==0*/
gen.c:         print("return fr%d;\t /*RETF*/\n", a->x.reg+ROFF);
gen.c:         retflush(p);    if (!cfunc->sync) assert(p->rframes==0);
gen.c:         Epilog(cfunc->sync);                            /*endet auf mo==0*/
gen.c:         print("return r%d;\t /*RETI*/\n", a->x.reg+ROFF);
gen.c:         Epilog(cfunc->sync);     /*endet auf mo==?*/
gen.c:                    typestring( p->syms[0]->type, p->syms[0]->x.name ));
gen.c:         print("  pr%d = &%s;}\t /*ADDRGP*/\n", r, p->syms[0]->x.name );
gen.c:         if (isarray(p->syms[0]->type))   /*Notnagel 980709*/
gen.c:                typestring( atop(p->syms[0]->type),""), r );
gen.c:         print("pr%d = &%s;\t /*ADDRLP*/\n", r, p->syms[0]->x.name);
gen.c:         if (isarray(p->syms[0]->u.c.loc->type)) {
gen.c:           print("getlo\t %s,r31\n", p->syms[0]->u.c.loc->type->size );
gen.c:           print("sub\t r31,r%d,r%d /*ADDRLP-Korrektur*/\n", r,r); /*950320*/
gen.c:         print("pr%d = &%s;\t /*ADDRFP*/\n", r, p->syms[0]->name, r);
gen.c:         print("r%d = %s;\t /*CNSTC*/\n", r, p->syms[0]->x.name);
gen.c:         print("pr%d = %s;\t /*CNSTP*/\n", r, p->syms[0]->x.name);
gen.c:         print("r%d = %s;\t /*CNSTS*/\n", r, p->syms[0]->x.name);
gen.c:         print("r%d = %s;\t /*CNSTU*/\n", r, p->syms[0]->x.name);
gen.c:         print("r%d = %s;\t /*CNSTI*/\n", r, p->syms[0]->x.name);
gen.c:         if (p->kids[0]->op==ADDRGP) /*CWK 980716*/
gen.c:            print("goto %s;\t /*JUMPV1*/\n\n", p->kids[0]->syms[0]->x.name);
gen.c:            print("_jump(r%d);\t /*JUMPV*/\n", a->x.reg+ROFF);/*CWK*/
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF, p->syms[0]->x.name);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF, p->syms[0]->x.name);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF, p->syms[0]->x.name);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           print("*((double *)pr%d) = dr%d;\t /*ASGND*/\n", a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           print("*((float *)pr%d) = fr%d;\t /*ASGNF*/\n", a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           print("*(char *)pr%d = r%d;\t /*ASGNC*/\n", a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           print("*((int *)pr%d) = r%d;\t /*ASGNI*/\n", a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         if (a->syms[0] && a->syms[0]->shared)
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:           if (!a->syms[0]) {
gen.c:             print("if (_isshared((void**)pr%d))\n", a->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:                    a->x.reg+ROFF, b->x.reg+ROFF);
gen.c:         /*save(p->x.busy&0x3f);*/
gen.c:         print("movc3 $%s,(r%d),%d(sp)   ARGB  \n", p->syms[0]->x.name,
gen.c:            a->x.reg+ROFF, p->x.argoffset);
gen.c:         /*restore(p->x.busy&0x3f);*/
gen.c:         print("dpar%d = dr%d;\t /*ARGD Nr.%d*/\n", pargnr, a->x.reg+ROFF,pargnr);
gen.c:         print("fpar%d = fr%d;\t /*ARGF Nr.%d*/\n", pargnr, a->x.reg+ROFF,pargnr);
gen.c:         print("ppar%d = pr%d;\t /*ARGP Nr.%d*/\n", pargnr, a->x.reg+ROFF,pargnr);
gen.c:         print("ipar%d = r%d;\t /*ARGI Nr.%d*/\n", pargnr, a->x.reg+ROFF,pargnr);
gen.c:         print("par%d = r%d\t /*RARGx*/\n", parreg, a->x.reg+ROFF );
gen.c:         if (p->op == CALLV) {
gen.c:            print("{ void (*_xxxxy)() = pr%d;\t /*CALLV*/\n", a->x.reg+ROFF);
gen.c:         if (p->op == CALLF) {
gen.c:            print("{ float (*_xxxxy)() = pr%d;\t /*CALLF*/\n", a->x.reg+ROFF);
gen.c:         if (p->op == CALLD) {
gen.c:            print("{ double (*_xxxxy)() = pr%d;\t /*CALLD*/\n", a->x.reg+ROFF);
gen.c:            print("{ int (*_xxxxy)() = pr%d;\t /*CALLI*/\n", a->x.reg+ROFF);
gen.c:           for (j=1; j<pargnr; j++) print("%cpar%d,", argtyp[j-1], j);
gen.c:           if (pargnr) print("%cpar%d", argtyp[pargnr-1], pargnr);
gen.c:         if (p->synchron) {
gen.c:         /*restore(p->x.busy&0xfff);*/
gen.c:         print("%s:\n", p->syms[0]->x.name);
gen.c:         print("MOV par%d,r%d /*ADDRREGx %s r%d*/\n", p->syms[0]->parreg, r,
gen.c:                p->syms[0]->x.name, r);
gen.c:         if (!isfunc(p->syms[0]->type)) {
gen.c:           print("{extern int %s;/*ADDRSGP*/\n", p->syms[0]->x.name);
gen.c:           print(" pr%d = (void*)&(_gsstack[%s]);} /*ADDRSGP*/\n", r, p->syms[0]->x.name);
gen.c:           print(" pr%d = %s; /*ADDRSGP*/\n", r, p->syms[0]->x.name);
gen.c:         if (p->syms[0]->x.framedepth == 0)  /* access at top level of fn. */
gen.c:           if (!cfunc->sync)  /*980129: start bastelt einen fake-fps!*/
gen.c:             print("r%d = fps+%d\t /*ADDRSLP a*/\n", r, 1+p->syms[0]->x.offset);
gen.c:             print("r%d = fps+%d\t /*ADDRSLP b*/\n", r, 1+p->syms[0]->x.offset);
gen.c:               /*vorher 2 statt 1 ^ da Fn-Grfr. dazw., jetzt retval weg */
gen.c:         if (p->shframedepth - p->syms[0]->x.framedepth == 1) {  /*new 970902*/
gen.c:           print(" pr%d = (void**)_gpp[3]+%d;\t /*ADDRSLP Leveldiff = 1 = %d - %d*/\n",
gen.c:                    r,       /* 4* */(4 + p->syms[0]->x.offset/4),
gen.c:                    p->shframedepth, p->syms[0]->x.framedepth ); 
gen.c:         if (p->shframedepth - p->syms[0]->x.framedepth > 1) {  /*new 970902*/
gen.c:           print("{void **r31 = _gpp[0];  /*ADDRSLP, Leveldiff=%d = %d-%d*/\n",
gen.c:             p->shframedepth - p->syms[0]->x.framedepth,
gen.c:             p->shframedepth, p->syms[0]->x.framedepth);
gen.c:           for ( j=p->shframedepth - p->syms[0]->x.framedepth - 1; j>1; j--)
gen.c:                    r,      4 + p->syms[0]->x.offset/4);
gen.c:                  r,       4 + p->syms[0]->x.offset/4);
gen.c:         print("r%d = %s\t /*ADDRSFP*/\n", r, p->syms[0]->x.name);
gen.c:         /*assert( p->synchron==1 );  /*cfunc->synchron && rausgeworfen 950324*/
gen.c:         /* allocate space for shared block-local variables */
gen.c:         print("_SLICESIZE = (int)(_eps-_sps) >> 3;\t /*split*/\n");
gen.c:         /* Pcodepar==0 -> then,  ==1 -> else. */
gen.c:      case MKGRPV:                /*CWK, a->x.reg+ROFF enthaelt Gruppengroesse */
gen.c:         print("_makegroupframe(r%d);\t /*mkgrp*/\n", a->x.reg+ROFF);
gen.c:         /* Register a->x.reg die Anzahl der zu startenden Prozessoren.*/
gen.c:         /*Die Gruppenrahmen vor der start-Anweisung werden wiederhergestellt.*/
gen.c:          * und tragen sich automatisch aus -> es ist gar nix zu tun. */
gen.c:         for (label1=Pcodepar; label1 > 0; label1--) {
gen.c:         /*synchron. Bestimme leader: Proz. mit kleinster MPADD-priority*/
gen.c:          * aufgebaut werden, um barriers im seq-Rumpf zu erlauben !
gen.c:         /*asynchron. Label und barrier ->weiter synchron in parallel*/
gen.c:/* function - generate code for a function */
gen.c:      if (callee[i]->shared) {   /*CWK*/
gen.c:        shoffset = roundup(shoffset, caller[i]->type->align);
gen.c:        callee[i]->x.offset = caller[i]->x.offset = shoffset;
gen.c:        callee[i]->x.name = caller[i]->x.name = stringf("aps,%d", shoffset); /*CWK*/
gen.c:        shoffset += caller[i]->type->size;
gen.c:        proffset = roundup(proffset, caller[i]->type->align);
gen.c:        callee[i]->x.offset = caller[i]->x.offset = proffset;
gen.c:        callee[i]->x.name = caller[i]->x.name = stringf("app+%d", proffset); /*CWK*/
gen.c:        proffset += caller[i]->type->size;
gen.c:      callee[i]->sclass = AUTO;
gen.c:   print("\n%s (\n", typestring(f->type->type, f->x.name));  /*CWK*/
gen.c:       if (!(callee[i]->shared)) /*CWK*/
gen.c:        print(" %s", typestring(callee[i]->type, callee[i]->name));
gen.c:   if (strcmp( f->x.name, "main" )==0) {    /* m a i n ( ) */
gen.c:          print(" %s", typestring(callee[i]->type, callee[i]->name));
gen.c:   /* spaeter alle R-Namen mit Underscore versehen, sonst evtl name clash!*/
gen.c:   if (strcmp( f->x.name, "main" )==0) {
gen.c:   if (f->sync) {
gen.c:   if (isstruct(freturn(f->type)))
gen.c:   //if (strcmp( f->x.name, "main" )==0) 
gen.c:     //print("barrier();\t /*nach Fn-Ruecksprung gemeinsam weiter*/\n");
gen.c:   if (strcmp(cfunc->x.name,"main")==0)
gen.c:/* gen - generate code for the dags on list p */
gen.c:   for (last = &head; p; p = p->link)
gen.c:   for (p = head; p; p = p->x.next) {
gen.c:      if (p->count == 0 && sets(p))
gen.c:/* getreg - allocate 1 or 2 registers for node p */
gen.c:   int r, m = optype(p->op) == D ? 3 : 1;
gen.c:         p->x.rmask = m;
gen.c:         p->x.reg = r;
gen.c:         if (p->syms[0])  p->syms[0]->reg = r;     /*CWK*/
gen.c:         debug(rflag,fprint(2,"allocating %s to node #%d\n", rnames(sets(p)), p->x.id));
gen.c:/* genreloads - make the nodes after dot use reloads of temp instead of p's register */
gen.c:   for (last = dot; dot = dot->x.next; last = dot)
gen.c:         if (dot->kids[i] == p) {
gen.c:            dot->kids[i] = newnode(INDIR + typecode(p),
gen.c:            dot->kids[i]->count = 1;
gen.c:            p->count--;
gen.c:            linearize(dot->kids[i], &last->x.next, last->x.next);
gen.c:            last = dot->kids[i];
gen.c:   assert(p->count == 0);
gen.c:/* genspill - generate code to spill p's register and return the temporary used */
gen.c:   Node q = p->x.next;
gen.c:      &p->x.next, p->x.next);
gen.c:   for (p = p->x.next; p != q; p = p->x.next)
gen.c:/* global - global id */
gen.c:   switch (p->type->align) {
gen.c:   if (p->shared) {
gen.c:            p->x.name,  shglobalptr / 4 );
gen.c:     p->x.offset = shglobalptr;
gen.c:     shglobalptr = roundup(shglobalptr + p->type->size, p->type->align);
gen.c:     //shglobalptr += p->type->size;
gen.c:     print("%s ", typestring(p->type, stringf(" _%s", p->x.name)));
gen.c:     print("%s ", typestring(p->type, p->x.name));
gen.c:/* linearize - linearize node list p */
gen.c:   if (p && !p->x.visited) {
gen.c:      last = linearize(p->kids[0], last, 0);
gen.c:      last = linearize(p->kids[1], last, 0);
gen.c:      p->x.visited = 1;
gen.c:      last = &p->x.next;
gen.c:      debug(1,if (p->x.id == 0) p->x.id = ++id);      
gen.c:/* local - local variable */
gen.c:  if (p->shared) {  /*CWK*/
gen.c:     p->x.offset = shoffset; //  + 1; 980810
gen.c:     p->x.framedepth = p->shframedepth;  /*970902*/
gen.c:     p->x.name = stringf("fps+%d", shoffset + 1);  /*CWK*/
gen.c:     shoffset = roundup(shoffset + p->type->size, p->type->align);
gen.c:     shoffset = roundup(shoffset, 4);  // 1->4  neu 980811
gen.c:  else {  /*private -> im Klartext generieren fuer FL*/
gen.c:     p->x.offset = 4711; // zur Kontrolle 980811. Vorher: proffset;  /*CWK*/
gen.c:     /*p->x.name = stringf("%d(fp)", -offset);*/
gen.c:     p->x.name = stringf("%s", p->name);
gen.c:     //proffset = roundup(proffset + p->type->size, p->type->align);
gen.c:  p->sclass = AUTO;
gen.c:/* needsreg - does p need a register? */
gen.c:   assert(opindex(p->op) > 0 && opindex(p->op) < sizeof reginfo/sizeof reginfo[0]);
gen.c:   return reginfo[opindex(p->op)]&(0x1000<<optype(p->op));
gen.c:/* progbeg - beginning of program */
gen.c:   while (--argc > 0)
gen.c:      if (**++argv == '-' && argv[0][1] >= '0' && argv[0][1] <= '9')
gen.c:      else if (strcmp(*argv, "-r") == 0)   /* (omit) */
gen.c:/* putreg - decrement register usage */
gen.c:   if (p && --p->count <= 0)
gen.c:      { assert(p->x.rmask);
gen.c:      debug(rflag,fprint(2,"deallocating %s from node #%d\n", rnames(sets(p)), p->x.id)); }
gen.c:/* ralloc - assign a register for p */
gen.c:   assert(p->x.rmask == 0);
gen.c:   switch (generic(p->op)) {
gen.c:       *     Unterscheidung zw. shared und private argoffset/-buildsize noetig.*/
gen.c:      argoffset = roundup(argoffset, p->syms[1]->u.c.v.i);
gen.c:      p->x.argoffset = argoffset;
gen.c:      argoffset += p->syms[0]->u.c.v.i;
gen.c:   default:assert(valid(p->op));
gen.c:      putreg(p->kids[i]);                     /*wegen exception-Handling     CWK*/
gen.c:   p->x.busy = rmask;
gen.c:/* restore - restore registers in mask */
gen.c:   for (i = nregs-1; i > 0; i--)         /* BUGFIX: in umgekehrter Rf. wieder poppen */
gen.c:         /*print("movl %d(fp),r%d\n", (4*)i - framesize + argbuildsize, i);*/
gen.c:/* save - save registers in mask */
gen.c:         /*print("movl r%d,%d(fp)\n", i, (4*)i - framesize + argbuildsize, i);*/
gen.c:/* segment - switch to logical segment s */
gen.c:/* spill - spill all registers that overlap (r,m) */
gen.c:   while (p = p->x.next)
gen.c:         if (p->kids[i] && sets(p->kids[i])&(m<<r)) {
gen.c:            Symbol temp = genspill(p->kids[i]);
gen.c:            rmask &= ~sets(p->kids[i]);
gen.c:            genreloads(dot, p->kids[i], temp);
gen.c:/* spillee - identify the most-distantly-used register */
gen.c:   int bestdist = -1, bestreg = /*0*/ 32-FREE_REGS, dist, r;
gen.c:   debug(rflag,fprint(2,"spillee: dot is node #%d\n", dot->x.id));
gen.c:   for (r = 1; r < nregs - (m>>1); r++) {
gen.c:      for (q = dot->x.next; q && !(uses(q)&(m<<r)); q = q->x.next)
gen.c:      debug(rflag,fprint(2,"r%d used in node #%d at distance %d\n", r, q->x.id, dist));
gen.c:/* uses - return mask of registers used by node p */
gen.c:      if (p->kids[i])
gen.c:         m |= sets(p->kids[i]);
gen.c:/* valid - is operator op a valid operator ? */
gen.c:/* lprint - print the nodelist beginning at p */
gen.c:      sprintf(buf, "%-4s%-8s%-8s%-8s%-7s%-13s%s",
gen.c:   for ( ; p; p = p->x.next)
gen.c:/* nprint - print a line describing node p */
gen.c:   if (p->kids[0]) {
gen.c:      for (i = 0; i < MAXKIDS && p->kids[i]; i++)
gen.c:         sprintf(buf + strlen(buf), "%3d", p->kids[i]->x.id);
gen.c:   if (p->syms[0] && p->syms[0]->x.name) {
gen.c:      for (i = 0; i < MAXSYMS && p->syms[i]; i++) {
gen.c:         if (p->syms[i]->x.name)
gen.c:            sprintf(buf + strlen(buf), " %s", p->syms[i]->x.name);
gen.c:         if (p->syms[i]->u.c.loc)
gen.c:            sprintf(buf + strlen(buf), "=%s", p->syms[i]->u.c.loc->name);
gen.c:   sprintf(buf, "%2d. %-8s%-8s%-8s %2d    %-13s",
gen.c:      p->x.id, opname(p->op), kids, syms, p->count, rnames(uses(p)));
gen.c:/* rnames - return names of registers given by mask m */
gen.c:/* strtol - interpret str as a base b number; if ptr!=0, *ptr gets updated str */
gen.c:   if (*str == '-' || *str == '+')
gen.c:         d = *str - '0';
gen.c:         d = (*str&~040) - 'A' + 10;
gen.c:      n = b*n - d;
gen.c:   return sign == '+' ? -n : n;
gen.c:/* === Funktionen fuer ex-p-code Befehle, CWK-neu 940628: ==================== */
gen.c:/* shspace(): allocate space for shared block-local variables */ 
gen.c:    codelist->u.node = listnodes( e, 0, 0 );
gen.c:    codelist->par = k;
gen.c: * um freien SM-Bereich gleichmaessig aufzuteilen;
gen.c: * gibt Backpatch-Pointer zurueck.
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = 2;
gen.c:   return &(codelist->par); 
gen.c: * und Gruppenrahmen fuer then-Gruppe anzulegen (zweiter->else-Gruppe) */
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = zweiter;
gen.c:/* lgrp_if(): erzeuge Code zum Verlassen angelegter Gruppenrahmen bei if-Anw.
gen.c: * einsoderzwei: 2 -> verlasse shared + private frame
gen.c: *               1 -> verlasse nur private frame
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = einsoderzwei;
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:/* engrp(): Gruppen betreten bei Fork-Anweisung */
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = forkexitlabel;
gen.c:/* exgrp(): Gruppen verlassen nach Fork-Anweisung */
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = forkexitlabel;
gen.c:/* xproc(): Prozessoren verlassen nach start-Anweisung */
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = looptyp;    /*950504*/
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = k;
gen.c:   /*shframedepth --; muss weg, weil die shframedepth eine
gen.c: assert( p->rframes >= 0); assert( p->started >=0 );
gen.c: /*shframedepth -= p->rframes;   /*970902*/
gen.c:   /*shframedepth --; weil der Compiler zu schlau ist
gen.c: for (i = p->rframes; i > 0; i--) {
gen.c: if (p->started) {     /*issue an xproc(): */
gen.c:         /*Die Gruppenrahmen vor der start-Anweisung werden wiederhergestellt.*/
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = labelnr;
gen.c:   codelist->u.node = listnodes( e, 0, 0 );
gen.c:   codelist->par = labelnr;
gen.c:/* ================= STAB - Funktionen    CWK 940921 ================== */
gen.c:/* asgncode - assign type code to ty */
gen.c:	if (ty->x.marked || ty->x.typeno)
gen.c:	ty->x.marked = 1;
gen.c:	switch (ty->op) {
gen.c:		asgncode(ty->type, lev);
gen.c:		ty->x.typeno = ty->type->x.typeno;
gen.c:		asgncode(ty->type, lev + 1);
gen.c:		for (p = fieldlist(ty); p; p = p->link)
gen.c:			asgncode(p->type, lev + 1);
gen.c:		if (ty->x.typeno == 0)
gen.c:			ty->x.typeno = ++ntypes;
gen.c:		if (lev > 0 && (*ty->u.sym->name < '0' || *ty->u.sym->name > '9'))
gen.c:/* dbxout - output .stabs entry for type ty */
gen.c:	if (!ty->x.printed) {
gen.c:		if (ty->u.sym && !(isfunc(ty) || isarray(ty) || isptr(ty)))
gen.c:			print("%s", ty->u.sym->name), col += strlen(ty->u.sym->name);
gen.c:/* dbxtype - emit a stabs entry for type ty, return type code */
gen.c:	return ty->x.typeno;
gen.c: * emittype - emit ty's type number, emitting its definition if necessary.
gen.c:	int tc = ty->x.typeno;
gen.c:		col = emittype(ty->type, lev, col);
gen.c:		ty->x.typeno = ty->type->x.typeno;
gen.c:		ty->x.printed = 1;
gen.c:		ty->x.typeno = tc = ++ntypes;
gen.c:	if (ty->x.printed)
gen.c:	ty->x.printed = 1;
gen.c:	switch (ty->op) {
gen.c:			print("=r%d;-128;127;", tc), col += 2+3+10;
gen.c:			print("=r1;-32768;32767;"), col += 17;
gen.c:		print("=r1;0;-1;"), col += 9;
gen.c:		print("=r1;%d;0;", ty->size), col += 4+1+3;
gen.c:		col = emittype(ty->type, lev + 1, col);
gen.c:		col = emittype(ty->type, lev + 1, col);
gen.c:		if (ty->size && ty->type->size)
gen.c:			print("=ar1;0;%d;", ty->size/ty->type->size - 1), col += 7+3+1;
gen.c:			print("=ar1;0;-1;"), col += 10;
gen.c:		col = emittype(ty->type, lev + 1, col);
gen.c:		if (!ty->u.sym->defined) {
gen.c:			print("=x%c%s:", ty->op == STRUCT ? 's' : 'u', ty->u.sym->name);
gen.c:			col += 2+1+strlen(ty->u.sym->name)+1;
gen.c:		if (lev > 0 && (*ty->u.sym->name < '0' || *ty->u.sym->name > '9')) {
gen.c:			ty->x.printed = 0;
gen.c:		print("=%c%d", ty->op == STRUCT ? 's' : 'u', ty->size), col += 1+1+3;
gen.c:		for (p = fieldlist(ty); p; p = p->link) {
gen.c:			if (p->name)
gen.c:				print("%s:", p->name), col += strlen(p->name)+1;
gen.c:			col = emittype(p->type, lev + 1, col);
gen.c:			/*if (p->lsb)
gen.c:				print(",%d,%d;", 8*p->offset +
gen.c:					(IR->little_endian ? fieldright(p) : fieldleft(p)),
gen.c:				print(",%d,%d;", 8*p->offset, 8*p->type->size);
gen.c:			if (col >= 80 && p->link) {
gen.c:		if (lev > 0 && (*ty->u.sym->name < '0' || *ty->u.sym->name > '9')) {
gen.c:			ty->x.printed = 0;
gen.c:		for (p = ty->u.sym->u.idlist; *p; p++) {
gen.c:			print("%s:%d,", (*p)->name, (*p)->u.value), col += strlen((*p)->name)+3;
gen.c:/* stabblock - output a stab entry for '{' or '}' at level lev */
gen.c:/* stabfend - end of function p */
gen.c:/* stabinit - initialize stab output */
gen.c:		/*(*IR->segment)(CODE);*/ segment( CODE ); /*CWK*/
gen.c:/* stabline - emit stab entry for source coordinate *cp */
gen.c:	if (cp->file && cp->file != currentfile) {
gen.c:				cp->file, N_SOL, lab);
gen.c:		currentfile = cp->file;
gen.c:	print(".stabd 0x%x,0,%d\n", N_SLINE, cp->y);
gen.c:/* stabsym - output a stab entry for symbol p */
gen.c:	int code, tc, sz = p->type->size;
gen.c:	if (p->generated || p->computed)
gen.c:	if (isfunc(p->type)) {
gen.c:		print(".stabs \"%s:%c%d\",%d,0,0,%s\n", p->name,
gen.c:			p->sclass == STATIC ? 'f' : 'F', dbxtype(freturn(p->type)),
gen.c:			N_FUN, p->x.name);
gen.c:	if (!IR->wants_argb && p->scope == PARAM && p->structarg) {
gen.c:		assert(isptr(p->type) && isstruct(p->type->type));
gen.c:		tc = dbxtype(p->type->type);
gen.c:		sz = p->type->type->size;
gen.c:		tc = dbxtype(p->type);
gen.c:	if (p->sclass == AUTO && p->scope == GLOBAL || p->sclass == EXTERN) {
gen.c:		print(".stabs \"%s:G", p->name);
gen.c:	} else if (p->sclass == STATIC) {
gen.c:		print(".stabs \"%s:%c%d\",%d,0,0,%s\n", p->name, p->scope == GLOBAL ? 'S' : 'V',
gen.c:			tc, p->u.seg == BSS ? N_LCSYM : N_STSYM, p->x.name);
gen.c:	} else if (p->sclass == REGISTER) {
gen.c:		if (p->scope > PARAM) {
gen.c:			int r = p->reg /* statt p->x.regnode->number CWK */;
gen.c:			/*if (p->x.regnode->set == FREG)
gen.c:			print(".stabs \"%s:r%d\",%d,0,", p->name, tc, N_RSYM);
gen.c:	} else if (p->scope == PARAM) {
gen.c:		print(".stabs \"%s:p", p->name);
gen.c:	} else if (p->scope >= LOCAL) {
gen.c:		print(".stabs \"%s:", p->name);
gen.c:		p->scope >= PARAM && p->sclass != EXTERN ? p->x.name : "0");
gen.c:/* stabtype - output a stab entry for type *p */
gen.c:	if (p->type) {
gen.c:		if (p->sclass == 0)
gen.c:			dbxtype(p->type);
gen.c:		else if (p->sclass == TYPEDEF)
gen.c:			print(".stabs \"%s:t%d\",%d,0,0,0\n", p->name, dbxtype(p->type), N_LSYM);
gen.c:/* symname - print prefix, p's name, declaration source coordinate, suffix */
gen.c:                print("%s@%w.%d", p->name, &p->src, p->src.x);
gen.c:/* stabend - finalize stab output */
gen.c:                print("%w.%d: ", cpp[i], cpp[i]->x);
init.c:/* defglobal - define a global or static variable in segment seg */
init.c:   swtoseg(p->u.seg = seg);
init.c:   if (p->sclass != STATIC)
init.c:      swtoseg(p->u.seg);
init.c:/* defpointer - initialize a pointer to p or to 0 if p==0 */
init.c:/* doconst - generate a variable for an out-of-line constant */
init.c:   if (p->u.c.loc) {
init.c:      defglobal(p->u.c.loc, p->u.c.loc->u.seg ? p->u.c.loc->u.seg : 
init.c:                  (p->shared)? GSDATA : DATA /*was: LIT*/ );    /*CWK 950320*/
init.c:      if (isarray(p->type)) {
init.c:         if (p->shared) {
init.c:            defstring(p->type->size, p->u.c.v.p);
init.c:            defstring(p->type->size, p->u.c.v.p);
init.c:         defconst(ttob(p->type), p->u.c.v, 0);
init.c:      p->u.c.loc->defined = 1;
init.c:      p->u.c.loc = 0;
init.c:/* genasgn - append tree for assignment of e to evolving structure expression in *sp */
init.c:   sp->off = roundup(sp->off, e->type->size);
init.c:   p = simplify(ADD+P, ptr(e->type), lvalue(idnode(sp->var)), constnode(sp->off, inttype));
init.c:   if (isarray(e->type)) {
init.c:      p = tree(ASGN+B, e->type, p, e);
init.c:      p->u.sym = intconst(e->type->size);
init.c:      p = asgnnode(ASGN, retype(rvalue(p), e->type), e);
init.c:   sp->tree = tree(RIGHT, voidtype, sp->tree, p);
init.c:   sp->off += e->type->size;
init.c:   return e->type->size;
init.c:/* genchar - generate assignment of string constant p to array in *sp */
init.c:   char *s = p->u.c.v.p;
init.c:   for (n = p->type->size; n > 0 && sp->off%inttype->align; n--)
init.c:      Type ty = array(chartype, p->type->size - (s - p->u.c.v.p), 0);
init.c:      v.p = stringn(s, ty->size);
init.c:      if (p->u.c.loc == 0)
init.c:         p->u.c.loc = genident(STATIC, ty, GLOBAL);
init.c:      e->u.sym = p->u.c.loc;
init.c:      e->u.sym = intconst(ty->size);
init.c:/* genconst - generate/check constant expression e; return size */
init.c:      switch (generic(e->op)) {
init.c:            defaddress(e->u.sym);
init.c:         return e->type->size;
init.c:         if (e->op == CNST+P && isarray(e->type)) {
init.c:           if (sy && sy->shared)      /* 980720*/
init.c:            defconst(ttob(e->type), e->u.v, 1);
init.c:            defconst(ttob(e->type), e->u.v, 0);
init.c:         return e->type->size;
init.c:         assert(e->kids[0] || e->kids[1]);
init.c:         if (e->kids[1] && e->kids[0])
init.c:         e = e->kids[1] ? e->kids[1] : e->kids[0];
init.c:         if (isarith(e->type))
init.c:               e->kids[0]->type, e->type);
init.c:         e = e->kids[0];
init.c:         return inttype->size;
init.c:/* genspace - generate n bytes of space or 0's */
init.c:   else if (n <= inttype->size)
init.c:      for ( ; n > 0; n--)
init.c:         zeros->sclass = STATIC;
init.c:         zeros->type = array(chartype, n, 0);
init.c:         zeros->generated = 1;
init.c:      if (n > zeros->type->size)
init.c:         zeros->type = array(chartype, n, 0);
init.c:      e = tree(INDIR+B, zeros->type, idnode(zeros), 0);
init.c:      e->u.sym = intconst(n);
init.c:/* initarray - initialize array of ty of <= len bytes; if len == 0, go to } */
init.c:      n += ty->size;
init.c:/* initchar - initialize array of <= len ty characters; if len == 0, go to } */
init.c:               e->type, ty);
init.c:         *s++ = initvalue(ty)->u.v.sc;
init.c:         if (++n%inttype->size == 0) {
init.c:            defstring(inttype->size, buf);
init.c:      defstring(s - buf, buf);
init.c:/* initend - finish off an initialization at level lev; accepts trailing comma */
init.c:/* initfields - initialize <= an unsigned's worth of bit fields in fields p to q */
init.c:         if (fieldsize(p) < 8*p->type->size)
init.c:         if (p->link == q)
init.c:         p = p->link;
init.c:      if (q && (n = q->offset - p->offset) < unsignedtype->size)
init.c:         for (i = n - 1; i >= 0; i--) {
init.c:               constnode(8*(unsignedtype->size - n + i), inttype));
init.c:      i = initvalue(inttype)->u.v.i;
init.c:      if (fieldsize(p) < 8*p->type->size) {
init.c:         if (p->type == inttype && i >= 0 && (i&~(fieldmask(p)>>1)) !=  0
init.c:         ||  p->type == inttype && i <  0 && (i| (fieldmask(p)>>1)) != ~0
init.c:         ||  p->type == unsignedtype      && (i& ~fieldmask(p)))
init.c:            warning("initializer exceeds bit-field width\n");
init.c:      if (p->to > n)
init.c:         n = p->to;
init.c:      if (p->link == q)
init.c:      p = p->link;
init.c:      v.uc = bits>>(8*(unsignedtype->size - 1));
init.c:/* initglobal - a new global identifier p, possibly initialized */
init.c:      if (p->sclass == STATIC) {
init.c:         for (ty = p->type; isarray(ty); ty = ty->type)
init.c:         defglobal(p, /*isconst(ty) ? LIT : */ ( (p->shared)? GSDATA:DATA));  /*CWK*/
init.c:         defglobal(p, (p->shared)? GSDATA:DATA);  /*CWK*/
init.c:         if (p && p->shared) {
init.c:             print("%s = ", typestring( p->type, stringf("__%s",p->name )));
init.c:      ty = initializer(p->type, 0, p);
init.c:      if (isarray(p->type) && p->type->size == 0)
init.c:         p->type = ty;
init.c:      p->defined = 1;
init.c:      if (p->sclass == EXTERN)
init.c:         p->sclass = AUTO;
init.c:/* initializer - constexpr | { constexpr ( , constexpr )* [ , ] } */
init.c:   if (sy && lev==GLOBAL && sy->shared)
init.c:            e->type, ty);
init.c:         needconst--;
init.c:   if ((isunion(ty) || isstruct(ty)) && ty->size == 0) {
init.c:         n = initstruct(ty->u.sym->u.s.flist->type->size, ty, lev + 1);
init.c:         n = initstruct(ty->u.sym->u.s.flist->type->size, ty, lev + 1);
init.c:               e->type, ty);
init.c:         n = ty->size;
init.c:         n = initstruct(ty->size, ty, lev + 1);
init.c:         n = initstruct(ty->u.sym->u.s.flist->type->size, ty, lev + 1);
init.c:      aty = unqual(ty->type);
init.c:         if (ty->size > 0 && ty->size == tsym->type->size - 1)
init.c:            tsym->type = array(chartype, ty->size, STRUCT_ALIGN);
init.c:         n = tsym->type->size;
init.c:            defstring(tsym->type->size, tsym->u.c.v.p);
init.c:      } else if (lev > 0 && ty->size > 0)
init.c:         n = initchar(ty->size, aty);
init.c:      } else if (lev > 0 && ty->size > 0)
init.c:         n = initarray(ty->size, aty, lev + 1);
init.c:         n = initarray(aty->size, aty, lev + 1);
init.c:   if (ty->size) {
init.c:      if (n > ty->size)
init.c:      else if (n < ty->size)
init.c:         genspace(ty->size - n, current);
init.c:   } else if (isarray(ty) && ty->type->size > 0)
init.c:      ty = array(ty->type, n/ty->type->size, 0);
init.c:      ty->size = n;
init.c:/* initstruct - initialize a struct ty of <= len bytes; if len == 0, go to } */
init.c:   Field p = ty->u.sym->u.s.flist;
init.c:      if (p->offset > n) {
init.c:         genspace(p->offset - n, current);
init.c:         n += p->offset - n;
init.c:      if (p->to) {
init.c:         while (q->link && q->link->offset == p->offset)
init.c:            q = q->link;
init.c:         n += initfields(p, q->link);
init.c:         initializer(p->type, lev, 0);
init.c:         n += p->type->size;
init.c:      if (p->link) {
init.c:         p = p->link;
init.c:         a = p->type->align;
init.c:         a = ty->align;
init.c:         genspace(a - n%a, current);
init.c:/* initvalue - evaluate a constant expression for a value of integer type ty */
init.c:         e->type,  ty);
init.c:   needconst--;
init.c:   if (generic(e->op) != CNST) {
init.c:/* structexp - in-line structure expression '{' expr ( , expr )* [ , ] '}' */
init.c:/* swtoseg - switch to segment seg, if necessary */
input.c:/* inputInit - initialize input processing */
input.c:   bsize = -1;
input.c:/* inputstring - arrange to read str as next input */
input.c:/* fillbuf - fill the input buffer, moving tail portion if necessary */
input.c:      int n = limit - cp;
input.c:      unsigned char *s = &buffer[MAXTOKEN + 1] - n;
input.c:      line = (char *)s - ((char *)cp - line);
input.c:      cp = &buffer[MAXTOKEN + 1] - n;
input.c:/* nextline - prepare to read next line */
input.c:/* pragma - handle #pragma ref id... */
input.c:            tsym->ref++;
input.c:/* resynch - set line number/file name in # n [ "file" ] and #pragma ... */
input.c:   if (limit - cp < MAXTOKEN)
input.c:         lineno = 10*lineno + *cp++ - '0';
input.c:      lineno--;
input.c:            file = stringn(buf, s - buf);
input.c:            file = stringn(file, (char *)cp - file);
lex.c:#define   BAD   040   /* non-portable characters */
lex.c:/* 055 -   */   0,
lex.c:/* asmargs - break out %name in string p, fill in argv, returned edited string */
lex.c:   if (p->type->size >= MAXLINE) {
lex.c:   for (s2 = str, s1 = p->u.c.v.p; *s1; )
lex.c:         if ((argv[n] = lookup(stringn(s1, t - s1), identifiers))
lex.c:         && argv[n]->sclass != TYPEDEF && argv[n]->sclass != ENUM) {
lex.c:            argv[n]->ref += refinc;
lex.c:            argv[n]->initialized = 1;   /* in case ref overflows */
lex.c:               n = size - 1;
lex.c:               *s2++ = n - 1;
lex.c:   return stringn(str, s2 - str);
lex.c:/* assem - parse asm("assembly code") */
lex.c:      warning("non-ANSI asm\n");
lex.c:         codelist->u.acode.code = s;
lex.c:         codelist->u.acode.argv = argv;
lex.c:/* backslash - get next character with \'s interpreted in q ... q */
lex.c:            error("ill-formed hexadecimal escape sequence\n");
lex.c:            error("ill-formed hexadecimal escape sequence `\\x%c'\n", *cp);
lex.c:         if (c&~((unsigned)-1 >> 4))
lex.c:            c = (c<<4) + *cp - '0';
lex.c:            c = (c<<4) + (*cp&~040) - 'A' + 10;
lex.c:      c = *(cp-1) - '0';
lex.c:         c = (c<<3) + *cp++ - '0';
lex.c:            c = (c<<3) + *cp++ - '0';
lex.c:      if (cp[-1] < ' ' || cp[-1] >= 0177)
lex.c:         warning("unrecognized character escape sequence `\\%c'\n", cp[-1]);
lex.c:   return cp[-1];
lex.c:/* fcon - scan for tail of a floating constant, set token, return symbol */
lex.c:      n += *s++ - '0';
lex.c:         n += *cp - '0';
lex.c:      if (*++cp == '-' || *cp == '+')
lex.c:/* getchr - return next significant character */
lex.c:/* gettok - return next token */
lex.c:      if (limit - rcp < MAXTOKEN) {
lex.c:      src.x = (char *)rcp - line;
lex.c:         cp = rcp - 1;
lex.c:         token = (char *)rcp - 1;
lex.c:                  d = *rcp - '0';
lex.c:                  d = *rcp - 'a' + 10;
lex.c:                  d = *rcp - 'A' + 10;
lex.c:               if (n&~((unsigned)-1 >> 4))
lex.c:            if ((char *)rcp - token <= 2)
lex.c:               if (n&~((unsigned)-1 >> 3))
lex.c:                  n = (n<<3) + (unsigned)(*rcp - '0');
lex.c:         for (n = *token - '0'; map[*rcp]&DIGIT; ) {
lex.c:            d = *rcp++ - '0';
lex.c:            if (n > ((unsigned)UINT_MAX - d)/10)
lex.c:            src.x--;
lex.c:         *s++ = *--rcp;
lex.c:                  if (limit - cp < MAXTOKEN)
lex.c:               if (s < &cbuf[sizeof cbuf] - 2)
lex.c:         if (Aflag >= 2 && cbuf[0] == '"' && s - cbuf - 1 > 509)
lex.c:            warning("%s literal contains non-portable characters\n",
lex.c:            tval.type = array(chartype, s - cbuf - 1, STRUCT_ALIGN);
lex.c:            if (s - cbuf > 3)
lex.c:            else if (s - cbuf <= 2)
lex.c:      case '-':
lex.c:         if (*rcp == '-') {
lex.c:         return '-';
lex.c:         return *(rcp-1);
lex.c:         token = (char *)rcp - 1;
lex.c:            token = stringn(cbuf, s - cbuf);
lex.c:            token = stringn(token, (char *)rcp - token);
lex.c:         if (map[cp[-1]]&BLANK)
lex.c:         if (cp[-1] < ' ' || cp[-1] >= 0177)
lex.c:            error("illegal character `\\0%o'\n", cp[-1]);
lex.c:            error("illegal character `%c'\n", cp[-1]);
lex.c:/* icon - scan for tail of an integer constant n, set token, return symbol */
main.c:int Aflag;         /* >= 0 if -A specified */
main.c:int Pflag;         /* != 0 if -P specified */
main.c:int Kflag;         /* != 0 if -K specified CWK ->generate consistency checks*/
main.c:int isFORKmodul = 0;   /* != 0 if -FORK specified CWK */
main.c:int glevel;         /* == [0-9] if -g[0-9] specified */
main.c:int xref;         /* != 0 for cross-reference data */
main.c:Symbol YYnull;         /* symbol for _YYnull if -n specified */
main.c:   assert(inttype->size >= voidptype->size);
main.c:   if (infile && *infile != '-') {
main.c:   if (outfile && *outfile != '-') {
main.c:/* compile - compile str */
main.c:/* readpath - Read a path string from argument -S pathname  CWK*/
main.c:/* doargs - process program arguments, removing top-half arguments from argv */
main.c:      if (strcmp(argv[i], "-g") == 0)
main.c:      else if (strncmp(argv[i], "-g", 2) == 0
main.c:         glevel = argv[i][2] - '0';
main.c:      else if (strcmp(argv[i], "-x") == 0)
main.c:      else if (strcmp(argv[i], "-A") == 0)
main.c:      else if (strcmp(argv[i], "-P") == 0)
main.c:      else if (strcmp(argv[i], "-K") == 0)              /*CWK*/
main.c:      else if (strcmp(argv[i], "-ForkLight") == 0)      /*CWK*/
main.c:      else if (strcmp(argv[i], "-w") == 0)
main.c:      else if (strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "-C") == 0
main.c:      || strncmp(argv[i], "-a", 2) == 0)
main.c:      else if (strncmp(argv[i],"-G", 2)==0)       /*CWK: read source path*/
main.c:      else if (strncmp(argv[i],"-nprocs",7)==0)       /*CWK*/
main.c:               sscanf(argv[i],"-nprocs%d", &STARTED_PROCS);
main.c:      else if (strcmp(argv[i], "-n") == 0) {
main.c:            YYnull->sclass = STATIC;
main.c:      } else if (strncmp(argv[i], "-t", 2) == 0)
main.c:      else if (strcmp(argv[i], "-v") == 0)
main.c:      else if (strncmp(argv[i], "-s", 2) == 0)
main.c:      else if (strncmp(argv[i], "-e", 2) == 0) {
main.c:         (p = lookup(stringn(argv[i], s - argv[i]), types))) {
main.c:               p->type->size = x;
main.c:               p->type->align = x;
main.c:            p->addressed = !(*s == 0 || *s == '0');
main.c:      } else if (strcmp(argv[i], "-") == 0 || *argv[i] != '-') {
main.c:         if (strcmp(argv[i], "-XP") == 0)
main.c:            argv[i] = "-p";
main.c:         else if (strncmp(argv[i], "-X", 2) == 0)
main.c:            *++argv[i] = '-';
main.c:/* emitYYnull - compile definition for _YYnull, if referenced */
main.c:   if (YYnull && YYnull->ref > 0) {
main.c:      YYnull->defined = 0;
main.c:      YYnull->ref = 1000;
main.c:/* ftype - return a function type for `rty function (ty,...)' */
main.c:/* mkstr - make a string constant */
main.c:   if (p->u.c.loc == 0) {
main.c:      p->u.c.loc = genident(STATIC, p->type, GLOBAL);
main.c:/* mksymbol - make a symbol for name, install in &globals if sclass==EXTERN */
main.c:      p->name = string(name);
main.c:      p->scope = GLOBAL;
main.c:   p->sclass = sclass;
main.c:   p->type = ty;
main.c:   p->defined = 1;
main.c:/* typestab - emit stab entries for p */
main.c:   if (*(Symbol *)cl == 0 && p->sclass && p->sclass != TYPEDEF)
main.c:   if (p->sclass == TYPEDEF || p->sclass == 0)
main.c:int npoints;      /* # of execution points if -b specified */
main.c:int ncalled = -1;   /* #times prof.out says current function was called */
main.c:static Symbol YYcounts;   /* symbol for _YYcounts if -b specified */
main.c:/* bbcall - build tree to set _callsite at call site *cp, emit call site data */
main.c:   defpointer(cp->file ? mkstr(cp->file)->u.c.loc : 0);
main.c:   defpointer(mkstr(cfunc->name)->u.c.loc);
main.c:   u.c.x = cp->x;
main.c:   u.c.y = cp->y;
main.c:/* bbentry - return tree for `_prologue(&afunc, &YYlink)' */
main.c:   walk(callnode(pointer(idnode(p)), freturn(p->type),
main.c:/* bbexit - return tree for `_epilogue(&afunc)' */
main.c:   walk(callnode(pointer(idnode(p)), freturn(p->type),
main.c:/* bbfile - add file to list of file names, return its index */
main.c:            lp = lp->link;
main.c:            if (((Symbol)lp->x)->u.c.v.p == file)
main.c:/* bbfunc - emit function name and src coordinates */
main.c:   defglobal(afunc, (f->shared)? GSDATA:DATA);  /*CWK*/
main.c:   defpointer(mkstr(f->name)->u.c.loc);
main.c:   u.c.x = f->u.f.pt[2].x;
main.c:   u.c.y = f->u.f.pt[2].y;
main.c:   u.c.index = bbfile(f->u.f.pt[2].file);
main.c:/* bbincr - build tree to increment execution point at *cp */
main.c:   struct map *mp = (struct map *)maplist->x;
main.c:   if (mp->size >= sizeof mp->u/sizeof mp->u[0]) {
main.c:      mp->size = 0;
main.c:   mp->u[mp->size].c.x = cp->x;
main.c:   mp->u[mp->size].c.y = cp->y;
main.c:   mp->u[mp->size++].c.index = bbfile(cp->file);
main.c:/* bbinit - initialize basic block counting options */
main.c:   if (strncmp(opt, "-a", 2) == 0) {
main.c:      if (ncalled == -1 && process(opt[2] ? &opt[2] : "prof.out") > 0)
main.c:   } else if ((strcmp(opt, "-b") == 0 || strcmp(opt, "-C") == 0) && YYlink == 0) {
main.c:      if (strcmp(opt, "-b") == 0) {
main.c:         ((struct map *)maplist->x)->size = 0;
main.c:/* bbvars - emit definition for basic block counting data */
main.c:      defglobal(YYcounts, (YYcounts->shared)? GSBSS:BSS);  /*CWK*/
main.c:      space(n*YYcounts->type->type->size);
main.c:      defpointer((*p)->u.c.loc);
main.c:   for (i = n, mp = (struct map **)ltoa(maplist, 0); *mp; i -= (*mp)->size, mp++)
main.c:      for (j = 0; j < (*mp)->size; j++)
main.c:         defconst(U, (v.u = (*mp)->u[j].coord, v), 0);
main.c:      space(i*coords->type->type->size);
main.c:   defglobal(yylink, (yylink->shared)? GSDATA:DATA);  /*CWK*/
main.c:/* appendstr - append str to the evolving format string, expanding it if necessary */
main.c:            char *s = (char *)talloc(2*(fmtend - fmt));
main.c:            strncpy(s, fmt, fmtend - fmt);
main.c:            fp = s + (fmtend - fmt);
main.c:            fmtend = s + 2*(fmtend - fmt);
main.c:   fp--;
main.c:/* tracecall - generate code to trace entry to f */
main.c:   space(counter->type->size);
main.c:   appendstr(f->name); appendstr("#");
main.c:   for (i = 0; f->u.f.callee[i]; i++) {
main.c:      appendstr(f->u.f.callee[i]->name); appendstr("=");
main.c:      tracevalue(idnode(f->u.f.callee[i]), 0);
main.c:   if (variadic(f->type))
main.c:/* tracefinis - complete & generate the trace call to print */
main.c:   for (ap = &args; *ap; ap = &(*ap)->kids[1])
main.c:   *ap = tree(ARG+P, ptr(chartype), pointer(idnode(p->u.c.loc)), 0);
main.c:   walk(callnode(pointer(idnode(printer)), freturn(printer->type), args), 0, 0);
main.c:/* traceinit - initialize for tracing */
main.c:      printer->sclass = EXTERN;
main.c:/* tracereturn - generate code to trace return e */
main.c:   appendstr(f->name); appendstr("#");
main.c:   if (freturn(f->type) != voidtype && e) {
main.c:/* tracevalue - append format and argument to print the value of e */
main.c:   Type ty = unqual(e->type);
main.c:   switch (ty->op) {
main.c:      if (unqual(ty->type) == chartype) {
main.c:         e = condnode(e, e, pointer(idnode(null->u.c.loc)));
main.c:      for (q = ty->u.sym->u.s.flist; q; q = q->link) {
main.c:         appendstr(q->name); appendstr("=");
main.c:         tracevalue(field(addrof(e), q->name), lev + 1);
main.c:         if (q->link)
main.c:      if (lev && ty->type->size > 0) {
main.c:         for (i = 0; i < ty->size/ty->type->size; i++) {
main.c:            if (isptr(p->type) && isarray(p->type->type))
main.c:               p = retype(p, p->type->type);
main.c:   else if ((isint(ty) || isenum(ty)) && ty->size != inttype->size)
main.c:   args = tree(ARG + widen(e->type), e->type, e, args);
main.c:   p->func = func;
main.c:   p->cl = cl;
main.c:         struct entry *p = (struct entry *)lp->x;
main.c:         (*p->func)(p->cl, arg1, arg2);
main.c:         lp = lp->link;
main.c:/* ======================= CWK: libfname-handling ==================== */
output.c:   1, buf1, buf1, buf1 + sizeof buf1 - 80,
output.c:   2, buf2, buf2, buf2 + sizeof buf2 - 80
output.c:/* fprint - formatted output to file descriptor f */
output.c:/* outflush - flush output buffer; writes last buffer first */
output.c:   if (bp > iop->buffer)
output.c:      write(iop->fd, iop->buffer, bp - iop->buffer);
output.c:   bp = iop->bp = iop->buffer;
output.c:/* outs - output string s */
output.c:   if (bp > io[fd]->limit)
output.c:/* print - formatted output to standard output */
output.c:/* stringf - formatted output to a saved string */
output.c:   io[1]->bp = bp;
output.c:   bp = io[0]->bp = io[0]->buffer = buf;
output.c:   io[0]->limit = buf + MAXLINE;
output.c:   bp = io[1]->bp;
output.c:/* vfprint - formatted output to file descriptor f */
output.c:      io[1]->bp = bp;
output.c:      io[2]->fd = f;
output.c:      bp = io[2]->bp;
output.c:      bp = io[1]->bp;
output.c:/* vprint - formatted output to standard output */
output.c:            *--s = 0;
output.c:               m = -n;
output.c:               *--s = m%10 + '0';
output.c:               *--s = '-';
output.c:            *--s = 0;
output.c:               *--s = (n&7) + '0';
output.c:            *--s = 0;
output.c:               *--s = "0123456789abcdef"[n&0xf];
output.c:            if (p->file && *p->file)
output.c:               print("%s:", p->file);
output.c:            print("%d", p->y);
output.c:      else if ((*bp++ = *fmt) == '\n' && bp > io[fd]->limit)
profio.c: *    ... (#files-1 times)
profio.c: *    ... (#functions-1 times)
profio.c: *    ... (#points-1 times)
profio.c:struct file {         /* per-file prof.out data: */
profio.c:   int count;         /* counts[0..count-1] hold valid data */
profio.c:#define EOF -1
profio.c:/* acaller - add caller and site (file,x,y) to callee's callers list */
profio.c:   for (q = callee->callers; q && (caller != q->name
profio.c:      || file != q->file || x != q->x || y != q->y); q = q->link)
profio.c:      q->name = caller;
profio.c:      q->file = file;
profio.c:      q->x = x;
profio.c:      q->y = y;
profio.c:      q->count = 0;
profio.c:      for (r = &callee->callers; *r && (strcmp(q->name, (*r)->name) > 0
profio.c:         || strcmp(q->file, (*r)->file) > 0 || q->y > (*r)->y || q->y > (*r)->y); r = &(*r)->link)
profio.c:      q->link = *r;
profio.c:   q->count += count;
profio.c:/* afunction - add function name and its data to file's function list */
profio.c:   for (q = p->funcs; q && name != q->name; q = q->link)
profio.c:      q->name = name;
profio.c:      q->count.x = x;
profio.c:      q->count.y = y;
profio.c:      q->count.count = 0;
profio.c:      q->callers = 0;
profio.c:      for (r = &p->funcs; *r && compare(&q->count, &(*r)->count) > 0; r = &(*r)->link)
profio.c:      q->link = *r;
profio.c:   q->count.count += count;
profio.c:/* apoint - append execution point i to file's data */ 
profio.c:   if (i >= p->size) {
profio.c:      if (p->size == 0) {
profio.c:         p->size = i >= 200 ? 2*i : 200;
profio.c:         p->counts = (struct count *)alloc(p->size*sizeof(struct count));
profio.c:         p->size = 2*i;
profio.c:         new = (struct count *)alloc(p->size*sizeof(struct count));
profio.c:         for (j = 0; j < p->count; j++)
profio.c:            new[j] = p->counts[j];
profio.c:         p->counts = new;
profio.c:      for (j = p->count; j < p->size; j++) {
profio.c:         p->counts[j] = z;
profio.c:   p->counts[i].x = x;
profio.c:   p->counts[i].y = y;
profio.c:   p->counts[i].count += count;
profio.c:   if (i >= p->count)
profio.c:      p->count = i + 1;
profio.c:/* compare - return <0, 0, >0 if a<b, a==b, a>b, resp. */
profio.c:   if (a->y == b->y)
profio.c:      return a->x - b->x;
profio.c:   return a->y - b->y;
profio.c:/* findcount - return count associated with (file,x,y) or -1 */
profio.c:   if (cursor == 0 || cursor->name != file)
profio.c:      struct count *c = cursor->counts;
profio.c:      for (l = 0, u = cursor->count - 1; l <= u; ) {
profio.c:            u = k - 1;
profio.c:   return -1;
profio.c:/* findfile - return file name's file list entry, or 0 */
profio.c:   for (p = filelist; p; p = p->link)
profio.c:      if (p->name == name)
profio.c:/* findfunc - return count associated with function name in file or -1 */
profio.c:   if (cursor == 0 || cursor->name != file)
profio.c:      for (p = cursor->funcs; p; p = p->link)
profio.c:         if (p->name == name)
profio.c:            return p->count.count;
profio.c:   return -1;
profio.c:/* gather - read prof.out data from fd */
profio.c:         return -1;
profio.c:         new->name = files[i];
profio.c:         new->size = new->count = 0;
profio.c:         new->counts = 0;
profio.c:         new->funcs = 0;
profio.c:         new->link = filelist;
profio.c:      return -1;
profio.c:         return -1;
profio.c:      q = afunction(name, files[f-1], x, y, count);
profio.c:         return -1;
profio.c:      return -1;
profio.c:         return -1;
profio.c:         apoint(i, files[f-1], x, y, count);
profio.c:/* getd - read a non-negative number */
profio.c:         n = 10*n + (c - '0');
profio.c:   return -1;
profio.c:/* getstr - read a string */
profio.c:      if (s - buf < sizeof buf - 2)
profio.c:/* process - read prof.out data from file */
profio.c:      for (p = filelist; p; p = p->link)
profio.c:         qsort(p->counts, p->count, sizeof *p->counts,
simp.c:/* add - return 1 if min <= x+y <= max, 0 otherwise */
simp.c:   || x < 0 && y < 0 && x >= min - y
simp.c:   || x > 0 && y > 0 && x <= max - y;
simp.c:/* addrnode - create a tree for addressing expression p+n, type ty */
simp.c:   q->name = stringd(genlabel(1));
simp.c:   q->sclass = p->sclass;
simp.c:   q->scope = p->scope;
simp.c:   q->type = ty;
simp.c:   q->defined = 1;
simp.c:   q->temporary = p->temporary;
simp.c:   q->generated = p->generated;
simp.c:   q->computed = 1;
simp.c:   q->addressed = p->addressed;
simp.c:   q->initialized = p->initialized;
simp.c:   q->ref = 1;
simp.c:   if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
simp.c:      q->sclass = p->sclass == AUTO ? STATIC : p->sclass;
simp.c:      if (p->shared) e = tree(ADDRSG+P, ty, 0, 0);  /*CWK*/
simp.c:      if (!p->defined)
simp.c:      cp->u.addr.sym = q;
simp.c:      cp->u.addr.base = p;
simp.c:      cp->u.addr.offset = n;
simp.c:      if (p->shared) e = tree(p->scope == PARAM ? ADDRSF+P : ADDRSL+P, ty, 0, 0);
simp.c:      else          e = tree(p->scope == PARAM ? ADDRF+P : ADDRL+P, ty, 0, 0);/*CWK*/
simp.c:   e->u.sym = q;
simp.c:   e->maybe_pr = 1;  /*Pointer->worst case   CWK*/
simp.c:/* div - return 1 if min <= x/y <= max, 0 otherwise */
simp.c:   if (x < 0) x = -x;
simp.c:   if (y < 0) y = -y;
simp.c:/* ispow2 - if u > 1 && u == 2^n, return n, otherwise return 0 */
simp.c:   if (u > 1 && (u&(u-1)) == 0)
simp.c:/* mul - return 1 if min <= x*y <= max, 0 otherwise */
simp.c:   int cond = x > -1 && x <= 1 || y > -1 && y <= 1
simp.c:   || x < 0 && y < 0 && -x <= max/-y
simp.c:   if (l->op == CNST+FTYPE) { \
simp.c:   if (l->op == CNST+FTYPE) { \
simp.c:   if (generic(R->op) == CNST && generic(L->op) != CNST) { \
simp.c:   if (l->op == FIELD && r->op == CNST+TYPE && r->u.v.VAR == 0) \
simp.c:      return eqnode(OP, bitnode(BAND, l->kids[0], \
simp.c:         constnode(fieldmask(l->u.field)<<fieldright(l->u.field), \
simp.c:#define ufoldcnst(TYPE,EXP) if (l->op == CNST+TYPE) return EXP
simp.c:   if (l->op == CNST+TYPE && r->op == CNST+TYPE \
simp.c:   && FUNC((double)l->u.v.VAR,(double)r->u.v.VAR,(double)MIN,(double)MAX, needconst)) { \
simp.c:      p->u.v.VAR = l->u.v.VAR OP r->u.v.VAR; return p; }
simp.c:   if (l->op == CNST+TYPE && r->op == CNST+TYPE) { \
simp.c:      p->u.v.VAR = l->u.v.VAR OP r->u.v.VAR; return p; }
simp.c:   if (l->op == CNST+TYPE && r->op == CNST+TYPE) { \
simp.c:      p->u.v.i = l->u.v.VAR OP r->u.v.VAR; return p; }
simp.c:   if (l->op == CNST+TYPE && r->op == CNST+I \
simp.c:   && r->u.v.i >= 0 && r->u.v.i < 8*l->type->size) { \
simp.c:      p->u.v.VAR = l->u.v.VAR OP r->u.v.i; return p; }
simp.c:   if (L->op == CNST+P && R->op == CNST+RTYPE) { \
simp.c:      p->u.v.p = L->u.v.p + R->u.v.VAR; return p; }
simp.c:   if (R->op == CNST+U && R->u.v.u == 0) { \
simp.c:#define idempotent(OP) if (l->op == OP) return l->kids[0];
simp.c:#define identity(X,Y,TYPE,VAR,VAL) if (X->op == CNST+TYPE && X->u.v.VAR == VAL) return Y
simp.c:/* simplify - build node for op, simplifying and folding constants, if possible */
simp.c:   if (l) maybepr = l->maybe_pr;             /*CWK*/
simp.c:   if (r) maybepr = maybepr || r->maybe_pr;
simp.c:      xfoldcnst(D,d,+,doubletype,add,-DBL_MAX,DBL_MAX);
simp.c:      xfoldcnst(F,f,+,floattype,add,-FLT_MAX,FLT_MAX);
simp.c:      if (isaddrop(l->op) && (r->op == CNST+I || r->op == CNST+U))
simp.c:         return addrnode(l->u.sym, r->op == CNST+I ? r->u.v.i : r->u.v.u, ty);
simp.c:      if ((l->op == ADD+I || l->op == SUB+I)
simp.c:      && l->kids[1]->op == CNST+I && isaddrop(r->op))
simp.c:         /* (x +- c) + r => x + r+-c, where r is a symbolic address */
simp.c:         return simplify(ADD+P, ty, l->kids[0],
simp.c:            simplify(l->op == ADD+I ? ADD+P : SUB+P, ty, r, l->kids[1]));
simp.c:      if (l->op == ADD+P && isaddrop(l->kids[1]->op)
simp.c:      && (r->op == CNST+I || r->op == CNST+U))
simp.c:         return simplify(ADD+P, ty, l->kids[0],
simp.c:            addrnode(l->kids[1]->u.sym, r->op == CNST+I ? r->u.v.i : r->u.v.u, ty));
simp.c:      if (l->op == ADD+P && generic(l->kids[1]->op) == CNST && generic(r->op) == CNST)
simp.c:         return simplify(ADD+P, ty, l->kids[0], (*opnode['+'])(ADD, l->kids[1], r));
simp.c:      if (l->op == ADD+I && generic(l->kids[1]->op) == CNST
simp.c:      &&  r->op == ADD+P && generic(r->kids[1]->op) == CNST)
simp.c:         return simplify(ADD+P, ty, l->kids[0],
simp.c:            simplify(ADD+P, ty, r->kids[0],
simp.c:            (*opnode['+'])(ADD, l->kids[1], r->kids[1])));
simp.c:      if (l->op == RIGHT && isstruct(l->type))   /* f().x */
simp.c:         return tree(RIGHT, ty, l->kids[0],
simp.c:            simplify(ADD+P, ty, l->kids[1], r));
simp.c:      if (l->op == RIGHT)
simp.c:         if (l->kids[1])
simp.c:            return tree(RIGHT, ty, l->kids[0],
simp.c:               simplify(ADD+P, ty, l->kids[1], r));
simp.c:               simplify(ADD+P, ty, l->kids[0], r), 0);
simp.c:      ufoldcnst(I,l->u.v.i ? cond(r) : l);   /* 0&&r => 0, 1&&r => r */
simp.c:      ufoldcnst(I,l->u.v.i ? constnode(1, inttype) : cond(r));
simp.c:      if (r->op == CNST+U && r->u.v.u == 0)   /* l&0 => (l,0) */
simp.c:      ufoldcnst(I,constnode(~l->u.v.i, inttype));
simp.c:      ufoldcnst(U,constnode(~l->u.v.u, unsignedtype));
simp.c:   case CVC+I:  cvtcnst(C,      inttype,p->u.v.i  = (l->u.v.sc&0200 ? (~0<<8) : 0)|(l->u.v.sc&0377)); break;
simp.c:   case CVC+U:  cvtcnst(C, unsignedtype,p->u.v.u  = l->u.v.uc); break;
simp.c:   case CVD+F: xcvtcnst(D,    floattype,p->u.v.f  = l->u.v.d,l->u.v.d,-FLT_MAX,FLT_MAX); break;
simp.c:   case CVD+I: xcvtcnst(D,      inttype,p->u.v.i  = l->u.v.d,l->u.v.d,INT_MIN,INT_MAX); break;
simp.c:   case CVF+D:  cvtcnst(F,   doubletype,p->u.v.d  = l->u.v.f);  break;
simp.c:   case CVI+C: xcvtcnst(I,     chartype,p->u.v.sc = l->u.v.i,l->u.v.i,SCHAR_MIN,SCHAR_MAX); break;
simp.c:   case CVI+D:  cvtcnst(I,   doubletype,p->u.v.d  = l->u.v.i);  break;
simp.c:   case CVI+S: xcvtcnst(I,    shorttype,p->u.v.ss = l->u.v.i,l->u.v.i,SHRT_MIN,SHRT_MAX); break;
simp.c:   case CVI+U:  cvtcnst(I, unsignedtype,p->u.v.u  = l->u.v.i);  break;
simp.c:   case CVP+U:  cvtcnst(P, unsignedtype,p->u.v.u  = (unsigned)l->u.v.p); break;
simp.c:   case CVS+I:  cvtcnst(S,      inttype,p->u.v.i  = l->u.v.ss); break;
simp.c:   case CVS+U:  cvtcnst(S, unsignedtype,p->u.v.u  = l->u.v.us); break;
simp.c:   case CVU+C:  cvtcnst(U, unsignedchar,p->u.v.uc = l->u.v.u);  break;
simp.c:   case CVU+D:  cvtcnst(U,   doubletype,p->u.v.d  = utod(l->u.v.u));  break;
simp.c:      if (needconst && l->u.v.u > INT_MAX)
simp.c:      if (needconst || l->u.v.u <= INT_MAX)
simp.c:         cvtcnst(U,   inttype,p->u.v.i  = l->u.v.u);
simp.c:   case CVU+P:  cvtcnst(U,    voidptype,p->u.v.p  = (char *)l->u.v.u);  break;
simp.c:   case CVU+S:  cvtcnst(U,unsignedshort,p->u.v.us = l->u.v.u);  break;
simp.c:      xfoldcnst(D,d,/,doubletype,div,-DBL_MAX,DBL_MAX);
simp.c:      xfoldcnst(F,f,/,floattype,div,-FLT_MAX,FLT_MAX);
simp.c:      if (l->op == CNST+I && r->op == CNST+I && r->u.v.i == -1
simp.c:      && !div((double)l->u.v.i, (double)r->u.v.i, (double)INT_MIN, (double)INT_MAX, 0))
simp.c:      if (r->op == CNST+U && r->u.v.u == 0)
simp.c:      if (r->op == CNST+U && (n = ispow2(r->u.v.u)))
simp.c:      if (l->op == CNST+U && l->u.v.u == 0)   /* 0 >= r => 0 == r */
simp.c:      if (r->op == CNST+U && r->u.v.u == 0)   /* l > 0 => l != 0 */
simp.c:      if (r->op == CNST+U && r->u.v.u == 0)   /* l <= 0 => l == 0 */
simp.c:      if (l->op == CNST+I && r->op == CNST+I
simp.c:      && r->u.v.i >= 0 && r->u.v.i < 8*l->type->size
simp.c:      && mul((double)l->u.v.i, (double)(1<<r->u.v.i), (double)INT_MIN, (double)INT_MAX, needconst))
simp.c:         return constnode(l->u.v.i<<r->u.v.i, inttype);
simp.c:      if (l->op == CNST+U && l->u.v.u == 0)   /* 0 < r => 0 != r */
simp.c:      if (r->op == CNST+I && r->u.v.i == 1)   /* l%1 => (l,0) */
simp.c:      if (r->op == CNST+I && r->u.v.i == 0)
simp.c:      if (l->op == CNST+I && r->op == CNST+I && r->u.v.i == -1
simp.c:      && !div((double)l->u.v.i, (double)r->u.v.i, (double)INT_MIN, (double)INT_MAX, 0))
simp.c:      if (r->op == CNST+U && ispow2(r->u.v.u))   /* l%2^n => l&(2^n-1) */
simp.c:            constnode(r->u.v.u - 1, unsignedtype));
simp.c:      if (r->op == CNST+U && r->u.v.u == 0)
simp.c:      xfoldcnst(D,d,*,doubletype,mul,-DBL_MAX,DBL_MAX);
simp.c:      xfoldcnst(F,f,*,floattype,mul,-FLT_MAX,FLT_MAX);
simp.c:      if (l->op == CNST+I && r->op == ADD+I && r->kids[1]->op == CNST+I)
simp.c:         return simplify(ADD+I, inttype, simplify(MUL+I, inttype, l, r->kids[0]),
simp.c:            simplify(MUL+I, inttype, l, r->kids[1]));
simp.c:      if (l->op == CNST+I && r->op == SUB+I && r->kids[1]->op == CNST+I)
simp.c:         /* c1*(x - c2) => c1*x - c1*c2 */
simp.c:         return simplify(SUB+I, inttype, simplify(MUL+I, inttype, l, r->kids[0]),
simp.c:            simplify(MUL+I, inttype, l, r->kids[1]));
simp.c:      if (l->op == CNST+I && l->u.v.i > 0 && (n = ispow2(l->u.v.i))) {
simp.c:      if (l->op == CNST+U && (n = ispow2(l->u.v.u)))
simp.c:      ufoldcnst(D,(p = tree(CNST+D, doubletype, 0, 0), p->u.v.d = -l->u.v.d, p));
simp.c:      ufoldcnst(F,(p = tree(CNST+F, floattype, 0, 0), p->u.v.f = -l->u.v.f, p));
simp.c:      if (l->op == CNST+I) {
simp.c:         if (needconst && l->u.v.i == INT_MIN)
simp.c:         if (needconst || l->u.v.i != INT_MIN)
simp.c:            return constnode(-l->u.v.i, inttype);
simp.c:      ufoldcnst(I,constnode(!l->u.v.i, inttype));
simp.c:      if (l->op == CNST+I && r->op == CNST+I
simp.c:      && r->u.v.i >= 0 && r->u.v.i < 8*l->type->size) {
simp.c:         int n = l->u.v.i>>r->u.v.i;
simp.c:         if (l->u.v.i < 0)
simp.c:            n |= ~0<<(8*l->type->size - r->u.v.i);
simp.c:      xfoldcnst(D,d,-,doubletype,sub,-DBL_MAX,DBL_MAX);
simp.c:      xfoldcnst(F,f,-,floattype,sub,-FLT_MAX,FLT_MAX);
simp.c:      xfoldcnst(I,i,-,inttype,sub,INT_MIN,INT_MAX);
simp.c:      foldcnst(U,u,-,unsignedtype);
simp.c:      if (l->op == CNST+P && r->op == CNST+P)
simp.c:         return constnode(l->u.v.p - r->u.v.p, inttype);
simp.c:      if (r->op == CNST+I || r->op == CNST+U)
simp.c:            constnode(r->op == CNST+I ? -r->u.v.i : -(int)r->u.v.u, inttype));
simp.c:      if (isaddrop(l->op) && r->op == ADD+I && r->kids[1]->op == CNST+I)
simp.c:         /* l - (x + c) => l-c - x */
simp.c:            simplify(SUB+P, ty, l, r->kids[1]), r->kids[0]);
simp.c:   ret->maybe_pr = maybepr;       /*CWK*/
simp.c:/* sub - return 1 if min <= x-y <= max, 0 otherwise */
simp.c:   return add(x, -y, min, max, needconst);
simp.c:/* vtoa - return string for the constant v of type ty */
simp.c:   switch (ty->op) {
simp.c:      if (ty->type->op == CHAR)
stmt.c:/* branch - jump to lab */
stmt.c:   for (cp = codelist; cp->kind < Label; )
stmt.c:      cp = cp->prev;
stmt.c:      while (cp->kind == Label && islabel(cp->u.node)
stmt.c:      && cp->u.node->syms[0]->u.l.label != lab) {
stmt.c:         equatelab(cp->u.node->syms[0], old);
stmt.c:         old->ref++;
stmt.c:         if (cp->prev->next = cp->next)
stmt.c:            cp->next->prev = cp->prev;
stmt.c:            codelist = cp->prev;
stmt.c:            cp = cp->prev;
stmt.c:         while (cp->kind < Label);
stmt.c:   if (cp->kind != Jump) {
stmt.c:      codelist->u.node = lab ? jump(lab) : 0;
stmt.c:/* caselabel - add a label to the current switch list */
stmt.c:   if (swp->ncases >= swp->size) {
stmt.c:      int    *vals = swp->values;
stmt.c:      Symbol *labs = swp->labels;
stmt.c:      swp->size *= 2;
stmt.c:      swp->values = (int    *) talloc(swp->size*sizeof (int));
stmt.c:      swp->labels = (Symbol *) talloc(swp->size*sizeof (Symbol));
stmt.c:      for (k = 0; k < swp->ncases; k++) {
stmt.c:         swp->values[k] = vals[k];
stmt.c:         swp->labels[k] = labs[k];
stmt.c:   for (k = swp->ncases; k > 0 && swp->values[k-1] >= val; k--) {
stmt.c:      swp->values[k] = swp->values[k-1];
stmt.c:      swp->labels[k] = swp->labels[k-1];
stmt.c:   if (k < swp->ncases && swp->values[k] == val)
stmt.c:   swp->values[k] = val;
stmt.c:   swp->labels[k] = findlabel(lab);
stmt.c:   ++swp->ncases;
stmt.c:   if (Aflag >= 2 && swp->ncases == 258)
stmt.c:/* cmp - generate code for `if (p op n) goto lab' for integer n */
stmt.c:/* definelab - define a label */
stmt.c:   codelist->u.node = newnode(LABEL+V, 0, 0, findlabel(lab));
stmt.c:   for (cp = codelist; cp->kind <= Label; )
stmt.c:      cp = cp->prev;
stmt.c:   while (cp->kind == Jump && cp->u.node && cp->u.node->kids[0]
stmt.c:   && cp->u.node->kids[0]->op == ADDRG+P
stmt.c:   && cp->u.node->kids[0]->syms[0]->u.l.label == lab) {
stmt.c:      cp->u.node->kids[0]->syms[0]->ref--;
stmt.c:      assert(cp->next);
stmt.c:      cp->prev->next = cp->next;
stmt.c:      cp->next->prev = cp->prev;
stmt.c:      cp = cp->prev;
stmt.c:/* definept - define an execution point n: current token at current pc */
stmt.c:   cp->u.point.src = p ? *p : src;
stmt.c:   cp->u.point.point = npoints;
stmt.c:      apply(events.points, (Generic)&cp->u.point.src, (Generic)&e);
stmt.c:      locus(identifiers, &cp->u.point.src);
stmt.c:/* dostmt - do statement while ( expression ) */
stmt.c:   if (findlabel(lab + 2)->ref)
stmt.c:/* xxxdostmt - xxxdo statement while ( expression ) */
stmt.c:    * e bekannt ist, ob private Pcode-Befehle eingefuegt werden muessen,
stmt.c:    * ist hier eine Erzeugung von Do-Code fuer private Abbruchbedingungen 
stmt.c:    * L+1: e                          continue-Ansprungadresse
stmt.c:    * L+2: if tmp jump to L+3;        break-Ansprungadresse
stmt.c:    * eines privaten do-stmt mit 4 labels ohne temp. Var. wie folgt vereinfacht:
stmt.c:    *      if true, jump to L    (L+1 = continue-Ansprungadresse)
stmt.c:    * L+2: exlgrp; sync; ....    (L+2 = break-Ansprungadresse)
stmt.c:    * (konservative worst-case-Annahme).
stmt.c:   shframedepth--;
stmt.c:   if (findlabel(lab + 2)->ref)
stmt.c:/* equatelab - add new=old to list of deferred equates */
stmt.c:   e->new = new;
stmt.c:   e->old = old;
stmt.c:   e->oldlink = 0;
stmt.c:   e->link = equlist;
stmt.c:   for (e = e->link; e; e = e->link)
stmt.c:      if (e->old == new)
stmt.c:         e->oldlink = equlist;
stmt.c:      else if (e->new == old)
stmt.c:         equlist->oldlink = e;
stmt.c:/* flushequ - flush deferred equates */
stmt.c:   for ( ; equlist; equlist = equlist->link)
stmt.c:/* foldcond - check if initial test in for(e1;e2;e3) S is necessary */
stmt.c:   Opcode op = generic(e2->op);
stmt.c:   if (generic(e1->op) == ASGN && isaddrop(e1->kids[0]->op)
stmt.c:   && generic(e1->kids[1]->op) == CNST) {
stmt.c:      v = e1->kids[0]->u.sym;
stmt.c:      e1 = e1->kids[1];
stmt.c:   && generic(e2->kids[0]->op) == INDIR
stmt.c:   && e2->kids[0]->kids[0]->u.sym == v
stmt.c:   && e2->kids[1]->op == e1->op) {
stmt.c:      e1 = simplify(op, e2->type, e1, e2->kids[1]);
stmt.c:      if (e1->op == CNST+I)
stmt.c:         return e1->u.v.i;
stmt.c:/* forstmt - for ( [expr1] ; [expr2] ; [expr3] ) statement */
stmt.c:   if (findlabel(lab + 2)->ref)
stmt.c:/* xxxforstmt - xxxfor ( [expr1] ; [expr2] ; [expr3] ) statement */
stmt.c:      if (priv) shframedepth--;
stmt.c:      if (priv) shframedepth--;
stmt.c:   if (findlabel(lab + 2)->ref)
stmt.c:/* forkstmt - fork ( [expr1] ; @ = [expr2] ) statement */    /*CWK*/
stmt.c:      codelist->u.node = listnodes(e1, 0, 0);
stmt.c:      if (generic(e2->op) == ASGN && 
stmt.c:          (generic(e2->kids[1]->op)==DIV || generic(e2->kids[1]->op)==MOD) )
stmt.c:      e2 = tree(ASGN, e2->type, e2->kids[0],
stmt.c:             simplify( e2->kids[1]->op, e2->kids[1]->type, e2->kids[1]->kids[0],
stmt.c:                                                           e2->kids[1]->kids[1]) );
stmt.c:   /* definelab(lab);  break/continue aus der fork-Anweisung moeglich 17.9. */
stmt.c:   shframedepth --;
stmt.c:/* syncstmt - barrier statement */                /*CWK*/
stmt.c:   codelist->u.node = listnodes(e1, 0, 0); /* spoolout */
stmt.c:     if (!isint(e->type)) {
stmt.c:        error("illegal type `%t' in start expression\n", e->type);
stmt.c:     /*e = cast(e, promote(e->type));*/
stmt.c:        codelist->u.node = listnodes(e, 0, 0);
stmt.c:   else {   /*default: no expression -> start all available processors*/
stmt.c:     codelist->u.node = listnodes(e, 0, 0);
stmt.c:   shframedepth--;
stmt.c:/* ifstmt - if ( expression ) statement [ else statement ] */
stmt.c:      if (findlabel(lab + 1)->ref)
stmt.c:/* xxxifstmt - xxxif ( expression ) statement [ else statement ] */
stmt.c:   if (priv) nextcase(0);    /*CWK: then-Gruppe aufmachen */
stmt.c:   if (priv) shframedepth--;
stmt.c:      if (priv) nextcase(1); /*CWK: else-Gruppe aufmachen */
stmt.c:      if (priv) shframedepth--;
stmt.c:      if (findlabel(lab + 1)->ref)
stmt.c:   } else {  /*dummy-Else, um die idle Prozessoren zu beschaeftigen: */
stmt.c:      // if (priv) nextcase(1); /*CWK: else-Gruppe aufmachen */
stmt.c:      if (priv && findlabel(lab + 1)->ref)
stmt.c:/* localaddr - returns q if p yields the address of local/parameter q;
stmt.c:   switch (generic(p->op)) {
stmt.c:      return p->u.sym;
stmt.c:      if (p->kids[1])
stmt.c:         return localaddr(p->kids[1]);
stmt.c:      return localaddr(p->kids[0]);
stmt.c:      if (p->kids[1] && (q = localaddr(p->kids[1])))
stmt.c:      return localaddr(p->kids[2]);
stmt.c:      if (p->kids[0] && (q = localaddr(p->kids[0])))
stmt.c:      return localaddr(p->kids[1]);
stmt.c:/* retcode - return p from the current function */
stmt.c:      if (ty = assign(freturn(cfunc->type), p))
stmt.c:            p->type, freturn(cfunc->type));
stmt.c:      if (cfunc->shared) { /*CWK*/
stmt.c:         if (p->op == RIGHT && p->kids[0]->op == CALL+B
stmt.c:         && p->kids[1]->op == INDIR+B) {
stmt.c:            p = p->kids[0];
stmt.c:            p->kids[1] = idnode(retv);
stmt.c:            Symbol t1 = genident(AUTO, p->type, level);
stmt.c:         p = cast(p, promote(p->type));
stmt.c:         if (isptr(p->type)) {
stmt.c:            if (q && (q->computed || q->generated))
stmt.c:                  q->scope == PARAM ? "parameter" : "local");
stmt.c:                  q->scope == PARAM ? "parameter" : "local", q->name);
stmt.c:         if (cfunc->shared)    /*CWK*/
stmt.c:               p = tree(SRET + widen(p->type), p->type, p, 0);
stmt.c:         else  p = tree(RET + widen(p->type), p->type, p, 0);
stmt.c:   p->rframes = rframes;     /*CWK*/
stmt.c:   p->started = isinsideastartbody; /*!(cfunc->sync) && isinsyncmode;     /*CWK*/
stmt.c:   if (isinsyncmode && cfunc && !(cfunc->sync))              /*CWK*/
stmt.c:/* statement - parse statements */
stmt.c:      if (!isFORKmodul) error("barrier is a ForkLight-specific statement");
stmt.c:         if (generic(p->op) == CNST && isint(p->type)) {
stmt.c:               p = cast(p, swp->sym->type);
stmt.c:               needconst--;
stmt.c:               caselabel(swp, p->u.v.i, lab);
stmt.c:         if (swp->deflab)
stmt.c:            swp->deflab = findlabel(swp->lab);
stmt.c:            definelab(swp->deflab->u.l.label);
stmt.c:         error("seq is a FORK-specific statement!\n");
stmt.c:         error("farm is a FORK-specific statement!\n");
stmt.c:      if (cfunc->sync && !isinsyncmode)
stmt.c:         if (freturn(cfunc->type) == voidtype) {
stmt.c:            retcode(0, cfunc->u.f.label, rframes);
stmt.c:            retcode(expr(0), cfunc->u.f.label, rframes);
stmt.c:         if (freturn(cfunc->type) != voidtype
stmt.c:         && (freturn(cfunc->type) != inttype || Aflag >= 1))
stmt.c:         retcode(0, cfunc->u.f.label, rframes);
stmt.c:      if (swp && swp->lab > loop) {
stmt.c:         branch(swp->lab + 1);
stmt.c:            p->u.l.label = genlabel(1);
stmt.c:            p->u.l.equatedto = p;
stmt.c:            p->src = src;
stmt.c:         p->ref++;
stmt.c:         branch(p->u.l.label);
stmt.c:/* stmtlabel - label : */
stmt.c:      p->u.l.label = genlabel(1);
stmt.c:      p->u.l.equatedto = p;
stmt.c:   if (p->defined)
stmt.c:         label, &p->src);
stmt.c:   p->defined = 1;
stmt.c:   p->src = src;
stmt.c:   definelab(p->u.l.label);
stmt.c:/* swcode - generate switch decision code for buckets b[lb..ub] */
stmt.c:   v = swp->values;
stmt.c:   median = ((float)v[b[lb]] + (float)v[b[ub+1]-1] + 1)/2;
stmt.c:         u = k - 1;
stmt.c:      else if (v[b[k+1]-1] < median)
stmt.c:      u = b[k+1] - 1;
stmt.c:      if (median < v[l] && k > lb && v[l] - median > median - v[l-1])
stmt.c:         k--;
stmt.c:      else if (median > v[u] && k < ub && median - v[u] > v[u+1] - median)
stmt.c:   u = b[k+1] - 1;
stmt.c:   lolab = hilab = swp->deflab->u.l.label;
stmt.c:   if (u - l + 1 <= 3) {
stmt.c:         cmp(EQ, swp->sym, swp->values[i], swp->labels[i]->u.l.label);
stmt.c:            cmp(LT, swp->sym, swp->values[l], lolab);
stmt.c:            cmp(GT, swp->sym, swp->values[u], hilab);
stmt.c:      Symbol tab = genident(STATIC, array(voidptype, u - l + 1, 0), GLOBAL);
stmt.c:      cmp(LT, swp->sym, swp->values[l], lolab ? lolab : lab);
stmt.c:      cmp(GT, swp->sym, swp->values[u], hilab ? hilab : lab);
stmt.c:         (*opnode['-'])(SUB, cast(idnode(swp->sym), inttype),
stmt.c:            constnode(swp->values[l], inttype)))), 0), 0, 0);
stmt.c:      codelist->u.swtch.sym = swp->sym;
stmt.c:      codelist->u.swtch.deflab = swp->deflab;
stmt.c:      codelist->u.swtch.table = tab;
stmt.c:      codelist->u.swtch.size = u - l + 1;
stmt.c:      codelist->u.swtch.values = &swp->values[l];
stmt.c:      codelist->u.swtch.labels = &swp->labels[l];
stmt.c:      if (swp->values[u] - swp->values[l] + 1 >= 10000)
stmt.c:      n = swcode(swp, b, lb, k - 1, n - 1);
stmt.c:      n = swcode(swp, b, k + 1, ub, n - 1);
stmt.c:/* swgen - partition case labels into buckets, initiate code generation */
stmt.c:#define den(k,n) ((float)(k-buckets[n]+1)/(float)(v[k]-v[buckets[n]]+1))
stmt.c:   if (swp->ncases == 0)
stmt.c:   buckets = (int *) talloc((swp->ncases + 1)*sizeof *buckets);
stmt.c:   v = swp->values;
stmt.c:   for (k = 0; k < swp->ncases; k++, n++) {
stmt.c:         float d = den(k, n-1);
stmt.c:         if (d < density || k < swp->ncases - 1 && d < den(k+1, n))
stmt.c:         n--;
stmt.c:   buckets[n--] = swp->ncases;
stmt.c:/* swstmt - switch ( expression ) statement */
stmt.c:   if (!isint(e->type)) {
stmt.c:      error("illegal type `%t' in switch expression\n", e->type);
stmt.c:   e = cast(e, promote(e->type));
stmt.c:   if (generic(e->op) == INDIR && isaddrop(e->kids[0]->op)
stmt.c:   && e->kids[0]->u.sym->type == e->type && !isvolatile(e->kids[0]->u.sym->type)) {
stmt.c:      sw.sym = e->kids[0]->u.sym;
stmt.c:      sw.sym = genident(REGISTER, e->type, level);
stmt.c:   if (findlabel(lab + 1)->ref)
stmt.c:   codelist = head->prev;
stmt.c:   head->next->prev = codelist;
stmt.c:   codelist->next = head->next;
stmt.c:/* visit - equate p->new=p->old, equating predecessor first */
stmt.c:   if (p && p->old) {
stmt.c:      visit(p->oldlink);
stmt.c:      p->new->u.l.equatedto = p->old->u.l.equatedto;
stmt.c:      p->old = 0;
stmt.c:/* whilestmt - while ( expression ) statement */
stmt.c:   if (generic(e->op) == CNST || glevel == 2) {
stmt.c:   if (findlabel(lab + 2)->ref)
stmt.c:/* xxxwhilestmt - xxxwhile ( expression ) statement */
stmt.c:   if (generic(e->op) == CNST || glevel == 2) {   /*CWK: CNST = shared!*/
stmt.c:      if (priv) shframedepth--;
stmt.c:      if (priv) shframedepth--;
stmt.c:   if (findlabel(lab + 2)->ref)
string.c:/* append - append x to list, return new list */
string.c:      freenodes = freenodes->link;
string.c:      new->link = list->link;
string.c:      list->link = new;
string.c:      new->link = new;
string.c:   new->x = x;
string.c:/* length - # elements in list */
string.c:      while ((lp = lp->link) != list);
string.c:/* ltoa - convert list to an 0-terminated array in a[0..length(list)] */
string.c:         lp = lp->link;
string.c:         a[i++] = lp->x;
string.c:      lp = list->link;
string.c:      list->link = freenodes;
string.c:/* string - save copy of (null-terminated ) str, return pointer to copy */
string.c:   return stringn(str, s - str);
string.c:/* stringd - convert n to a string, return pointer to saved string */
string.c:      m = -n;
string.c:      *--s = m%10 + '0';
string.c:      *--s = '-';
string.c:   return stringn(s, &str[30] - s);
string.c:/* stringn - save copy of str[0..n-1], return pointer to copy */
string.c:         return nums[str[0]-'0'];
string.c:         return nums[10*(str[0]-'0') + str[1]-'0'];
string.c:   for (h = 0, i = n, end = str; i > 0; i--)
string.c:   h &= TABLESIZE-1;
string.c:   for (p = buckets[h]; p; p = p->link)
string.c:      if (n == p->len)
string.c:         for (s1 = str, s2 = p->str; *s1 == *s2++; )
string.c:               return p->str;
string.c:   p->len = n;
string.c:   for (p->str = next; str < end; )
string.c:   p->link = buckets[h];
string.c:   return p->str;
sym.c:/* constant - install and return constant v of type ty */
sym.c:   unsigned h = v.u&(HASHSIZE-1);
sym.c:   for (p = constants->buckets[h]; p; p = p->link)
sym.c:      if (eqtype(ty, p->sym.type, 1))
sym.c:         switch (ty->op) {
sym.c:         case CHAR:     if (v.uc == p->sym.u.c.v.uc) return &p->sym; break;
sym.c:         case SHORT:    if (v.ss == p->sym.u.c.v.ss) return &p->sym; break;
sym.c:         case INT:      if (v.i  == p->sym.u.c.v.i)  return &p->sym; break;
sym.c:         case UNSIGNED: if (v.u  == p->sym.u.c.v.u)  return &p->sym; break;
sym.c:         case FLOAT:    if (v.f  == p->sym.u.c.v.f)  return &p->sym; break;
sym.c:         case DOUBLE:   if (v.d  == p->sym.u.c.v.d)  return &p->sym; break;
sym.c:         case POINTER:  if (v.p  == p->sym.u.c.v.p)  return &p->sym; break;
sym.c:   BZERO(&p->sym, struct symbol);
sym.c:   p->sym.name = vtoa(ty, v);
sym.c:   p->sym.scope = CONSTANTS;
sym.c:   p->sym.type = ty;
sym.c:   p->sym.sclass = STATIC;
sym.c:   p->sym.u.c.v = v;
sym.c:   p->link = constants->buckets[h];
sym.c:   p->sym.up = constants->list;
sym.c:   constants->list = &p->sym;
sym.c:   constants->buckets[h] = p;
sym.c:   p->refs = 0;   /* (omit) */
sym.c:   defsymbol(&p->sym);
sym.c:   return &p->sym;
sym.c:/* enterscope - enter a scope */
sym.c:/* exitscope - exit a scope */
sym.c:   if (identifiers->level == level) {
sym.c:         for (p = identifiers->list; p && p->scope == level; p = p->up)
sym.c:      identifiers = identifiers->previous;
sym.c:   if (types->level == level) {
sym.c:      types = types->previous;
sym.c:   --level;
sym.c:/* fielduses - convert use lists for fields in type p */
sym.c:   if (p->type && isstruct(p->type) && p->u.s.ftab)
sym.c:      setuses(p->u.s.ftab);
sym.c:/* findlabel - lookup/install label lab in the labels table */
sym.c:   p->generated = 1;
sym.c:   p->u.l.label = lab;
sym.c:   p->u.l.equatedto = p;
sym.c:/* findtype - find type ty in identifiers */
sym.c:         for (p = tp->buckets[i]; p; p = p->link)
sym.c:            if (p->sym.type == ty && p->sym.sclass == TYPEDEF)
sym.c:               return &p->sym;
sym.c:   while (tp = tp->previous);
sym.c:/* foreach - call f(p) for each entry p in table tp */
sym.c:   while (tp && tp->level > lev)
sym.c:      tp = tp->previous;
sym.c:   if (tp && tp->level == lev) {
sym.c:      for (p = tp->list; p && p->scope == lev; p = p->up) {
sym.c:         src = p->src;
sym.c:/* genident - create an identifier with class `sclass', type ty at scope lev */
sym.c:   p->name = stringd(genlabel(1));
sym.c:   p->scope = lev;
sym.c:   p->sclass = sclass;
sym.c:   p->type = ty;
sym.c:   p->generated = 1;
sym.c:/* genlabel - generate n local labels, return first one */
sym.c:   return label - n;
sym.c:/* install - install name in table *tp; permanently allocate entry iff perm!=0 */
sym.c:   unsigned h = (unsigned)name&(HASHSIZE-1);
sym.c:   if ((tpp == &identifiers || tpp == &types) && (*tpp)->level < level)
sym.c:   BZERO(&p->sym, struct symbol);
sym.c:   p->sym.name = name;
sym.c:   p->sym.scope = (*tpp)->level;
sym.c:   p->sym.up = (*tpp)->list;
sym.c:   p->sym.regparameters = p->sym.sharedparameters = 0;   /*init,CWK*/
sym.c:   p->sym.parreg = 0;   /*init, CWK*/
sym.c:   (*tpp)->list = &p->sym;
sym.c:   p->link = (*tpp)->buckets[h];
sym.c:   (*tpp)->buckets[h] = p;
sym.c:   p->refs = 0;   /* (omit) */
sym.c:   return &p->sym;
sym.c:/* intconst - install and return integer constant n */
sym.c:/* locus - append (table, cp) to the evolving loci and symbol tables lists */
sym.c:   tables = append((Generic)tp->list, tables);
sym.c:/* lookup - lookup name in table tp, return pointer to entry */
sym.c:   unsigned h = (unsigned)name&(HASHSIZE-1);
sym.c:      for (p = tp->buckets[h]; p; p = p->link)
sym.c:         if (name == p->sym.name)
sym.c:            return &p->sym;
sym.c:   while (tp = tp->previous);
sym.c:/* newconst - install and return constant n with type tc */
sym.c:/* newtemp - back-end interface to temporary (see below) */
sym.c:   t1->scope = LOCAL;
sym.c:   if (t1->defined == 0) {
sym.c:      t1->defined = 1;
sym.c:/* release - release a temporary for re-use */
sym.c:   if (t1->ref) {
sym.c:      p->sym = t1;
sym.c:      p->link = temps;
sym.c:      t1->ref = 0;
sym.c:/* rmtemps - remove temporaries at scope `level' or with `sclass' */
sym.c:      if (p->sym->scope == level || p->sym->sclass == sclass)
sym.c:         *q = p->link;
sym.c:         q = &p->link;
sym.c:/* setuses - convert p->refs to p->uses for all p at the current level in *tp */
sym.c:         for (p = tp->buckets[i]; p; p = p->link) {
sym.c:            if (p->refs)
sym.c:               p->sym.uses = (Coordinate **)ltoa(p->refs, 0);
sym.c:            p->refs = 0;
sym.c:            symbols = append((Generic)&p->sym, symbols);
sym.c:/* table - create a new table with predecessor tp, scope lev */
sym.c:   new->previous = tp;
sym.c:   new->level = lev;
sym.c:   new->list = tp ? tp->list : 0;   /* (omit) */
sym.c:      new->buckets[i] = 0;
sym.c:/* temporary - create temporary with class `sclass', type ty */
sym.c:   for (p = *q; p; q = &p->link, p = *q)
sym.c:      if (p->sym->sclass == sclass
sym.c:      && p->sym->type->size  == ty->size
sym.c:      && p->sym->type->align >= ty->align) {
sym.c:         *q = p->link;
sym.c:         p->sym->type = ty;
sym.c:         return p->sym;
sym.c:   t1->temporary = 1;
sym.c:/* use - add src to the list of uses for p */
sym.c:      ((struct entry *)p)->refs = append((Generic)cp, ((struct entry *)p)->refs);
tree.c:/* allocate - allocate n bytes in arena **p, adding a new arena if necessary */
tree.c:   while (ap->avail + n > ap->limit)
tree.c:      if (ap->next) {      /* move to next arena */
tree.c:         ap = ap->next;
tree.c:         ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
tree.c:      } else if (ap->next = freearenas) {
tree.c:         freearenas = freearenas->next;
tree.c:         ap = ap->next;
tree.c:         ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
tree.c:         ap->first = (*p)->first;
tree.c:         ap->next = 0;
tree.c:         ap->next = (Arena) malloc(m);
tree.c:         assert(ap->next && (int)ap->next >= 0);
tree.c:         if ((char *)ap->next == ap->limit) /* extend previous arena? */
tree.c:            ap->limit = (char *)ap->next + m;
tree.c:            ap = ap->next;
tree.c:            ap->limit = (char *)ap + m;
tree.c:            ap->avail = (char *)ap + roundup(sizeof *ap, sizeof (double));
tree.c:         ap->first = (*p)->first;
tree.c:         ap->next = 0;
tree.c:   ap->avail += n;
tree.c:   return ap->avail - n;
tree.c:/* deallocate - release all space in arena *p, except the first arena; reset *p */
tree.c:   Arena first = (*p)->first;
tree.c:   (*p)->next = freearenas;
tree.c:   freearenas = first->next;
tree.c:   first->next = 0;
tree.c:/* cvtconst - convert a constant tree into tree for a global variable */
tree.c:   Symbol q = constant(p->type, p->u.v);
tree.c:   if (q->u.c.loc == 0) {
tree.c:      q->u.c.loc = genident(STATIC, p->type, GLOBAL);
tree.c:   if (isarray(p->type)) {
tree.c:      e = tree(ADDRG+P, atop(p->type), 0, 0);
tree.c:      e->u.sym = q->u.c.loc;
tree.c:      e = tree(INDIR+P, p->type, e, 0 );   /*testweise 980709*/
tree.c:      e = idnode(q->u.c.loc);
tree.c:/* hascall - does tree p contain a CALL? */
tree.c:   if (generic(p->op) == CALL
tree.c:   || p->op == DIV+I || p->op == MOD+I || p->op == MUL+I
tree.c:   || p->op == DIV+U || p->op == MOD+U || p->op == MUL+U
tree.c:   || p->op == DIV+I || p->op == MOD+I                 /*CWK*/
tree.c:   || p->op == DIV+U || p->op == MOD+U
tree.c:   return hascall(p->kids[0]) || hascall(p->kids[1]);
tree.c:/* opname - return string for operator op */
tree.c:   if (optype(op) > 0 && optype(op) < sizeof (TYPENAMES) - 1)
tree.c:/* tree - allocate and initialize a tree node */
tree.c:   p->op = op;
tree.c:   p->type = type;
tree.c:   p->kids[0] = left;
tree.c:   p->kids[1] = right;
tree.c:   p->node = 0;
tree.c:   p->u.sym = 0;
tree.c:   p->synchron = isinsyncmode;  /*CWK 950912*/
tree.c:   p->stabilized = 0;  /*980811*/
tree.c:   p->maybe_pr = may_dep_on_pr_var( p );
tree.c:/* retype - return a copy of tree p with type field = ty */
tree.c:   if (p->type == ty)
tree.c:   q = tree(p->op, ty, p->kids[0], p->kids[1]);
tree.c:   q->u = p->u;
tree.c:/* root - tree p will be a root; remove unnecessary temporaries */
tree.c:   switch (generic(p->op)) {
tree.c:      Tree q = p->kids[1];
tree.c:      assert(q && q->op == RIGHT);
tree.c:      if (p->u.sym && q->kids[0] && generic(q->kids[0]->op) == ASGN)
tree.c:         q->kids[0] = root(q->kids[0]->kids[1]);
tree.c:         q->kids[0] = root(q->kids[0]);
tree.c:      if (p->u.sym && q->kids[1] && generic(q->kids[1]->op) == ASGN)
tree.c:         q->kids[1] = root(q->kids[1]->kids[1]);
tree.c:         q->kids[1] = root(q->kids[1]);
tree.c:      if (p->u.sym)
tree.c:         release(p->u.sym);
tree.c:      p->u.sym = 0;
tree.c:      if (q->kids[0] == 0 && q->kids[1] == 0)
tree.c:         p = root(p->kids[0]);
tree.c:      if ((p->kids[1] = root(p->kids[1])) == 0)
tree.c:         p = root(p->kids[0]);
tree.c:      return root(p->kids[0]);
tree.c:      if (p->kids[1] == 0)
tree.c:         return root(p->kids[0]);
tree.c:      if (p->kids[0] && p->kids[0]->op == CALL+B
tree.c:      &&  p->kids[1] && p->kids[1]->op == INDIR+B)
tree.c:         return p->kids[0];
tree.c:      if (p->kids[0] && p->kids[0]->op == RIGHT
tree.c:      &&  p->kids[1] == p->kids[0]->kids[0])
tree.c:         /* de-construct e++ construction */
tree.c:         return p->kids[0]->kids[1];
tree.c:      p = tree(RIGHT, p->type, root(p->kids[0]), root(p->kids[1]));
tree.c:      return p->kids[0] || p->kids[1] ? p : 0;
tree.c:      if (p->type->size == 0)
tree.c:         warning("reference to `%t' elided\n", p->type);
tree.c:      if (isptr(p->kids[0]->type) && isvolatile(p->kids[0]->type->type))
tree.c:         warning("reference to `volatile %t' elided\n", p->type);
tree.c:      return root(p->kids[0]);
tree.c:      if (p->u.sym->temporary)
tree.c:         release(p->u.sym);
tree.c:      if (p->u.sym->temporary)
tree.c:         release(p->u.sym);
tree.c:/* texpr - parse an expression via f(tok), allocating trees in transient area */
tree.c:/* tfree - release space in all transient arenas and default tree area */
tree.c:/* nodeid - lookup id for tree or node p */
tree.c:/* printed - return pointer to ids[id].printed */
tree.c:/* printtree - print tree p on fd */
tree.c:/* printtree1 - recursively print tree p */
tree.c:       &blanks[sizeof blanks - lev]);
tree.c:   fprint(fd, "%s %t", opname(p->op), p->type);
tree.c:   for (i = 0; i < sizeof p->kids/sizeof p->kids[0]; i++)
tree.c:      if (p->kids[i])
tree.c:         fprint(fd, " #%d", nodeid(p->kids[i]));
tree.c:   if (generic(p->op) == FIELD && p->u.field)
tree.c:      fprint(fd, " %s %d..%d", p->u.field->name, p->u.field->from,
tree.c:         p->u.field->to);
tree.c:   else if (generic(p->op) == CNST)
tree.c:      fprint(fd, " %s", vtoa(p->type, p->u.v));
tree.c:   else if (p->u.sym)
tree.c:      fprint(fd, " %s", p->u.sym->name);
tree.c:   if (p->node)
tree.c:      fprint(fd, " node=0x%x", p->node);
tree.c:   for (i = 0; i < sizeof p->kids/sizeof p->kids[0]; i++)
tree.c:      printtree1(p->kids[i], fd, lev + 1);
tree.c:/* may_dep_on_pr_var - recursively test for occurrence of priv. var */    /*CWK*/
tree.c:   /*if (e->maybe_pr) return 1;*/
tree.c:   if (e->stabilized) return 0;   // 980811
tree.c:   switch (generic(e->op)) {
tree.c:        if (e->kids[0]->kids[0]) return 1;   /* pointer */
tree.c:        /*else  sharity immer durchreichen: */ return may_dep_on_pr_var(e->kids[0]);
tree.c:        MaxGrad = sizeof e->kids/sizeof e->kids[0];
tree.c:        if (!(e->kids[0]))  return 1;  /*worst case*/
tree.c:          if (e->kids[i])
tree.c:            ret = ret || may_dep_on_pr_var(e->kids[i]);
tree.c:/* may_dep_on_async_fnp - recursively test for occurrence of async fn pointer CWK*/
tree.c:   switch (generic(e->op)) {
tree.c:        if (e->u.sym && isfunc(e->u.sym->type))
tree.c:          return (e->u.sym->sync)? 0 : 1;
tree.c:        if (!(e->kids[0]))  return 0;  /*worst case*/
tree.c:        MaxGrad = sizeof e->kids/sizeof e->kids[0];
tree.c:          if (e->kids[i])
tree.c:            ret = ret || may_dep_on_async_fnp(e->kids[i]);
tree.c:/* search_sym_of_fnp - recursively search for declared sym of fn pointer call CWK*/
tree.c:   switch (generic(e->op)) {
tree.c:        if (e->u.sym && isfunc(e->u.sym->type))
tree.c:          return (e->u.sym);
tree.c:        if (!(e->kids[0]))  return 0;  /*worst case*/
tree.c:        MaxGrad = sizeof e->kids/sizeof e->kids[0];
tree.c:          if (e->kids[i]) {
tree.c:            ret = search_sym_of_fnp(e->kids[i]);
tree.c:/* occurin - recursively test for occurrence of operator o in tree e */ /*CWK*/
tree.c:   if (!(e->kids[0])) return (generic(e->op) == o);
tree.c:   return occurin( e->kids[0], o) && occurin( e->kids[1], o);
types.c:/* typeInit - initialize basic types */
types.c:   v = p->type = tynode(op, 0, metrics+1?(Generic)p:0); p->addressed = (metrics); \
types.c:   assert(v->align == 0 || v->size%v->align == 0); }
types.c:#define xx(v,name,adr) v = install(string(name), &types, 1); v->addressed = (adr);
types.c:   assert(voidptype->align > 0 && voidptype->size%voidptype->align == 0);
types.c:   assert(unsignedtype->size >= voidptype->size);
types.c:/* array - construct the type `array 0..n-1 of ty' with alignment a or ty's */
types.c:      a = ty->align;
types.c:   if (level > GLOBAL && isarray(ty) && ty->size == 0)
types.c:   if (ty->size == 0) {
types.c:   } else if (n > INT_MAX/ty->size) {
types.c:   return tynode(ARRAY, ty, n*ty->size, a, (Generic)0);
types.c:/* atop - convert ty from `array of ty' to `pointer to ty' */
types.c:      return ptr(ty->type);
types.c:/* check - check ty for ambiguous inherited fields, return augmented field set */
types.c:   for (p = ty->u.sym->u.s.flist; p; p = p->link)
types.c:      if (p->name && isfield(p->name, inherited))
types.c:         error("ambiguous field `%s' of `%t' from `%t'\n", p->name, top, ty);
types.c:      else if (p->name && !isfield(p->name, top->u.sym->u.s.flist)) {
types.c:         new->offset = off + p->offset;
types.c:         new->link = inherited;
types.c:   for (p = ty->u.sym->u.s.flist; p; p = p->link)
types.c:      if (p->name == 0)
types.c:         inherited = check(p->type, top, inherited,
types.c:            off + p->offset);
types.c:/* checkfields - check for ambiguous inherited fields in struct/union ty */
types.c:   for (p = ty->u.sym->u.s.flist; p; p = p->link)
types.c:      if (p->name == 0)
types.c:         inherited = check(p->type, ty, inherited, p->offset);
types.c:/* composite - return the composite type of ty1 & ty2, or 0 if ty1 & ty2 are incompatible */
types.c:   if (ty1->op != ty2->op)
types.c:   switch (ty1->op) {
types.c:      return qual(CONST, qual(VOLATILE, composite(ty1->type, ty2->type)));
types.c:      return qual(ty1->op, composite(ty1->type, ty2->type));
types.c:      return ptr(composite(ty1->type, ty2->type));
types.c:      if (ty = composite(ty1->type, ty2->type)) {
types.c:         if (ty1->size && ty1->type->size && ty2->size == 0)
types.c:            return array(ty, ty1->size/ty1->type->size, ty1->align);
types.c:         if (ty2->size && ty2->type->size && ty1->size == 0)
types.c:            return array(ty, ty2->size/ty2->type->size, ty2->align);
types.c:      if (ty = composite(ty1->type, ty2->type)) {
types.c:         if (ty1->u.proto && ty2->u.proto == 0)
types.c:            return func(ty, ty1->u.proto);
types.c:         if (ty2->u.proto && ty1->u.proto == 0)
types.c:            return func(ty, ty2->u.proto);
types.c:         for (p1 = ty1->u.proto, p2 = ty2->u.proto; *p1 && *p2; p1++, p2++) {
types.c:/* deftype - define name to be equivalent to type ty */
types.c:   if (p && p->scope == level)
types.c:   p->type = ty;
types.c:   p->sclass = TYPEDEF;
types.c:   p->src = *pos;
types.c:/* deref - dereference ty, type *ty */
types.c:      ty = ty->type;
types.c:   return isenum(ty) ? unqual(ty)->type : ty;
types.c:/* eqtype - is ty1==ty2?  handles arrays & functions; return ret if ty1==ty2, but one is incomplete */
types.c:   if (ty1->op != ty2->op)
types.c:   switch (ty1->op) {
types.c:      return eqtype(ty1->type, ty2->type, ret);
types.c:      if (eqtype(ty1->type, ty2->type, ret)) {
types.c:         if (ty1->size == ty2->size)
types.c:         if (ty1->size == 0 && ty2->size >  0
types.c:         ||  ty1->size >  0 && ty2->size == 0)
types.c:      if (eqtype(ty1->type, ty2->type, ret)) {
types.c:         Type *p1 = ty1->u.proto, *p2 = ty2->u.proto;
types.c:               || ty == voidtype && p1 != ty1->u.proto)
types.c:/* extends - if ty extends fty, return a pointer to field structure */
types.c:   for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link)
types.c:      if (p->name == 0 && unqual(p->type) == unqual(fty))
types.c:      else if (p->name == 0 && (q = extends(p->type, fty))) {
types.c:         f.offset = p->offset + q->offset;
types.c:/* fieldlist - construct a flat list of fields in type ty */
types.c:   for (p = ty->u.sym->u.s.flist; p; p = p->link)
types.c:      if (p->name == 0)
types.c:         inherited = check(p->type, ty, inherited, p->offset);
types.c:      return ty->u.sym->u.s.flist;
types.c:      t = p->link;
types.c:      p->link = q;
types.c:   for (r = &inherited, p = ty->u.sym->u.s.flist; p && q; )
types.c:      if (p->name == 0)
types.c:         p = p->link;
types.c:      else if (p->offset <= q->offset) {
types.c:         r = &(*r)->link;
types.c:         p = p->link;
types.c:         r = &q->link;
types.c:         q = q->link;
types.c:   for ( ; p; p = p->link)
types.c:      if (p->name) {
types.c:         r = &(*r)->link;
types.c:/* fieldref - find field name of type ty, return entry */
types.c:   if (p = isfield(name, unqual(ty)->u.sym->u.s.flist)) {
types.c:         assert(unqual(ty)->u.sym->u.s.ftab);
types.c:         q = lookup(name, unqual(ty)->u.sym->u.s.ftab);
types.c:   for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link) {
types.c:      if (p->name == 0 && (q = fieldref(name, p->type))) {
types.c:         f.offset = p->offset + q->offset;
types.c:/* freturn - for `function returning ty', return ty */
types.c:      return ty->type;
types.c:/* func - construct the type `function (proto) returning ty' */
types.c:/* funcl - construct the type `function (list) returning ty' */
types.c:/* hasproto - true iff ty has no function types or they all have prototypes */
types.c:   switch (ty->op) {
types.c:      return hasproto(ty->type);
types.c:      return hasproto(ty->type) && ty->u.proto;
types.c:/* isfield - if name is a field in flist, return pointer to the field structure */
types.c:   for ( ; flist; flist = flist->link)
types.c:      if (flist->name == name)
types.c:/* newfield - install a new field in ty with type fty */
types.c:   Field p, *q = &ty->u.sym->u.s.flist;
types.c:   for (p = *q; p; q = &p->link, p = *q)
types.c:      if (p->name == name)
types.c:   p->name = name;
types.c:   p->type = fty;
types.c:      if (ty->u.sym->u.s.ftab == 0)
types.c:         ty->u.sym->u.s.ftab = table(0, level);
types.c:      install(name, &ty->u.sym->u.s.ftab, 1)->src = src;
types.c:/* newstruct - install a new structure/union/enum depending on op */
types.c:   if ((p = lookup(tag, types)) && (p->scope == level
types.c:   || p->scope == PARAM && level == PARAM+1)) {
types.c:      if (p->type->op == op && !p->defined)
types.c:         return p->type;
types.c:   p->type = tynode(op, 0, 0, 0, p);
types.c:   if (p->scope > maxlevel)
types.c:      maxlevel = p->scope;
types.c:   p->src = src;
types.c:   return p->type;
types.c:/* outtype - output type ty */
types.c:   switch (ty->op) {
types.c:      print("%k %k %t", CONST, VOLATILE, ty->type);
types.c:      print("%k %t", ty->op, ty->type);
types.c:      assert(ty->u.sym);
types.c:      if (ty->size == 0)
types.c:      assert(ty->u.sym->name);
types.c:      if (*ty->u.sym->name >= '1' && *ty->u.sym->name <= '9') {
types.c:            print("%k defined at %w", ty->op, &ty->u.sym->src);
types.c:            print(p->name);
types.c:         print("%k %s", ty->op, ty->u.sym->name);
types.c:         if (ty->size == 0)
types.c:            print(" defined at %w", &ty->u.sym->src);
types.c:      print(ty->u.sym->name);
types.c:      print("pointer to %t", ty->type);
types.c:      print("%t function", ty->type);
types.c:      if (ty->u.proto) {
types.c:         Type *p = ty->u.proto;
types.c:      if (ty->size > 0 && ty->type && ty->type->size > 0) {
types.c:         print("array %d", ty->size/ty->type->size);
types.c:         while (ty->type && isarray(ty->type) && ty->type->type->size > 0) {
types.c:            ty = ty->type;
types.c:            print(",%d", ty->size/ty->type->size);
types.c:      if (ty->type)
types.c:         print(" of %t", ty->type);
types.c:/* printdecl - output a C declaration for symbol p of type ty */
types.c:   switch (p->sclass) {
types.c:      print( "%s%s %s;\n", (isfunc(ty))? ((p->sync)?"sync ":"async "):"",
types.c:           (p->shared)?"sh":"  ",typestring(ty, p->name)); /*CWK*/
types.c:      print( "%k %s%s %s;\n", p->sclass,
types.c:           (isfunc(ty))? ((p->sync)?"sync ":"async "):"",
types.c:           (p->shared)?"sh":"  ", typestring(ty, p->name)); /*CWK*/
types.c:/* printproto - output a prototype declaration for function p */
types.c:   if (p->type->u.proto)
types.c:      printdecl(p, p->type);
types.c:            list = append(callee[i]->type, list);
types.c:      printdecl(p, funcl(freturn(p->type), list));
types.c:/* printtype - print details of type ty on fd */
types.c:   switch (ty->op) {
types.c:      fprint(fd, "%k %s size=%d {\n", ty->op, ty->u.sym->name, ty->size);
types.c:      for (p = ty->u.sym->u.s.flist; p; p = p->link) {
types.c:         fprint(fd, "field %s: offset=%d", p->name, p->offset);
types.c:         if (p->to)
types.c:            fprint(fd, " bits=%d..%d", p->from, p->to);
types.c:         fprint(fd, " type=%t", p->type);
types.c:      fprint(fd, "enum %s {", ty->u.sym->name);
types.c:      for (i = 0; p = ty->u.sym->u.idlist[i]; i++) {
types.c:         fprint(fd, "%s=%d", p->name, p->u.value);
types.c:/* ptr - construct the type `pointer to ty' */
types.c:/* qual - construct the type `op ty' where op is CONST or VOLATILE */
types.c:      ty = tynode(ARRAY, qual(op, ty->type), ty->size,
types.c:         ty->align, 0);
types.c:         op += ty->op;
types.c:         ty = ty->type;
types.c:         for (tn = typetable[i]; tn; tn = tn->link)
types.c:            if (tn->type.op == op && tn->type.type == ty) {
types.c:               tn->type.size = ty->size;
types.c:               tn->type.align = ty->align;
types.c:               return &tn->type;
types.c:      return tynode(op, ty, ty->size, ty->align, 0);
types.c:/* rmtypes - remove type nodes at the current scope level */
types.c:            if (tn->type.op == FUNCTION)
types.c:               tq = &tn->link;
types.c:            else if (tn->type.u.sym && tn->type.u.sym->scope == level)
types.c:               *tq = tn->link;
types.c:               if (tn->type.u.sym && tn->type.u.sym->scope > maxlevel)
types.c:                  maxlevel = tn->type.u.sym->scope;
types.c:               tq = &tn->link;
types.c:/* ttob - map arbitrary type ty to integer basic type */
types.c:   switch (ty->op) {
types.c:      return ttob(ty->type);
types.c:      return ty->op;
types.c:/* tynode - allocate and initialize a type node */
types.c:   int i = (opindex(op)^((unsigned)type>>2))&(sizeof typetable/sizeof typetable[0]-1);
types.c:      for (tn = typetable[i]; tn; tn = tn->link)
types.c:         if (tn->type.op   == op   && tn->type.type  == type
types.c:         &&  tn->type.size == size && tn->type.align == align
types.c:         &&  tn->type.u.ptr == ptr)
types.c:            return &tn->type;
types.c:   tn->type.op = op;
types.c:   tn->type.type = type;
types.c:   tn->type.size = size;
types.c:   tn->type.align = align;
types.c:   tn->type.u.ptr = ptr;
types.c:      tn->type.sharedparams = (*((Type *)ptr))->sharedparams;     /*CWK*/
types.c:      tn->type.regparams = (*((Type *)ptr))->regparams;        /*CWK*/
types.c:      tn->type.sharedparams = 0;     /*CWK*/
types.c:      tn->type.regparams = 0;        /*CWK*/
types.c:   BZERO((&tn->type.x), Xtype);
types.c:   tn->link = typetable[i];
types.c:   return &tn->type;
types.c:/* typestring - return ty as C declaration for str, which may be "" */
types.c:   for ( ; ty; ty = ty->type) {
types.c:      switch (ty->op) {
types.c:         if (isptr(ty->type))
types.c:            return stringf("%k %k %s", CONST, VOLATILE, typestring(ty->type, str));
types.c:         if (isptr(ty->type))
types.c:            str = stringf("%k %s", ty->op, str);
types.c:            return stringf("%k %s", ty->op, typestring(ty->type, str));
types.c:         assert(ty->u.sym);
types.c:            return *str ? stringf("%s %s", p->name, str) : p->name;
types.c:         if (*ty->u.sym->name >= '1' && *ty->u.sym->name <= '9')
types.c:            warning("unnamed %k in prototype\n", ty->op);
types.c:            return stringf("%k %s %s", ty->op, ty->u.sym->name, str);
types.c:            return stringf("%k %s", ty->op, ty->u.sym->name);
types.c:         return *str ? stringf("%s %s", ty->u.sym->name, str) : ty->u.sym->name;
types.c:         if (unqual(ty->type)->op != CHAR && (p = findtype(ty)))
types.c:            return *str ? stringf("%s %s", p->name, str) : p->name;
types.c:         str = stringf(isarray(ty->type) || isfunc(ty->type) ? "(*%s)" : "*%s", str);
types.c:            return *str ? stringf("%s %s", p->name, str) : p->name;
types.c:         if (ty->u.proto == 0)
types.c:            Type *proto = ty->u.proto;
types.c:            long sharedpar = (*proto)->sharedparams; /*CWK*/
types.c:            long regpar = (*proto)->regparams; /*CWK*/
types.c:                          (isfunc(*proto))? ((p->sync)?"sync ":"async ") : "",
types.c:                        (isfunc(*proto))? ((p->sync)?"sync ":"async ") : "",
types.c:            return *str ? stringf("%s %s", p->name, str) : p->name;
types.c:         if (ty->type && ty->type->size > 0)
types.c:           if (ty->size)  /*Holzhammer 980721*/
types.c:              str = stringf("%s[%d]", str, ty->size/ty->type->size);
types.c:/* variadic - is function type ty variadic? */
types.c:   if (isfunc(ty) && ty->u.proto) {
types.c:      for (i = 0; ty->u.proto[i]; i++)
types.c:      return i > 1 && ty->u.proto[i-1] == voidtype;
