grap/misc.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include "grap.h"
   5 #include "y.tab.h"
   6
   7 int     nnum    = 0;    /* number of saved numbers */
   8 double  num[MAXNUM];
   9
  10 int     just;           /* current justification mode (RJUST, etc.) */
  11 int     sizeop;         /* current optional operator for size change */
  12 double  sizexpr;        /* current size change expression */
  13
  14 void savenum(int n, double f)   /* save f in num[n] */
  15 {
  16         num[n] = f;
  17         nnum = n+1;
  18         if (nnum >= MAXNUM)
  19                 ERROR "too many numbers" WARNING;
  20 }
  21
  22 void setjust(int j)
  23 {
  24         just |= j;
  25 }
  26
  27 void setsize(int op, double expr)
  28 {
  29         sizeop = op;
  30         sizexpr = expr;
  31 }
  32
  33 char *tostring(char *s)
  34 {
  35         register char *p;
  36
  37         p = malloc(strlen(s)+1);
  38         if (p == NULL)
  39                 ERROR "out of space in tostring on %s", s FATAL;
  40         strcpy(p, s);
  41         return(p);
  42 }
  43
  44 void range(Point pt)    /* update the range for point pt */
  45 {
  46         Obj *p = pt.obj;
  47
  48         if (!(p->coord & XFLAG)) {
  49                 if (pt.x > p->pt1.x)
  50                         p->pt1.x = pt.x;
  51                 if (pt.x < p->pt.x)
  52                         p->pt.x = pt.x;
  53         }
  54         if (!(p->coord & YFLAG)) {
  55                 if (pt.y > p->pt1.y)
  56                         p->pt1.y = pt.y;
  57                 if (pt.y < p->pt.y)
  58                         p->pt.y = pt.y;
  59         }
  60 }
  61
  62 void halfrange(Obj *p, int side, double val)    /* record max and min for one direction */
  63 {
  64         if (!(p->coord&XFLAG) && (side == LEFT || side == RIGHT)) {
  65                 if (val < p->pt.y)
  66                         p->pt.y = val;
  67                 if (val > p->pt1.y)
  68                         p->pt1.y = val;
  69         } else if (!(p->coord&YFLAG) && (side == TOP || side == BOT)) {
  70                 if (val < p->pt.x)
  71                         p->pt.x = val;
  72                 if (val > p->pt1.x)
  73                         p->pt1.x = val;
  74         }
  75 }
  76
  77
  78 Obj *lookup(char *s, int inst)  /* find s in objlist, install if inst */
  79 {
  80         Obj *p;
  81         int found = 0;
  82
  83         for (p = objlist; p; p = p->next){
  84                 if (strcmp(s, p->name) == 0) {
  85                         found = 1;
  86                         break;
  87                 }
  88         }
  89         if (p == NULL && inst != 0) {
  90                 p = (Obj *) calloc(1, sizeof(Obj));
  91                 if (p == NULL)
  92                         ERROR "out of space in lookup" FATAL;
  93                 p->name = tostring(s);
  94                 p->type = NAME;
  95                 p->pt = ptmax;
  96                 p->pt1 = ptmin;
  97                 p->fval = 0.0;
  98                 p->next = objlist;
  99                 objlist = p;
 100         }
 101         dprintf("lookup(%s,%d) = %d\n", s, inst, found);
 102         return p;
 103 }
 104
 105 double getvar(Obj *p)   /* return value of variable */
 106 {
 107         return p->fval;
 108 }
 109
 110 double setvar(Obj *p, double f) /* set value of variable to f */
 111 {
 112         if (strcmp(p->name, "pointsize") == 0) {        /* kludge */
 113                 pointsize = f;
 114                 ps_set = 1;
 115         }
 116         p->type = VARNAME;
 117         return p->fval = f;
 118 }
 119
 120 Point makepoint(Obj *s, double x, double y)     /* make a Point */
 121 {
 122         Point p;
 123
 124         dprintf("makepoint: %s, %g,%g\n", s->name, x, y);
 125         p.obj = s;
 126         p.x = x;
 127         p.y = y;
 128         return p;
 129 }
 130
 131 Attr *makefattr(int type, double fval)  /* set double in attribute */
 132 {
 133         return makeattr(type, fval, (char *) 0, 0, 0);
 134 }
 135
 136 Attr *makesattr(char *s)                /* make an Attr cell containing s */
 137 {
 138         Attr *ap = makeattr(STRING, sizexpr, s, just, sizeop);
 139         just = sizeop = 0;
 140         sizexpr = 0.0;
 141         return ap;
 142 }
 143
 144 Attr *makeattr(int type, double fval, char *sval, int just, int op)
 145 {
 146         Attr *a;
 147
 148         a = (Attr *) malloc(sizeof(Attr));
 149         if (a == NULL)
 150                 ERROR "out of space in makeattr" FATAL;
 151         a->type = type;
 152         a->fval = fval;
 153         a->sval = sval;
 154         a->just = just;
 155         a->op = op;
 156         a->next = NULL;
 157         return a;
 158 }
 159
 160 Attr *addattr(Attr *a1, Attr *ap)       /* add attr ap to end of list a1 */
 161 {
 162         Attr *p;
 163
 164         if (a1 == 0)
 165                 return ap;
 166         if (ap == 0)
 167                 return a1;
 168         for (p = a1; p->next; p = p->next)
 169                 ;
 170         p->next = ap;
 171         return a1;
 172 }
 173
 174 void freeattr(Attr *ap) /* free an attribute list */
 175 {
 176         Attr *p;
 177
 178         while (ap) {
 179                 p = ap->next;   /* save next */
 180                 if (ap->sval)
 181                         free(ap->sval);
 182                 free((char *) ap);
 183                 ap = p;
 184         }
 185 }
 186
 187 char *slprint(Attr *stringlist) /* print strings from stringlist */
 188 {
 189         int ntext, n, last_op, last_just;
 190         double last_fval;
 191         static char buf[1000];
 192         Attr *ap;
 193
 194         buf[0] = '\0';
 195         last_op = last_just = 0;
 196         last_fval = 0.0;
 197         for (ntext = 0, ap = stringlist; ap != NULL; ap = ap->next)
 198                 ntext++;
 199         sprintf(buf, "box invis wid 0 ht %d*textht", ntext);
 200         n = strlen(buf);
 201         for (ap = stringlist; ap != NULL; ap = ap->next) {
 202                 if (ap->op == 0) {      /* propagate last value */
 203                         ap->op = last_op;
 204                         ap->fval = last_fval;
 205                 } else {
 206                         last_op = ap->op;
 207                         last_fval = ap->fval;
 208                 }
 209                 sprintf(buf+n, " \"%s\"", ps_set || ap->op ? sizeit(ap) : ap->sval);
 210                 if (ap->just)
 211                         last_just = ap->just;
 212                 if (last_just)
 213                         strcat(buf+n, juststr(last_just));
 214                 n = strlen(buf);
 215         }
 216         return buf;     /* watch it:  static */
 217 }
 218
 219 char *juststr(int j)    /* convert RJUST, etc., into string */
 220 {
 221         static char buf[50];
 222
 223         buf[0] = '\0';
 224         if (j & RJUST)
 225                 strcat(buf, " rjust");
 226         if (j & LJUST)
 227                 strcat(buf, " ljust");
 228         if (j & ABOVE)
 229                 strcat(buf, " above");
 230         if (j & BELOW)
 231                 strcat(buf, " below");
 232         return buf;     /* watch it:  static */
 233 }
 234
 235 char *sprntf(char *s, Attr *ap) /* sprintf(s, attrlist ap) */
 236 {
 237         char buf[500];
 238         int n;
 239         Attr *p;
 240
 241         for (n = 0, p = ap; p; p = p->next)
 242                 n++;
 243         switch (n) {
 244         case 0:
 245                 return s;
 246         case 1:
 247                 sprintf(buf, s, ap->fval);
 248                 break;
 249         case 2:
 250                 sprintf(buf, s, ap->fval, ap->next->fval);
 251                 break;
 252         case 3:
 253                 sprintf(buf, s, ap->fval, ap->next->fval, ap->next->next->fval);
 254                 break;
 255         case 5:
 256                 ERROR "too many expressions in sprintf" WARNING;
 257         case 4:
 258                 sprintf(buf, s, ap->fval, ap->next->fval, ap->next->next->fval, ap->next->next->next->fval);
 259                 break;
 260         }
 261         free(s);
 262         return tostring(buf);
 263 }