Return to plot.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / cifplot

Annotation of 41BSD/cmd/cifplot/plot.c, revision 1.1

1.1     ! root        1: /*******************************************************************
        !             2: *                                                                  *
        !             3: *    File: CIFPLOT/plot.c                                          *
        !             4: *    Written by Dan Fitzpatrick                                    *
        !             5: *    copyright 1980 -- Regents of the University of California     *
        !             6: *                                                                  *
        !             7: ********************************************************************/
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include "defs.h"
        !            11: #include "globals.h"
        !            12: #include "parser_defs.h"
        !            13: #include "structs.h"
        !            14: #include "out_structs.h"
        !            15: 
        !            16: #define CONST 4
        !            17: 
        !            18: IMPORT GetList();
        !            19: IMPORT ICompare();
        !            20: IMPORT instance *GetUnAct();
        !            21: 
        !            22: Plot()
        !            23: {
        !            24:      int i,j,k;
        !            25: 
        !            26:       vopen();
        !            27:       Instanciate(prog,GlobalTransform,0);
        !            28:       NextEdge = -INFINITY;
        !            29:       for(i=CONVERT((real) prog->CBBox.xmin - 1); i<Bottom;i=Sift(i));
        !            30:       for(j = Bottom; j<=Top+40; j += OUT_BUF_SIZE) {
        !            31:        for(i = j; i < j+OUT_BUF_SIZE; i++) {
        !            32:            Sift(i);
        !            33:            if(i>=LastEdge) RemoveEdges(i);
        !            34:            /*
        !            35:            if(i>=NextEdge) 
        !            36:            */
        !            37:                AddEdges(i);
        !            38:            Sort(i);
        !            39:            ScanActives(i);
        !            40:            }
        !            41:        i = j + OUT_BUF_SIZE;
        !            42:        /* We're at the end of output buffer, send remaining traps */
        !            43:        finishBuf = 1;
        !            44:        for(k=0;k<UsedLayers;k++) change[k] = 1;
        !            45:        Sift(i);
        !            46:        if(i>=LastEdge) RemoveEdges(i);
        !            47:        /*
        !            48:        if(i>=NextEdge) 
        !            49:        */
        !            50:            AddEdges(i);
        !            51:        Sort(i);
        !            52:        ScanActives(i);
        !            53:        DumpBuf(i);
        !            54:        finishBuf = 0;
        !            55:        for(k=0;k<UsedLayers;k++) AddLine(k,i);
        !            56:        }
        !            57:     vclose();
        !            58:     }
        !            59: 
        !            60: Sift(i)
        !            61: register int i;
        !            62: {
        !            63:     register instance *p;
        !            64: 
        !            65:     while((p=GetUnAct(i)) != NIL) {
        !            66:        Activate(p);
        !            67:        }
        !            68:     return(FindNext(i));
        !            69:     }
        !            70: 
        !            71: InitPlotter()
        !            72: {
        !            73:     int i;
        !            74:     Top = CONVERT((real) Window.xmax) + 1;
        !            75:     xLast = Bottom = CONVERT((real) Window.xmin - 1) - 1;
        !            76:     EdgeQueue = (Queue *) alloc(UsedLayers*sizeof(Queue));
        !            77:     NEdgeQueue = (Queue *) alloc(UsedLayers*sizeof(Queue));
        !            78:     ActiveEdges = (List *) alloc(UsedLayers*sizeof(List));
        !            79:     NecEdgeQueue = (Queue *) alloc(UsedLayers*sizeof(Queue));
        !            80:     EdgeEnd = (int *) alloc(UsedLayers*sizeof(int));
        !            81:     EdgeStart = (int *) alloc(UsedLayers*sizeof(int));
        !            82:     EdgeIntersection = (int *) alloc(UsedLayers*sizeof(int));
        !            83:     Valid = (int *) alloc(UsedLayers*sizeof(int));
        !            84:     Drawn = (int *) alloc(UsedLayers*sizeof(int));
        !            85:     NextChange = (int *) alloc(UsedLayers*sizeof(int));
        !            86:     EdgeHolder = (nedge **) alloc(UsedLayers*sizeof(nedge));
        !            87:     change = (int *) alloc(UsedLayers*sizeof(int));
        !            88:     xprev = (int *) alloc(UsedLayers*sizeof(int));
        !            89:     NextEdge = LastEdge = INFINITY;
        !            90:     finishBuf = 0;
        !            91:     DummyPoly.level = 0;
        !            92:     DummyPoly.count = 0;
        !            93:     DummyPoly.refs = 0;
        !            94:     for(i=0;i<UsedLayers;i++) {
        !            95:        EdgeEnd[i] = INFINITY;
        !            96:        EdgeStart[i] = Bottom;
        !            97:        EdgeIntersection[i] = INFINITY;
        !            98:        Valid[i] = INFINITY;
        !            99:        Drawn[i] = -INFINITY;
        !           100:        NextChange[i] = -INFINITY;
        !           101:        EdgeHolder[i] = NIL;
        !           102:        change[i] = 0;
        !           103:        xprev[i] = -INFINITY;
        !           104:        InitQueue(&(EdgeQueue[i]));
        !           105:        InitQueue(&(NEdgeQueue[i]));
        !           106:        InitQueue(&(NecEdgeQueue[i]));
        !           107:        InitList(&(ActiveEdges[i]));
        !           108:        }
        !           109:     InitList(&TempList);
        !           110:     InitUnAct();
        !           111:     InitQueue(&FreeHolders);
        !           112:     InitList(&TextList);
        !           113:     InitScan();
        !           114:     }
        !           115: 
        !           116: ReStartPlotter()
        !           117: {
        !           118:     int i;
        !           119:     InitPlotter();
        !           120:     NextEdge = LastEdge = INFINITY;
        !           121:     DummyPoly.level = 0;
        !           122:     DummyPoly.count = 0;
        !           123:     DummyPoly.refs = 0;
        !           124:     for(i=0;i<UsedLayers;i++) {
        !           125:        EdgeEnd[i] = INFINITY;
        !           126:        EdgeStart[i] = Bottom;
        !           127:        EdgeIntersection[i] = INFINITY;
        !           128:        Valid[i] = INFINITY;
        !           129:        Drawn[i] = -INFINITY;
        !           130:        NextChange[i] = -INFINITY;
        !           131:        EdgeHolder[i] = NIL;
        !           132:        change[i] = 0;
        !           133:        InitQueue(&(EdgeQueue[i]));
        !           134:        InitQueue(&(NEdgeQueue[i]));
        !           135:        InitQueue(&(NecEdgeQueue[i]));
        !           136:        InitList(&(ActiveEdges[i]));
        !           137:        }
        !           138:     }

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