Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>
#include <mach.h>
#define Extern extern
#include "acid.h"

static List **tail;

List*
construct(Node *l)
{
        List *lh, **save;

        save = tail;
        lh = 0;
        tail = &lh;
        build(l);
        tail = save;

        return lh;
}

int
listlen(List *l)
{
        int len;

        len = 0;
        while(l) {
                len++;
                l = l->next;
        }
        return len;
}

void
build(Node *n)
{
        List *l;
        Node res;

        if(n == 0)
                return;

        switch(n->op) {
        case OLIST:
                build(n->left);
                build(n->right);
                return;
        default:
                expr(n, &res);
                l = al(res.type);
                l->Store = res.Store;
                *tail = l;
                tail = &l->next;        
        }
}

List*
addlist(List *l, List *r)
{
        List *f;

        if(l == 0)
                return r;

        for(f = l; f->next; f = f->next)
                ;
        f->next = r;

        return l;
}

void
append(Node *r, Node *list, Node *val)
{
        List *l, *f;

        l = al(val->type);
        l->Store = val->Store;
        l->next = 0;

        r->op = OCONST;
        r->type = TLIST;

        if(list->l == 0) {
                list->l = l;
                r->l = l;
                return;
        }
        for(f = list->l; f->next; f = f->next)
                ;
        f->next = l;
        r->l = list->l;
}

int
listcmp(List *l, List *r)
{
        if(l == r)
                return 1;

        while(l) {
                if(r == 0)
                        return 0;
                if(l->type != r->type)
                        return 0;
                switch(l->type) {
                case TINT:
                        if(l->ival != r->ival)
                                return 0;
                        break;
                case TFLOAT:
                        if(l->fval != r->fval)
                                return 0;
                        break;
                case TSTRING:
                        if(scmp(l->string, r->string) == 0)
                                return 0;
                        break;
                case TLIST:
                        if(listcmp(l->l, r->l) == 0)
                                return 0;
                        break;
                }
                l = l->next;
                r = r->next;
        }
        if(l != r)
                return 0;
        return 1;
}

void
nthelem(List *l, int n, Node *res)
{
        if(n < 0)
                error("negative index in []");

        while(l && n--)
                l = l->next;

        res->op = OCONST;
        if(l == 0) {
                res->type = TLIST;
                res->l = 0;
                return;
        }
        res->type = l->type;
        res->Store = l->Store;
}

void
delete(List *l, int n, Node *res)
{
        List **tl;

        if(n < 0)
                error("negative index in delete");

        res->op = OCONST;
        res->type = TLIST;
        res->l = l;

        for(tl = &res->l; l && n--; l = l->next)
                tl = &l->next;

        if(l == 0)
                error("element beyond end of list");
        *tl = l->next;
}

List*
listvar(char *s, vlong v)
{
        List *l, *tl;

        tl = al(TLIST);

        l = al(TSTRING);
        tl->l = l;
        l->fmt = 's';
        l->string = strnode(s);
        l->next = al(TINT);
        l = l->next;
        l->fmt = 'X';
        l->ival = v;

        return tl;
}

static List*
listlocals(Map *map, Symbol *fn, uvlong fp)
{
        int i;
        uvlong val;
        Symbol s;
        List **tail, *l2;

        l2 = 0;
        tail = &l2;
        s = *fn;

        for(i = 0; localsym(&s, i); i++) {
                if(s.class != CAUTO)
                        continue;
                if(s.name[0] == '.')
                        continue;

                if(geta(map, fp-s.value, &val) > 0) {
                        *tail = listvar(s.name, val);
                        tail = &(*tail)->next;
                }
        }
        return l2;
}

static List*
listparams(Map *map, Symbol *fn, uvlong fp)
{
        int i;
        Symbol s;
        uvlong v;
        List **tail, *l2;

        l2 = 0;
        tail = &l2;
        fp += mach->szaddr;                     /* skip saved pc */
        s = *fn;
        for(i = 0; localsym(&s, i); i++) {
                if (s.class != CPARAM)
                        continue;

                if(geta(map, fp+s.value, &v) > 0) {
                        *tail = listvar(s.name, v);
                        tail = &(*tail)->next;
                }
        }
        return l2;
}

void
trlist(Map *map, uvlong pc, uvlong sp, Symbol *sym)
{
        List *q, *l;

        static List **tail;

        if (tracelist == 0) {           /* first time */
                tracelist = al(TLIST);
                tail = &tracelist;
        }

        q = al(TLIST);
        *tail = q;
        tail = &q->next;

        l = al(TINT);                   /* Function address */
        q->l = l;
        l->ival = sym->value;
        l->fmt = 'X';

        l->next = al(TINT);             /* called from address */
        l = l->next;
        l->ival = pc;
        l->fmt = 'Y';

        l->next = al(TLIST);            /* make list of params */
        l = l->next;
        l->l = listparams(map, sym, sp);

        l->next = al(TLIST);            /* make list of locals */
        l = l->next;
        l->l = listlocals(map, sym, sp);
}