Return to 4.i CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests

Annotation of researchv10no/cmd/ccom/vax/tests/4.i, revision 1.1

1.1     ! root        1: extern struct  _iobuf {
        !             2:        int     _cnt;
        !             3:        char    *_ptr;
        !             4:        char    *_base;
        !             5:        short   _flag;
        !             6:        char    _file;
        !             7: } _iob[20];
        !             8: struct _iobuf  *fopen();
        !             9: struct _iobuf  *fdopen();
        !            10: struct _iobuf  *freopen();
        !            11: long   ftell();
        !            12: char   *fgets();
        !            13: typedef struct Triple{
        !            14:        float   x;
        !            15:        float   y;
        !            16:        float   z;
        !            17: }Triple;
        !            18: typedef Triple Color;
        !            19: typedef struct Point {
        !            20:        int type;
        !            21:        long stamp;             
        !            22:        double x;
        !            23:        double y;
        !            24:        double z;
        !            25: } Point;
        !            26: typedef struct Plane {
        !            27:        int type;
        !            28:        long stamp;
        !            29:        double A;
        !            30:        double B;
        !            31:        double C;
        !            32:        double D;
        !            33: } Plane;
        !            34: typedef struct Conic {
        !            35:        int type;
        !            36:        long stamp;
        !            37:        double A;
        !            38:        double B;
        !            39:        double C;
        !            40:        double D;
        !            41:        double E;
        !            42:        double F;
        !            43:        double G;
        !            44:        double H;
        !            45:        double I;
        !            46:        double J;
        !            47: } Conic;
        !            48: typedef struct Transform {
        !            49:        double A, B, C, D;
        !            50:        double E, F, G, H;
        !            51:        double I, J, K, L;
        !            52: } Transform;
        !            53: typedef struct Tpair {
        !            54:        int type;
        !            55:        long stamp;
        !            56:        Transform t;
        !            57:        Transform tinv;
        !            58: } Tpair;
        !            59: typedef struct Ctree {
        !            60:        int type;
        !            61:        int (*test)();
        !            62:        struct Ctree *car;
        !            63:        struct Ctree *cdr;
        !            64: } Ctree;
        !            65: typedef struct Surface {
        !            66:        int type;
        !            67:        short flags;
        !            68:        Triple n;       
        !            69:        short nfacet;
        !            70:        struct{
        !            71:                float m;
        !            72:                float frac;
        !            73:        }facet[5                ];
        !            74:        Triple *Dtab;
        !            75:        Color speccolor;
        !            76:        Color diffcolor;
        !            77:        Color ambcolor;
        !            78:        Color clearcolor;
        !            79: } Surface;
        !            80: typedef struct Object {
        !            81:        int type;
        !            82:        union {
        !            83:                Plane *plane;
        !            84:                Conic *conic;
        !            85:        } surface;
        !            86:        Conic *cover;
        !            87:        Point *center;
        !            88:        struct List *references;
        !            89:        Ctree *ctree;
        !            90:        Tpair *tpair;
        !            91:        Surface *srf;
        !            92:        float minrange1, minrange2;
        !            93:        float Q1, R1, S1, T1;
        !            94:        float Q2, R2, S2, T2;
        !            95:        int (*fun)();
        !            96: } Object;
        !            97: typedef struct View {
        !            98:        int type;
        !            99:        Tpair *tpair;
        !           100:        int style;
        !           101:        Color lightcolor;
        !           102:        Point *viewpoint;
        !           103:        Point *ul_corner, *ll_corner, *lr_corner;       
        !           104:        Plane *screen;
        !           105:        struct List *bin[32             ][32            ];      
        !           106: } View;
        !           107: typedef struct List {
        !           108:        int type;
        !           109:        union {
        !           110:                Point *point;
        !           111:                Object *object;
        !           112:                View *view;
        !           113:                struct List *list;
        !           114:        } car;
        !           115:        struct List *cdr;
        !           116: } List;
        !           117: typedef struct Symbol{
        !           118:        char    *name;
        !           119:        short   type;
        !           120:        union{
        !           121:                double  val;
        !           122:                List    *obj;
        !           123:                Tpair   *tpair;
        !           124:                Triple  *triple;
        !           125:                Surface *srf;
        !           126:        }u;
        !           127:        struct Symbol *next;
        !           128: }Symbol;
        !           129: extern double  range1;
        !           130: extern double  range2;
        !           131: extern long    transform_stamp;
        !           132: extern Color   black;
        !           133: extern Color   fillcolor;
        !           134: extern Color   white;
        !           135: extern List    *scene;
        !           136: extern Point   testpoint;
        !           137: extern Object  *pobject;
        !           138: extern Point   dirnums;
        !           139: extern Transform tnull;
        !           140: extern View    *camera;
        !           141: extern List    *lightsource;
        !           142: extern char    *progname;
        !           143: char           *emalloc();
        !           144: double         Pow();
        !           145: double         setvalue();
        !           146: double         value();
        !           147: double         fsqrt();
        !           148: Color          *create_color();
        !           149: Color          light();
        !           150: Ctree          *and();
        !           151: Ctree          *create_ctree();
        !           152: Ctree          *inside_list();
        !           153: Ctree          *outside_list();
        !           154: List           *cons_list();
        !           155: Object         *adddefn();
        !           156: Object         *boolean();
        !           157: Object         *copy();
        !           158: Object         *inside();
        !           159: Object         *outside();
        !           160: Object         *setobjvalue();
        !           161: Object         *unit_cone();
        !           162: Object         *unit_cube();
        !           163: Object         *unit_disc();
        !           164: Object         *unit_cylinder();
        !           165: Object         *unit_hyperboloid();
        !           166: Object         *unit_paraboloid();
        !           167: Object         *unit_paracylinder();
        !           168: Object         *unit_saddle();
        !           169: Object         *unit_sphere();
        !           170: Object         *unit_square();
        !           171: Point          intersect();
        !           172: Point          min_range();
        !           173: Point          trans_point();
        !           174: Surface                *create_surface();
        !           175: Symbol         *install();
        !           176: Symbol         *lookup();
        !           177: Tpair          *create_tpair();
        !           178: Tpair          *mulmat();
        !           179: Tpair          *matvalue();
        !           180: Tpair          *setmatvalue();
        !           181: Transform      trans_product();
        !           182: Triple         *trivalue();
        !           183: Triple         *settrivalue();
        !           184: Triple         *create_triple();
        !           185: View           *create_view();
        !           186: long transform_stamp = 1;
        !           187: extern double sin(), cos();
        !           188: Transform tnull = {1.0, 0.0, 0.0, 0.0,
        !           189:                   0.0, 1.0, 0.0, 0.0,
        !           190:                   0.0, 0.0, 1.0, 0.0,};
        !           191: Transform
        !           192: trans_product(t1, t2)
        !           193: register Transform *t1, *t2;
        !           194: {
        !           195:        Transform t3;
        !           196:        t3.A = t1->A * t2->A + t1->B * t2->E + t1->C * t2->I;
        !           197:        t3.B = t1->A * t2->B + t1->B * t2->F + t1->C * t2->J;
        !           198:        t3.C = t1->A * t2->C + t1->B * t2->G + t1->C * t2->K;
        !           199:        t3.D = t1->A * t2->D + t1->B * t2->H + t1->C * t2->L + t1->D;
        !           200:        t3.E = t1->E * t2->A + t1->F * t2->E + t1->G * t2->I;
        !           201:        t3.F = t1->E * t2->B + t1->F * t2->F + t1->G * t2->J;
        !           202:        t3.G = t1->E * t2->C + t1->F * t2->G + t1->G * t2->K;
        !           203:        t3.H = t1->E * t2->D + t1->F * t2->H + t1->G * t2->L + t1->H;
        !           204:        t3.I = t1->I * t2->A + t1->J * t2->E + t1->K * t2->I;
        !           205:        t3.J = t1->I * t2->B + t1->J * t2->F + t1->K * t2->J;
        !           206:        t3.K = t1->I * t2->C + t1->J * t2->G + t1->K * t2->K;
        !           207:        t3.L = t1->I * t2->D + t1->J * t2->H + t1->K * t2->L + t1->L;
        !           208:        return t3;
        !           209: }
        !           210: Conic
        !           211: trans_conic(t, c)
        !           212: register Transform *t;
        !           213: register Conic *c;
        !           214: {
        !           215:        Conic nc;
        !           216:        nc.type = 3;
        !           217:        nc.A =  (c->A*t->A*t->A + c->B*t->E*t->E + c->C*t->I*t->I) +
        !           218:                (c->D*t->A*t->E + c->E*t->E*t->I + c->F*t->A*t->I);
        !           219:        nc.B =  (c->A*t->B*t->B + c->B*t->F*t->F + c->C*t->J*t->J) +
        !           220:                (c->D*t->B*t->F + c->E*t->F*t->J + c->F*t->B*t->J);
        !           221:        nc.C =  (c->A*t->C*t->C + c->B*t->G*t->G + c->C*t->K*t->K) +
        !           222:                (c->D*t->C*t->G + c->E*t->G*t->K + c->F*t->C*t->K);
        !           223:        nc.D =  (c->A*t->A*t->B + c->B*t->E*t->F + c->C*t->I*t->J)*2.0 +
        !           224:                c->D*(t->A*t->F + t->B*t->E) +
        !           225:                c->E*(t->E*t->J + t->F*t->I) +
        !           226:                c->F*(t->A*t->J + t->B*t->I);
        !           227:        nc.E =  (c->A*t->B*t->C + c->B*t->F*t->G + c->C*t->J*t->K)*2.0 +
        !           228:                c->D*(t->B*t->G + t->C*t->F) +
        !           229:                c->E*(t->F*t->K + t->G*t->J) +
        !           230:                c->F*(t->B*t->K + t->C*t->J);
        !           231:        nc.F =  (c->A*t->A*t->C + c->B*t->E*t->G + c->C*t->I*t->K)*2.0 +
        !           232:                c->D*(t->A*t->G + t->E*t->C) +
        !           233:                c->E*(t->E*t->K + t->G*t->I) +
        !           234:                c->F*(t->A*t->K + t->C*t->I);
        !           235:        nc.G =  (c->A*t->A*t->D + c->B*t->E*t->H + c->C*t->I*t->L)*2.0 +
        !           236:                c->D*(t->A*t->H + t->D*t->E) +
        !           237:                c->E*(t->E*t->L + t->H*t->I) +
        !           238:                c->F*(t->A*t->L + t->D*t->I) +
        !           239:                c->G*t->A + c->H*t->E + c->I*t->I;
        !           240:        nc.H =  (c->A*t->B*t->D + c->B*t->F*t->H + c->C*t->J*t->L)*2.0 +
        !           241:                c->D*(t->B*t->H + t->D*t->F) +
        !           242:                c->E*(t->F*t->L + t->H*t->J) +
        !           243:                c->F*(t->B*t->L + t->D*t->J) +
        !           244:                c->G*t->B + c->H*t->F + c->I*t->J;
        !           245:        nc.I =  (c->A*t->C*t->D + c->B*t->G*t->H + c->C*t->K*t->L)*2.0 +
        !           246:                c->D*(t->C*t->H + t->D*t->G) +
        !           247:                c->E*(t->G*t->L + t->H*t->K) +
        !           248:                c->F*(t->C*t->L + t->D*t->K) +
        !           249:                c->G*t->C + c->H*t->G + c->I*t->K;
        !           250:        nc.J =  (c->A*t->D*t->D + c->B*t->H*t->H + c->C*t->L*t->L) +
        !           251:                (c->D*t->D*t->H + c->E*t->H*t->L + c->F*t->D*t->L) +
        !           252:                c->G*t->D + c->H*t->H + c->I*t->L +
        !           253:                c->J;
        !           254:        return nc;
        !           255: }
        !           256: Plane
        !           257: trans_plane(t, p)
        !           258: register Transform *t;
        !           259: register Plane *p;
        !           260: {
        !           261:        Plane np;
        !           262:        np.type = 2;
        !           263:        np.A = p->A*t->A + p->B*t->E + p->C*t->I;
        !           264:        np.B = p->A*t->B + p->B*t->F + p->C*t->J;
        !           265:        np.C = p->A*t->C + p->B*t->G + p->C*t->K;
        !           266:        np.D = p->A*t->D + p->B*t->H + p->C*t->L + p->D;
        !           267:        return np;
        !           268: }
        !           269: Point
        !           270: trans_point(t, p)
        !           271: register Transform *t;
        !           272: register Point *p;
        !           273: {
        !           274:        Point np;
        !           275:        np.type = 1;
        !           276:        np.x = t->A*p->x + t->B*p->y + t->C*p->z + t->D;
        !           277:        np.y = t->E*p->x + t->F*p->y + t->G*p->z + t->H;
        !           278:        np.z = t->I*p->x + t->J*p->y + t->K*p->z + t->L;
        !           279:        return np;
        !           280: }
        !           281: do_transform(tp, list)
        !           282: Tpair *tp;
        !           283: register List *list;
        !           284: {
        !           285:        if (!list)
        !           286:                return;
        !           287:        switch (list->type) {
        !           288:        case 1:
        !           289:                if (((Point *)list)->stamp == tp->stamp)
        !           290:                        return;
        !           291:                *((Point *)list) = trans_point(&tp->t, ((Point *)list));
        !           292:                ((Point *)list)->stamp = tp->stamp;
        !           293:                return;
        !           294:        case 3:
        !           295:                if (((Conic *)list)->stamp == tp->stamp)
        !           296:                        return;
        !           297:                *((Conic *)list) = trans_conic(&tp->tinv, ((Conic *)list));
        !           298:                ((Conic *)list)->stamp = tp->stamp;
        !           299:                return;
        !           300:        case 2:
        !           301:                if (((Plane *)list)->stamp == tp->stamp)
        !           302:                        return;
        !           303:                *((Plane *)list) = trans_plane(&tp->tinv, ((Plane *)list));
        !           304:                ((Plane *)list)->stamp = tp->stamp;
        !           305:                return;
        !           306:        case 5:
        !           307:                do_transform(tp, list->car.list);
        !           308:                do_transform(tp, list->cdr);
        !           309:                return;
        !           310:        case 7:
        !           311:                do_transform(tp, ((Ctree *)list)->car);
        !           312:                do_transform(tp, ((Ctree *)list)->cdr);
        !           313:                return;
        !           314:        case 4:
        !           315:                do_transform(tp, ((View *)list)->viewpoint);
        !           316:                do_transform(tp, ((View *)list)->ul_corner);
        !           317:                do_transform(tp, ((View *)list)->ll_corner);
        !           318:                do_transform(tp, ((View *)list)->lr_corner);
        !           319:                do_transform(tp, ((View *)list)->screen);
        !           320:                do_transform(tp, ((View *)list)->tpair);
        !           321:                return;
        !           322:        case 6:
        !           323:                do_transform(tp, ((Object *)list)->surface);
        !           324:                do_transform(tp, ((Object *)list)->cover);
        !           325:                do_transform(tp, ((Object *)list)->references);
        !           326:                do_transform(tp, ((Object *)list)->ctree);
        !           327:                do_transform(tp, ((Object *)list)->tpair);
        !           328:                do_transform(tp, ((Object *)list)->center);
        !           329:                return;
        !           330:        case 8:
        !           331:                if (((Tpair *)list)->stamp == tp->stamp)
        !           332:                        return;
        !           333:                ((Tpair *)list)->t = trans_product(&tp->t, &((Tpair *)list)->t);
        !           334:                ((Tpair *)list)->tinv = trans_product(&((Tpair *)list)->tinv, &tp->tinv);
        !           335:                ((Tpair *)list)->stamp = tp->stamp;
        !           336:        }
        !           337:        return;
        !           338: }
        !           339: translate(x, y, z, list)
        !           340: double x, y, z;
        !           341: List *list;
        !           342: {
        !           343:        Tpair tp;
        !           344:        tp.stamp = transform_stamp++;
        !           345:        tp.type = 8;
        !           346:        tp.t = tnull;
        !           347:        tp.t.A = 1.0;
        !           348:        tp.t.F = 1.0;
        !           349:        tp.t.K = 1.0;
        !           350:        tp.t.D = x;
        !           351:        tp.t.H = y;
        !           352:        tp.t.L = z;
        !           353:        tp.tinv = tp.t;
        !           354:        tp.tinv.D = -x;
        !           355:        tp.tinv.H = -y;
        !           356:        tp.tinv.L = -z;
        !           357:        do_transform(&tp, list);
        !           358: }
        !           359: stretch(x, y, z, list)
        !           360: double x, y, z;
        !           361: List *list;
        !           362: {
        !           363:        Tpair tp;
        !           364:        tp.stamp = transform_stamp++;
        !           365:        tp.type = 8;
        !           366:        tp.t = tnull;
        !           367:        tp.t.A = x;
        !           368:        tp.t.F = y;
        !           369:        tp.t.K = z;
        !           370:        tp.tinv = tnull;
        !           371:        tp.tinv.A = 1.0/x;
        !           372:        tp.tinv.F = 1.0/y;
        !           373:        tp.tinv.K = 1.0/z;
        !           374:        do_transform(&tp, list);
        !           375: }
        !           376: rotateX(theta, list)
        !           377: double theta;
        !           378: List *list;
        !           379: {
        !           380:        Tpair tp;
        !           381:        tp.stamp = transform_stamp++;
        !           382:        tp.type = 8;
        !           383:        theta = theta * 0.0174532925199432957692        ;
        !           384:        tp.t = tnull;
        !           385:        tp.t.A = 1.0;
        !           386:        tp.t.F = cos(theta);
        !           387:        tp.t.G = -sin(theta);
        !           388:        tp.t.J = -tp.t.G;
        !           389:        tp.t.K = tp.t.F;
        !           390:        tp.tinv = tp.t;
        !           391:        tp.tinv.G = -tp.tinv.G;
        !           392:        tp.tinv.J = -tp.tinv.J;
        !           393:        do_transform(&tp, list);
        !           394: }
        !           395: rotateY(theta, list)
        !           396: double theta;
        !           397: List *list;
        !           398: {
        !           399:        Tpair tp;
        !           400: 
        !           401: 
        !           402:        tp.stamp = transform_stamp++;
        !           403:        tp.type = 8;
        !           404:        theta = theta * 0.0174532925199432957692        ;
        !           405:        tp.t = tnull;
        !           406:        tp.t.F = 1.0;
        !           407:        tp.t.A = cos(theta);
        !           408:        tp.t.C = -sin(theta);
        !           409:        tp.t.I = -tp.t.C;
        !           410:        tp.t.K = tp.t.A;
        !           411:        tp.tinv = tp.t;
        !           412:        tp.tinv.C = -tp.tinv.C;
        !           413:        tp.tinv.I = -tp.tinv.I;
        !           414:        do_transform(&tp, list);
        !           415: }
        !           416: rotateZ(theta, list)
        !           417: double theta;
        !           418: List *list;
        !           419: {
        !           420:        Tpair tp;
        !           421: 
        !           422: 
        !           423:        tp.stamp = transform_stamp++;
        !           424:        tp.type = 8;
        !           425:        theta = theta * 0.0174532925199432957692        ;
        !           426:        tp.t = tnull;
        !           427:        tp.t.K = 1.0;
        !           428:        tp.t.A = cos(theta);
        !           429:        tp.t.B = -sin(theta);
        !           430:        tp.t.E = -tp.t.B;
        !           431:        tp.t.F = tp.t.A;
        !           432:        tp.tinv = tp.t;
        !           433:        tp.tinv.B = -tp.tinv.B;
        !           434:        tp.tinv.E = -tp.tinv.E;
        !           435:        do_transform(&tp, list);
        !           436: }
        !           437: Conic
        !           438: tangent_cone(p, c)
        !           439: register Point *p;
        !           440: register Conic *c;
        !           441: {
        !           442:        Conic e;
        !           443:        double f4, fx, fy, fz, fw;
        !           444:        
        !           445:        f4 = (p->x*(c->A*p->x + c->D*p->y + c->F*p->z + c->G) +
        !           446:              p->y*(c->B*p->y + c->E*p->z + c->H) +
        !           447:              p->z*(c->C*p->z + c->I) + c->J) * 4.0;
        !           448:        e.A = f4*c->A;
        !           449:        e.B = f4*c->B;
        !           450:        e.C = f4*c->C;
        !           451:        e.D = f4*c->D;
        !           452:        e.E = f4*c->E;
        !           453:        e.F = f4*c->F;
        !           454:        e.G = f4*c->G;
        !           455:        e.H = f4*c->H;
        !           456:        e.I = f4*c->I;
        !           457:        e.J = f4*c->J;
        !           458:        
        !           459:        fx = 2.0*c->A*p->x + c->D*p->y + c->F*p->z + c->G;
        !           460:        fy = 2.0*c->B*p->y + c->D*p->x + c->E*p->z + c->H;
        !           461:        fz = 2.0*c->C*p->z + c->E*p->y + c->F*p->x + c->I;
        !           462:        fw = 2.0*c->J      + c->G*p->x + c->H*p->y + c->I*p->z;
        !           463:        
        !           464:        e.A -= fx*fx;
        !           465:        e.B -= fy*fy;
        !           466:        e.C -= fz*fz;
        !           467:        e.J -= fw*fw;
        !           468:        e.D -= 2.0*fx*fy;
        !           469:        e.E -= 2.0*fy*fz;
        !           470:        e.F -= 2.0*fz*fx;
        !           471:        e.G -= 2.0*fx*fw;
        !           472:        e.H -= 2.0*fy*fw;
        !           473:        e.I -= 2.0*fz*fw;
        !           474:        return e;
        !           475: }

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