Return to 0.parts.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / struct

Annotation of 43BSDTahoe/usr.bin/struct/0.parts.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)0.parts.c  4.1     (Berkeley)      2/11/83";
                      3: #endif not lint
                      4: 
                      5: #include <stdio.h>
                      6: #include "def.h"
                      7: 
                      8: char *typename[TYPENUM]        = {"STLNVX",    "IFVX",         "DOVX",         "IOVX", "FMTVX",
                      9:                        "COMPVX",       "ASVX",         "ASGOVX",       "LOOPVX",       "WHIVX",
                     10:                        "UNTVX",        "ITERVX",       "THENVX",       "STOPVX",       "RETVX",
                     11:                        "DUMVX",        "GOVX",         "BRKVX",        "NXTVX",        "SWCHVX",
                     12:                        "ACASVX",       "ICASVX"
                     13:        };
                     14: int hascom[TYPENUM]    = {2,           2,              2,              2,              2,
                     15:                        2,              2,              2,              0,              0,
                     16:                        0,              0,              2,              0,              0,
                     17:                        0,              0,              0,              0,              2,
                     18:                        2,              0
                     19:                        };
                     20: 
                     21: int nonarcs[TYPENUM]   = {FIXED+3,     FIXED+4,        FIXED+2,        FIXED+3,        FIXED+2,
                     22:                        FIXED+2,        FIXED+2,        FIXED+2,        FIXED+1,        FIXED+1,
                     23:                        FIXED+1,        FIXED+4,        FIXED+3,        FIXED,          FIXED,
                     24:                        FIXED+2,        FIXED+1,        FIXED + 1,      FIXED + 1,      FIXED+3,
                     25:                        FIXED+4,        FIXED+2
                     26:                        };
                     27: 
                     28: int childper[TYPENUM]  = {0,   2,      1,      0,      0,
                     29:                        0,      0,      0,      1,      1,
                     30:                        1,      1,      1,      0,      0,
                     31:                        1,      0,      0,      0,      1,
                     32:                        2,      1
                     33:                        };
                     34: 
                     35: int arcsper[TYPENUM]   = {1,           2,              2,      3,      0,
                     36:                        -(FIXED+1),     1,      -(FIXED+1),     1,      1,
                     37:                        1,              1,              2,      0,      0,
                     38:                        -FIXED,         1,      1,              1,      -(FIXED+1),
                     39:                        2,              1
                     40:                        };
                     41: 
                     42: VERT *arc(v,i)
                     43: VERT v;
                     44: int i;
                     45:        {
                     46:        ASSERT(DEFINED(v),arc);
                     47:        ASSERT(0 <= i && i < ARCNUM(v), arc);
                     48:        return(&graph[v][nonarcs[NTYPE(v)] + i ]);
                     49:        }
                     50: 
                     51: VERT *lchild(v,i)
                     52: VERT v; int i;
                     53:        {
                     54:        ASSERT(DEFINED(v),lchild);
                     55:        ASSERT(0 <= i && i < childper[NTYPE(v)],lchild);
                     56:        return(&graph[v][nonarcs[NTYPE(v)]-i-1]);
                     57:        }
                     58: 
                     59: int *vxpart(v,type,j)
                     60: VERT v;
                     61: int type,j;
                     62:        {
                     63:        ASSERT((NTYPE(v) == type) && (0 <= j) && (j < nonarcs[type] - FIXED), vxpart);
                     64:        return(&graph[v][FIXED+j]);
                     65:        }
                     66: 
                     67: int *expres(v)
                     68: VERT v;
                     69:        {
                     70:        int ty;
                     71:        ty = NTYPE(v);
                     72:        ASSERT(ty == COMPVX || ty == ASGOVX || ty == ASVX || ty == SWCHVX || ty == ICASVX,expres);
                     73:        return(&graph[v][FIXED]);
                     74:        }
                     75: 
                     76: int *negpart(v)
                     77: VERT v;
                     78:        {
                     79:        ASSERT(NTYPE(v) == IFVX || NTYPE(v) == ACASVX,negpart);
                     80:        return(&graph[v][FIXED+1]);
                     81:        }
                     82: 
                     83: int *predic(v)
                     84: VERT v;
                     85:        {
                     86:        ASSERT(NTYPE(v) == IFVX || NTYPE(v) == ACASVX, predic);
                     87:        return(&graph[v][FIXED]);
                     88:        }
                     89: 
                     90: int *level(v)
                     91: VERT v;
                     92:        {
                     93:        ASSERT(NTYPE(v) == GOVX || NTYPE(v) == BRKVX || NTYPE(v) == NXTVX, level);
                     94:        return(&graph[v][FIXED]);
                     95:        }
                     96: int *stlfmt(v,n)
                     97: VERT v;
                     98: int n;
                     99:        {
                    100:        ASSERT(NTYPE(v) == STLNVX || NTYPE(v) == FMTVX,stlfmt);
                    101:        return(&graph[v][FIXED + n]);
                    102:        }
                    103: 
                    104: create(type,arcnum)
                    105: int type, arcnum;
                    106:        {
                    107:        int i, *temp, wds;
                    108:        if (nodenum >= maxnode)
                    109:                {
                    110:                maxnode += 100;
                    111:                temp=realloc(graph,maxnode*sizeof(*graph));
                    112:                free(graph);
                    113:                graph=temp;
                    114:                }
                    115:        wds = nonarcs[type] + arcnum;
                    116:        graph[nodenum] = galloc(sizeof(*graph) * wds);
                    117:        for (i = 0; i < wds; i++)  graph[nodenum][i] = 0;
                    118:        NTYPE(nodenum) = type;
                    119:        if (arcsper[type] < 0)
                    120:                ARCNUM(nodenum) = arcnum;
                    121:        
                    122:        return(nodenum++);
                    123:        }
                    124: 

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