Return to 3.then.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / struct

Annotation of 40BSD/cmd/struct/3.then.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "def.h"
                      3: #include "3.def.h"
                      4: 
                      5: #define BRANCHTYPE(t)  (t == STOPVX || t == RETVX || t == BRKVX || t == NXTVX || t == GOVX)
                      6: #define MAXCHUNK       20
                      7:                /* if else clause smaller than MAXCHUNK and smaller than then clause,
                      8:                        and there is no reason not to negate the if, negate the if */
                      9: 
                     10: getthen(v)             /* turn IFVX into THEN when appropriate, create else ifs where possible  */
                     11: VERT v;
                     12:        {
                     13:        VERT tch, fch;
                     14:        int tn,fn;
                     15:        int recvar;
                     16: 
                     17:        if (NTYPE(v) == IFVX)
                     18:                {
                     19:                tch = LCHILD(v,THEN);
                     20:                fch = LCHILD(v,ELSE);
                     21:                if (!DEFINED(fch))
                     22:                        mkthen(v);
                     23:                else if (!DEFINED(tch))
                     24:                        {
                     25:                        negate(v);
                     26:                        mkthen(v);
                     27:                        }
                     28:                else if (BRANCHTYPE(NTYPE(tch)))
                     29:                        mkthen(v);
                     30:                else if (BRANCHTYPE(NTYPE(fch)))
                     31:                        {
                     32:                        negate(v);
                     33:                        mkthen(v);
                     34:                        }
                     35:                else if (NTYPE(fch) != IFVX || DEFINED(RSIB(fch)))      /* not an else if */
                     36:                        if ( NTYPE(tch) == IFVX && !DEFINED(RSIB(tch)))
                     37:                                        /* invert into else if */
                     38:                                negate(v);
                     39:                        else
                     40:                                {
                     41:                                /* asoc(v,n) returns number of statements associated with v
                     42:                                        if <= n, -1 otherwise */
                     43:                                tn = asoc(tch,MAXCHUNK);
                     44:                                fn = asoc(fch,MAXCHUNK);
                     45:                                if (fn >= 0 && (tn < 0 || fn < tn))
                     46:                                        /* else clause smaller */
                     47:                                        negate(v);
                     48:                                }
                     49:                }
                     50:        RECURSE(getthen,v,recvar);
                     51:        }
                     52: 
                     53: mkthen(v)
                     54: VERT v;
                     55:        {
                     56:        VERT w,tc;
                     57:        w = LCHILD(v,ELSE);
                     58:        tc = LCHILD(v,THEN);
                     59:        ASSERT(!DEFINED(w) || (DEFINED(tc) && BRANCHTYPE(NTYPE(tc)) ),mkthen);
                     60:        if (DEFINED(w))
                     61:                {
                     62:                insib(v,w);
                     63:                LCHILD(v,ELSE) = UNDEFINED;
                     64:                }
                     65:        ASSERT(IFTHEN(v),mkthen);
                     66:        }
                     67: 
                     68: 
                     69: negate(v)
                     70: VERT v;
                     71:        {
                     72:        ASSERT(NTYPE(v) == IFVX,negate);
                     73:        exchange(&LCHILD(v,THEN), &LCHILD(v,ELSE));
                     74:        NEG(v) = !NEG(v);
                     75:        }

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