Node *
mkfunc(Srcloc loc, Node **args, size_t nargs, Type *ret, Node *body)
{
Node *n;
Node *f;
size_t i;
Stab *st;
f = mknode(loc, Nfunc);
f->func.args = args;
f->func.nargs = nargs;
f->func.body = body;
f->func.scope = mkstab(1);
f->func.type = mktyfunc(loc, args, nargs, ret);
f->func.env = mkenv();
bindtype(f->func.env, f->func.type);
st = body->block.scope;
for (i = 0; i < nargs; i++)
putdcl(st, args[i]);
n = mknode(loc, Nlit);
n->lit.littype = Lfunc;
n->lit.fnval = f;
return n;
}
static Node *
decl()
{
Node *n, *init;
char *name;
CTy *type, *basety;
SrcPos *pos;
Sym *sym;
Vec *syms;
int sclass;
pos = &tok->pos;
syms = vec();
basety = declspecs(&sclass);
while(tok->k != ';' && tok->k != TOKEOF) {
type = declarator(basety, &name, &init);
switch(sclass){
case SCNONE:
if(isglobal()) {
sclass = SCGLOBAL;
} else {
sclass = SCAUTO;
}
break;
case SCTYPEDEF:
if(init)
errorposf(pos, "typedef cannot have an initializer");
break;
}
if(!name)
errorposf(pos, "decl needs to specify a name");
sym = definesym(pos, sclass, name, type, init);
vecappend(syms, sym);
if(isglobal() && tok->k == '{') {
if(init)
errorposf(pos, "function declaration has an initializer");
if(type->t != CFUNC)
errorposf(pos, "expected a function");
curfunc = mknode(NFUNC, pos);
curfunc->type = type;
curfunc->Func.name = name;
curfunc->Func.params = vec();
curfunc->Func.stkslots = vec();
fbody();
definesym(pos, sclass, name, type, curfunc);
curfunc = 0;
goto done;
}
if(tok->k == ',')
next();
else
break;
}
expect(';');
done:
n = mknode(NDECL, pos);
n->Decl.syms = syms;
return n;
}
t_btree *P_ops(char *str, int i)
{
t_btree *tree;
t_btree *tree1;
op;
if (str[i + 1] >= '0' && str[i + 1] <= '9')
{
tree = mkleaf(str, i + 1);
read;
return (tree);
}
else if (str[i + 1] == '(')
{
read;
tree = E_ops(str, i);
expect(')');
return (tree);
}
else if (str[i + 1] == '-')
{
read;
tree = P_ops(str, i);
return (mknode(unary('-'), tree));
}
else
write(2, "Parse error\n", 12);
return (tree);
}
struct kpnode* mktree(struct lnode *list)
{
struct kpnode *root = 0;
struct tlist *tlp = mktlist(0);
struct tlist *tlroot = tlp;
/* make leaves */
for (; list != 0; list = list->next) {
tlp->tree = mknode(list->ch);
tlp->freq = list->freq;
if (list->next != 0) {
tlp->next = mktlist(0);
tlp = tlp->next;
}
}
tlroot = sorttlist(tlroot);
disptlist(tlroot);
/* connect leaves to form whole tree */
tlroot = unite(tlroot);
disptlist(tlroot);
root = tlroot->tree;
return root;
}
/* insert into red-black tree */
void bt_dict_insert(bt_dict *t, const char *k, bt_element *v)
{
bt_dict *p, *g, *gg, *x;
int n;
if (t->key == NULL) { /* initially empty tree */
xfernode(t, k, v);
return;
}
x = p = g = t;
while (x != NULL) {
gg = g;
g = p;
p = x;
n = strcmp(k, x->key);
if (n == 0) return; /* no dupes */
x = n < 0 ? x->left : x->right;
if (x && x->left && x->right && x->left->red && x->right->red)
x = split(t, x, p, g, gg, k);
}
x = mknode(k, v);
if (less(k, p->key)) p->left = x;
else p->right = x;
split(t, x, p, g, gg, k);
}
Node *
mkimplstmt(Srcloc loc, Node *name, Type *t, Type **aux, size_t naux, Node **decls, size_t ndecls)
{
Node *n;
size_t i;
n = mknode(loc, Nimpl);
n->impl.traitname = name;
n->impl.type = t;
n->impl.aux = aux;
n->impl.naux = naux;
n->impl.decls = decls;
n->impl.ndecls = ndecls;
lappend(&impltab, &nimpltab, n);
if (hasparams(t)) {
n->impl.env = mkenv();
bindtype(n->impl.env, t);
}
for (i = 0; i < naux; i++)
if (hasparams(aux[i]))
bindtype(n->impl.env, aux[i]);
for (i = 0; i < ndecls; i++) {
if (name->name.ns)
setns(decls[i]->decl.name, name->name.ns);
if (decls[i]->decl.env)
decls[i]->decl.env->super = n->impl.env;
}
return n;
}
int main()
{
Node *tmp = mknode(17);
fprintf(stdout, "Before calling rmnode(tmp) ... \n");
fprintf(stdout, "---------------------------------------------\n");
fprintf(stdout, "tmp has an address of: %p\n", &tmp);
fprintf(stdout, "tmp points to: %p\n", tmp);
tmp = rmnode(tmp);
fprintf(stdout, "\nAfter calling rmnode(tmp) ... \n");
fprintf(stdout, "---------------------------------------------\n");
fprintf(stdout, "tmp has an address of: %p\n", &tmp);
fprintf(stdout, "tmp points to: %p\n", tmp);
if (tmp == NULL)
{
fprintf(stdout, "tmp successfully deleted.\n");
}
else
{
fprintf(stderr, "error deleting tmp.\n");
exit(1);
}
return(0);
}
static Node *
mkunop(SrcPos *p, int op, Node *o)
{
Node *n;
n = mknode(NUNOP, p);
n->Unop.op = op;
switch(op) {
case '&':
if(!islval(o))
errorposf(&o->pos, "& expects an lvalue");
n->type = mkptr(o->type);
break;
case '*':
if(!isptr(o->type))
errorposf(&o->pos, "cannot deref non pointer");
n->type = o->type->Ptr.subty;
break;
default:
o = ipromote(o);
n->type = o->type;
break;
}
n->Unop.operand = o;
return n;
}
struct kpnode* insnode(char data, struct kpnode* childl, struct kpnode* childr)
{
struct kpnode* node = mknode(data);
node->lnext = childl;
node->rnext = childr;
return node;
}
tree *
mkid (char *id)
{
tree *t = mknode (t_id, 0, NULL, NULL);
t->value.idval = id;
t->id = counter++;
return t;
}
tree *
mknum (int num)
{
tree *t = mknode (t_num, 0, NULL, NULL);
t->value.numval = num;
t->id = counter++;
return t;
}
static Node *
mkblock(SrcPos *p, Vec *v)
{
Node *n;
n = mknode(NBLOCK, p);
n->Block.stmts = v;
return n;
}
Node *
mkvoid(Srcloc loc)
{
Node *n;
n = mknode(loc, Nlit);
n->lit.littype = Lvoid;
return n;
}
Node *
mkblock(Srcloc loc, Stab *scope)
{
Node *n;
n = mknode(loc, Nblock);
n->block.scope = scope;
return n;
}
/*
* Create a new key node, add it to the *end* of this list
*/
static int add_key(SYM sym, char *key, void *data)
{
register struct sym *sn;
if (sym->sym == NULL) {
sym->sym = mknode(NULL, key, data);
if (sym->sym == NULL) {
return (-1);
}
} else {
for (sn = sym->sym; sn != NULL && sn->next != NULL;
sn = sn->next) ;
sn->next = mknode(NULL, key, data);
assert(sn->next != NULL);
if (sn->next == NULL)
return (-1);
}
return (0);
}
Node *
mkmatch(Srcloc loc, Node *pat, Node *body)
{
Node *n;
n = mknode(loc, Nmatch);
n->match.pat = pat;
n->match.block = body;
return n;
}
Node *
mkname(Srcloc loc, char *name)
{
Node *n;
n = mknode(loc, Nname);
n->name.name = strdup(name);
return n;
}
node * mknode_mass(int n, real m)
{
node *root = mknode(n); // note that sequential labels are always set.
root->set_root(root);
root->set_mass(m);
for_all_daughters(node, root, b) b->set_mass(m/n);
return root;
}
Node *
mkfloat(Srcloc loc, double val)
{
Node *n;
n = mknode(loc, Nlit);
n->lit.littype = Lflt;
n->lit.fltval = val;
return n;
}
Node *
mkint(Srcloc loc, uvlong val)
{
Node *n;
n = mknode(loc, Nlit);
n->lit.littype = Lint;
n->lit.intval = val;
return n;
}
Node *
mkuse(Srcloc loc, char *use, int islocal)
{
Node *n;
n = mknode(loc, Nuse);
n->use.name = strdup(use);
n->use.islocal = islocal;
return n;
}
Node *
mkchar(Srcloc loc, uint32_t val)
{
Node *n;
n = mknode(loc, Nlit);
n->lit.littype = Lchr;
n->lit.chrval = val;
return n;
}
Node *
mkmatchstmt(Srcloc loc, Node *val, Node **matches, size_t nmatches)
{
Node *n;
n = mknode(loc, Nmatchstmt);
n->matchstmt.val = val;
n->matchstmt.matches = matches;
n->matchstmt.nmatches = nmatches;
return n;
}
Node *
mkbool(Srcloc loc, int val)
{
Node *n;
n = mknode(loc, Nlit);
n->lit.littype = Lbool;
n->lit.boolval = val;
return n;
}
Node *
mkexprl(Srcloc loc, Op op, Node **args, size_t nargs)
{
Node *n;
n = mknode(loc, Nexpr);
n->expr.op = op;
n->expr.args = args;
n->expr.nargs = nargs;
return n;
}
Node *
mkiterstmt(Srcloc loc, Node *elt, Node *seq, Node *body)
{
Node *n;
n = mknode(loc, Niterstmt);
n->iterstmt.elt = elt;
n->iterstmt.seq = seq;
n->iterstmt.body = body;
return n;
}
Node *
mkifstmt(Srcloc loc, Node *cond, Node *iftrue, Node *iffalse)
{
Node *n;
n = mknode(loc, Nifstmt);
n->ifstmt.cond = cond;
n->ifstmt.iftrue = iftrue;
n->ifstmt.iffalse = iffalse;
return n;
}
Node *
mklbl(Srcloc loc, char *lbl)
{
Node *n;
assert(lbl != NULL);
n = mknode(loc, Nlit);
n->lit.littype = Llbl;
n->lit.lblname = NULL;
n->lit.lblval = strdup(lbl);
return mkexpr(loc, Olit, n, NULL);
}
static Node *
mkcast(SrcPos *p, Node *o, CTy *to)
{
Node *n;
if(sametype(o->type, to))
return o;
n = mknode(NCAST, p);
n->type = to;
n->Cast.operand = o;
return n;
}
Node *
mknsname(Srcloc loc, char *ns, char *name)
{
Node *n;
n = mknode(loc, Nname);
if (ns)
n->name.ns = strdup(ns);
n->name.name = strdup(name);
return n;
}
