Return to util.c CVS log

Up to [Research Unix] / researchv10no / cmd / ideal

Annotation of researchv10no/cmd/ideal/util.c, revision 1.1

1.1     ! root        1: #include "ideal.h"
        !             2: #include "y.tab.h"
        !             3: 
        !             4: #define SYMSIZE        5000
        !             5: 
        !             6: static char *symtab[SYMSIZE+1] = {
        !             7:        "(unnamed)"
        !             8: };
        !             9: static int syminstal   = 1;
        !            10: 
        !            11: int lookup(identifier)
        !            12: char *identifier;
        !            13: {
        !            14:        register int i;
        !            15:        i = 0;
        !            16:        symtab[syminstal] = identifier;
        !            17:        while (strcmp(identifier, symtab[i]))
        !            18:                i++;
        !            19:        if (i == syminstal) {
        !            20:                dprintf "installing NAME: %s\n", identifier);
        !            21:                if (i < SYMSIZE) {
        !            22:                        if (!(symtab[i] = malloc((unsigned) (1+strlen(identifier))))) {
        !            23:                                fprintf(stderr,"ideal: memory overflow in lookup\n");
        !            24:                                exit(1);
        !            25:                        }
        !            26:                }
        !            27:                else {
        !            28:                        fprintf(stderr,"ideal: too many identifiers\n");
        !            29:                        exit(1);
        !            30:                }
        !            31:                strcpy(symtab[syminstal++], identifier);
        !            32:        }
        !            33:        return(i);
        !            34: }
        !            35: 
        !            36: char *idprint(idnum)
        !            37: int idnum;
        !            38: {
        !            39:        if ((idnum > -1) && (idnum < syminstal))
        !            40:                return(symtab[idnum]);
        !            41:        else {
        !            42:                fprintf(stderr,"ideal: invalid identifier index: %d\n", idnum);
        !            43:                return(NULL);
        !            44:        }
        !            45: }
        !            46: 
        !            47: extern BOXPTR boxlist;
        !            48: 
        !            49: BOXPTR findbox (sought, alarm)
        !            50: int sought,
        !            51:        alarm;
        !            52: {
        !            53:        BOXPTR bxwalk;
        !            54:        for (bxwalk = boxlist;
        !            55:                bxwalk && (bxwalk->name != sought);
        !            56:                bxwalk = bxwalk->next)
        !            57:                ;
        !            58:        if (!bxwalk) {
        !            59:                if (!alarm)
        !            60:                        fprintf (stderr, "ideal: undefined box:  %s\n", idprint (sought));
        !            61:                return (boxgen (sought, (STMTPTR) NULL));
        !            62:        } else
        !            63:                return (bxwalk);
        !            64: }
        !            65: 
        !            66: 
        !            67: INTLPTR varfind (name, givennoad)
        !            68: int name;
        !            69: NOADPTR givennoad;
        !            70: {
        !            71:        /* finds simple variable 'name' from 'givennoad' */
        !            72:        register VARPTR varwalk;
        !            73:        if (!givennoad) {
        !            74:                fprintf (stderr, "ideal: no such variable, %s\n  >>>Returning 0.0\n",
        !            75:                        idprint (name)
        !            76:                );
        !            77:                return (commagen (0.0, 0.0));
        !            78:        }
        !            79:        dprintf "Looking for %s in %s\n", idprint (name), idprint (givennoad->defnode->name));
        !            80:        for (varwalk = givennoad->edgevarlist;
        !            81:                varwalk && THENAME(varwalk) != name;
        !            82:                varwalk = varwalk->next)
        !            83:                ;
        !            84:        if (!varwalk)
        !            85:                for (varwalk = givennoad->boxvarlist;
        !            86:                        varwalk && THENAME(varwalk) != name;
        !            87:                        varwalk = varwalk->next)
        !            88:                        ;
        !            89:        if (!varwalk)
        !            90:                return (varfind (name, givennoad->father));
        !            91:        else
        !            92:                return (intlgen (
        !            93:                        ';',
        !            94:                        (EXPR) depadd ((DEPPTR) NULL, 0.0, varwalk->deplist, 1.0),
        !            95:                        (EXPR) depadd ((DEPPTR) NULL, 0.0, varwalk->next->deplist, 1.0)
        !            96:                        ));
        !            97: }
        !            98: 
        !            99: INTLPTR pathfind (ptname, givennoad)
        !           100: NAMEPTR ptname;
        !           101: NOADPTR givennoad;
        !           102: {
        !           103:        /* finds compound variable 'ptname' from 'givennoad' */
        !           104:        int i;
        !           105:        STMTPTR putwalk;
        !           106:        NOADPTR noadwalk;
        !           107:        if (!ptname->next)
        !           108:                return (varfind (ptname->name, givennoad));
        !           109:        for (i = 0; i < 2; i++) {
        !           110:                noadwalk = givennoad->son;
        !           111:                for (putwalk = nextstmt (PUT, givennoad->defnode->parm->stmtlist);
        !           112:                        putwalk && ((PUTPTR) putwalk->stmt)->name != ptname->name;
        !           113:                        putwalk = nextstmt (PUT, putwalk->next))
        !           114:                        noadwalk = noadwalk->brother;
        !           115:                if (!putwalk)
        !           116:                        for (putwalk = nextstmt (PUT, findbox (givennoad->defnode->parm->name,FALSE)->stmtlist);
        !           117:                                putwalk && ((PUTPTR) putwalk->stmt)->name != ptname->name;
        !           118:                                putwalk = nextstmt (PUT, putwalk->next))
        !           119:                                noadwalk = noadwalk->brother;
        !           120:                if (putwalk) {
        !           121:                        dprintf "found %s, now looking for %s\n",
        !           122:                                idprint (ptname->name),
        !           123:                                idprint (ptname->next->name)
        !           124:                        );
        !           125:                        return (pathfind (ptname->next, noadwalk));
        !           126:                }
        !           127:                if (!(givennoad = givennoad->father)) {
        !           128:                        dprintf "reached root of noad tree\n");
        !           129:                        break;
        !           130:                } else {
        !           131:                        dprintf "looking for %s at father of %s\n",
        !           132:                                idprint (ptname->name),
        !           133:                                idprint (givennoad->defnode->name)
        !           134:                        );
        !           135:                }
        !           136:        }
        !           137:        fprintf (stderr, "ideal: invalid variable path name beginning %s\n  >>>Returning 0.0\n",
        !           138:                idprint (ptname->name));
        !           139:        return (commagen (0.0, 0.0));
        !           140: }
        !           141: 
        !           142: BOXPTR tail (head)
        !           143: BOXPTR head;
        !           144: {
        !           145:        while (head->next)
        !           146:                head = head->next;
        !           147:        return (head);
        !           148: }
        !           149: 
        !           150: void forget (sought)
        !           151: int sought;
        !           152: {
        !           153:        BOXPTR bxwalk;
        !           154:        BOXPTR prevbox;
        !           155:        prevbox = NULL;
        !           156:        for (bxwalk = boxlist;
        !           157:                bxwalk && (bxwalk->name != sought);
        !           158:                bxwalk = bxwalk->next)
        !           159:                prevbox = bxwalk;
        !           160:        if (bxwalk) {
        !           161:                if (prevbox) {
        !           162:                        prevbox->next = bxwalk->next;
        !           163:                } else {
        !           164:                        boxlist = bxwalk->next;
        !           165:                }
        !           166:                boxfree (bxwalk);
        !           167:        }
        !           168: }
        !           169: 
        !           170: void exprprint (exprn)
        !           171: EXPR exprn;
        !           172: {
        !           173:        INTLPTR intl;
        !           174:        EXTLPTR extl;
        !           175:        if (!exprn)
        !           176:                return;
        !           177:        if (((EXTLPTR) exprn)->leaf) {
        !           178:                extl = (EXTLPTR) exprn;
        !           179:                switch (extl->kind) {
        !           180:                case PATH:
        !           181:                        {
        !           182:                        NAMEPTR pathwalk;
        !           183:                        for (pathwalk = extl->info.path;
        !           184:                                pathwalk->next;
        !           185:                                pathwalk = pathwalk->next)
        !           186:                                fprintf (stderr, "%s.", idprint (pathwalk->name));
        !           187:                        fprintf (stderr, "%s", idprint (pathwalk->name));
        !           188:                        }
        !           189:                        break;
        !           190:                case CONST:
        !           191:                        fprintf (stderr, "%f", extl->info.const);
        !           192:                        break;
        !           193:                }
        !           194:        } else {
        !           195:                intl = (INTLPTR) exprn;
        !           196:                switch (intl->oper) {
        !           197:                case NAME:
        !           198:                        fprintf (stderr, "%s(", idprint ((int) intl->left));
        !           199:                        exprprint (((EXPRPTR) intl->right)->expr);
        !           200:                        fprintf (stderr, ")");
        !           201:                        break;
        !           202:                case '=':
        !           203:                case '~':
        !           204:                        exprprint ((EXPR) intl->right);
        !           205:                        break;
        !           206:                case ',':
        !           207:                        fprintf (stderr, "(");
        !           208:                        exprprint ((EXPR) intl->left);
        !           209:                        fprintf (stderr, ",");
        !           210:                        exprprint ((EXPR) intl->right);
        !           211:                        fprintf (stderr, ")");
        !           212:                        break;
        !           213:                case ';':
        !           214:                        fprintf (stderr, "(");
        !           215:                        depprint ((DEPPTR) intl->left);
        !           216:                        fprintf (stderr, ",");
        !           217:                        depprint ((DEPPTR) intl->right);
        !           218:                        fprintf (stderr, ")");
        !           219:                        break;
        !           220:                default:
        !           221:                        fprintf (stderr, "(");
        !           222:                        exprprint ((EXPR) intl->left);
        !           223:                        fprintf (stderr, " %c ", intl->oper);
        !           224:                        exprprint ((EXPR) intl->right);
        !           225:                        fprintf (stderr, ")");
        !           226:                        break;
        !           227:                }
        !           228:        }
        !           229: }
        !           230: 
        !           231: STMTPTR nextstmt (kind, curstmt)
        !           232: int kind;
        !           233: STMTPTR curstmt;
        !           234: {
        !           235:        register STMTPTR stmtwalk;
        !           236:        stmtwalk = curstmt;
        !           237:        for (stmtwalk;
        !           238:                stmtwalk && (stmtwalk->kind != kind);
        !           239:                stmtwalk = stmtwalk->next)
        !           240:                ;
        !           241:        return (stmtwalk);
        !           242: }
        !           243: 
        !           244: EXPR bracket (alpha, x, y)
        !           245: EXPR alpha,
        !           246:        x,
        !           247:        y;
        !           248: {
        !           249:        return (
        !           250:                (EXPR) intlgen (
        !           251:                        '+',
        !           252:                        x,
        !           253:                        (EXPR) intlgen (
        !           254:                                '*',
        !           255:                                alpha,
        !           256:                                (EXPR) intlgen (
        !           257:                                        '-',
        !           258:                                        y,
        !           259:                                        x
        !           260:                                )
        !           261:                        )
        !           262:                )
        !           263:        );
        !           264: }
        !           265: 
        !           266: void depprint (depnd)
        !           267: DEPPTR depnd;
        !           268: {
        !           269:        for (depnd;
        !           270:                depnd->next;
        !           271:                depnd = depnd->next)
        !           272:                fprintf (stderr, "%f %s(%s) + ",
        !           273:                        depnd->coeff,
        !           274:                        ISREAL(depnd->var)?"re":"im",
        !           275:                        idprint (THENAME(depnd->var))
        !           276:                );
        !           277:        fprintf (stderr, "%f", depnd->coeff);
        !           278:        if (depnd->var)
        !           279:                fprintf (stderr, " %s(%s)",
        !           280:                        ISREAL(depnd->var)?"re":"im",
        !           281:                        idprint (THENAME(depnd->var))
        !           282:                );
        !           283: }
        !           284: 
        !           285: void dexch (a,b)
        !           286: double *a;
        !           287: double *b;
        !           288: {
        !           289:        double temp;
        !           290:        temp = *a;
        !           291:        *a = *b;
        !           292:        *b = temp;
        !           293: }
        !           294: 
        !           295: void fexch (a,b)
        !           296: float *a;
        !           297: float *b;
        !           298: {
        !           299:        float temp;
        !           300:        temp = *a;
        !           301:        *a = *b;
        !           302:        *b = temp;
        !           303: }
        !           304: 
        !           305: float rprin (angle)
        !           306: float angle;
        !           307: {
        !           308:        while (angle < 0.0)
        !           309:                angle += 2*PI;
        !           310:        while (angle > 2*PI + EPSILON)
        !           311:                angle -= 2*PI;
        !           312:        return (angle);
        !           313: }
        !           314: 
        !           315: /*
        !           316: float dprin (angle)
        !           317: float angle;
        !           318: {
        !           319:        while (angle < 0.0)
        !           320:                angle += 360;
        !           321:        while (angle > 2*PI)
        !           322:                angle -= 360;
        !           323:        return (angle);
        !           324: }
        !           325: */
        !           326: 
        !           327: void angorder (startang, midang, endang)
        !           328: float *startang;
        !           329: float midang;
        !           330: float *endang;
        !           331: {
        !           332:        if (
        !           333:                ((*endang < -EPSILON +  midang) && (midang < -EPSILON +  *startang))
        !           334:        ||      ((*startang < -EPSILON +  *endang) && (*endang < -EPSILON +  midang))
        !           335:        ||      ((midang < -EPSILON +  *startang) && (*startang < -EPSILON +  *endang))
        !           336:        )
        !           337:                fexch (startang, endang);
        !           338: }
        !           339: 
        !           340: STMTPTR reverse (stmtlist)
        !           341: STMTPTR stmtlist;
        !           342: {
        !           343:        STMTPTR curstmt, prevstmt, temp;
        !           344:        prevstmt = curstmt = stmtlist;
        !           345:        temp = NULL;
        !           346:        while (curstmt) {
        !           347:                curstmt = prevstmt->next;
        !           348:                prevstmt->next = temp;
        !           349:                temp = prevstmt;
        !           350:                prevstmt = curstmt;
        !           351:        }
        !           352:        return (temp);
        !           353: }
        !           354: 
        !           355: void impossible (msg)
        !           356: char *msg;
        !           357: {
        !           358:        fprintf (stderr, "ideal: %s: can't happen\n", msg);
        !           359:        exit (1);
        !           360: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.