Return to layers.c CVS log

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

Annotation of 41BSD/cmd/cifplot/layers.c, revision 1.1.1.1

1.1       root        1: /*******************************************************************
                      2: *                                                                  *
                      3: *    File: CIFPLOT/layers.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 "pats.h"
                     15: #include "alloc.h"
                     16: 
                     17: IMPORT alloc();
                     18: IMPORT palloc();
                     19: 
                     20: struct LCell *Layers;  /* Points to the list of layers */
                     21: int UsedLayers = 0;    /* Count of how many layers have been used */
                     22: 
                     23: extern struct LCell *FindLayer();      /* Forward Reference FindLayer */
                     24: 
                     25: InitLayers()
                     26: {
                     27:     int i;
                     28: 
                     29:     MaxLayers = NUM_LAYERS;
                     30:     Pats = (int **) alloc(MaxLayers*sizeof(int *));
                     31:     Layers = NIL;
                     32:     for(i=0; i<NLAYERS; i++)
                     33:        CreatLayer(pats[i].IName,&(pats[i].IPat[0]));
                     34:     FindLayer(pats[0].IName);
                     35:     }
                     36: 
                     37: CreatLayer(s,p)
                     38: char *s;
                     39: int *p;
                     40: /* Add a layer to the 'Layers' list. 's' is the layer's name and
                     41:  * p is a pointer to the patterns */
                     42: {
                     43:     struct LCell *t;
                     44: 
                     45:     t = (struct LCell *) palloc(sizeof(struct LCell));
                     46:     t->LName = s;
                     47:     t->pat = p;
                     48:     t->LNum = -1;
                     49:     /* Add t to list of layers */
                     50:     t->Link = Layers;
                     51:     t->BackLink = NIL;
                     52:     t->visible = 1;
                     53:     if(Layers != NIL)
                     54:        Layers->BackLink = t;
                     55:     Layers = t;
                     56:     return;
                     57:     }
                     58: 
                     59: struct LCell *
                     60: FindLayer(s)
                     61: char *s;
                     62: /* Return a pointer to list element of layer 's'. Return NIL if
                     63:  * 's' is not a layer */
                     64: {
                     65:     struct LCell *p;
                     66: 
                     67:     for(p=Layers;p!=NIL;p=p->Link)
                     68:        if(strcmp(p->LName,s) == 0) {
                     69:            if(p->LNum == -1) {
                     70:                /* If this layer has never been used before give it
                     71:                 * a number */
                     72:                if(UsedLayers >= MaxLayers) {
                     73:                        MaxLayers = MaxLayers*2;
                     74:                        Pats = (int **) expand(Pats,MaxLayers*sizeof(int *));
                     75:                        }
                     76:                Pats[UsedLayers] = p->pat;
                     77:                p->LNum = UsedLayers++;
                     78:                }
                     79:            return(p);
                     80:            }
                     81:     return((struct LCell *) NIL);
                     82:     }
                     83: 
                     84: struct LCell *
                     85: GetLayer(n)
                     86: int n;
                     87: {
                     88:     struct LCell *p;
                     89: 
                     90:     for(p=Layers;p!=NIL;p=p->Link)
                     91:        if(p->LNum == n)
                     92:            return(p);
                     93:      return(NIL);
                     94: }
                     95: 
                     96: Command *
                     97: MakeLayer(l)
                     98: char *l;
                     99: /* Create a Command of type LAYER which has the value of
                    100:  * the layer in it's level field */
                    101: {
                    102:     Command *command;
                    103:     struct LCell *p;
                    104: 
                    105:     command = GetCommand();
                    106:     command->type = LAYER;
                    107:     command->CLink = NIL;
                    108:     command->Ctype.Layer = l;
                    109:     p = FindLayer(l);
                    110:     if(p == NIL) {
                    111:        Error("Unknown Layer",FATAL);
                    112:        CreatLayer(l,FindLayer("null")->pat);
                    113:        p = FindLayer(l);
                    114:        }
                    115:     command->level = p->LNum;
                    116:     return(command);
                    117:     }
                    118: 
                    119: Invisible(str)
                    120: char *str;
                    121: /* str is a string of layer names seperated by commas or spaces
                    122:  * that are to be made invisible */
                    123:  {
                    124:     char *name,ch;
                    125:     struct LCell *l;
                    126:     do {
                    127:        name = str;
                    128:        while(*str != '\0' && *str != ',' && *str != ' ' && *str != '\t') str++;
                    129:        ch = *str;
                    130:        *str = '\0';
                    131:        if(strcmp(name,"bbox") == 0) symbox = 0;
                    132:          else if(strcmp(name,"text") == 0) text = 0;
                    133:            else if(strcmp(name,"symbolName") == 0) printSymbolName = 0;
                    134:              else {
                    135:                l = FindLayer(name);
                    136:                if(l != NIL) l->visible = 0;
                    137:                  else fprintf(stderr,"%s: No Such Layer\n",name);
                    138:                }
                    139:        str++;
                    140:        } while(ch != '\0');
                    141:     }

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