reg.c

   1 /* registers and environments */
   2 #include <ctype.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <time.h>
   8 #include <unistd.h>
   9 #include "roff.h"
  10
  11 #define NENVS           64      /* number of environment registers */
  12
  13 struct env {
  14         int eregs[NENVS];       /* environment-specific number registers */
  15         int tabs[NTABS];        /* tab stops */
  16         char tabs_type[NTABS];  /* type of tabs: L, C, R */
  17         struct fmt *fmt;        /* per environment line formatting buffer */
  18         struct wb wb;           /* per environment partial word */
  19         char tc[GNLEN];         /* tab character (.tc) */
  20         char lc[GNLEN];         /* leader character (.lc) */
  21         char hc[GNLEN];         /* hyphenation character (.hc) */
  22         char mc[GNLEN];         /* margin character (.mc) */
  23 };
  24
  25 static int nregs[NREGS];        /* global number registers */
  26 static int nregs_inc[NREGS];    /* number register auto-increment size */
  27 static int nregs_fmt[NREGS];    /* number register format */
  28 static char *sregs[NREGS];      /* global string registers */
  29 static void *sregs_dat[NREGS];  /* builtin function data */
  30 static struct env *envs[NREGS];/* environments */
  31 static struct env *env;         /* current enviroment */
  32 static int env_id;              /* current environment id */
  33 static int eregs_idx[NREGS];    /* register environment index in eregs[] */
  34
  35 static char *eregs[] = {        /* environment-specific number registers */
  36         "ln", ".f", ".i", ".j", ".l",
  37         ".L", ".nI", ".nm", ".nM", ".nn",
  38         ".nS", ".m", ".s", ".u", ".v",
  39         ".it", ".itn", ".mc", ".mcn",
  40         ".ce", ".f0", ".i0", ".l0",
  41         ".hy", ".hycost", ".hycost2", ".hycost3", ".hlm",
  42         ".L0", ".m0", ".n0", ".s0", ".ss", ".ssh", ".sss", ".pmll", ".pmllcost",
  43         ".ti", ".lt", ".lt0", ".v0",
  44 };
  45
  46 /* return the address of a number register */
  47 int *nreg(int id)
  48 {
  49         if (eregs_idx[id])
  50                 return &env->eregs[eregs_idx[id]];
  51         return &nregs[id];
  52 }
  53
  54 static char *directory(char *path)
  55 {
  56         static char dst[PATHLEN];
  57         char *s = strrchr(path, '/');
  58         if (!s)
  59                 return ".";
  60         if (path == s)
  61                 return "/";
  62         memcpy(dst, path, s - path);
  63         dst[s - path] = '\0';
  64         return dst;
  65 }
  66
  67 static int num_fmt(char *s, int n, int fmt);
  68
  69 /* the contents of a number register (returns a static buffer) */
  70 char *num_str(int id)
  71 {
  72         static char numbuf[128];
  73         char *s = map_name(id);
  74         if (!nregs_fmt[id])
  75                 nregs_fmt[id] = '0';
  76         numbuf[0] = '\0';
  77         if (s[0] == '.' && !s[2]) {
  78                 switch (s[1]) {
  79                 case 'b':
  80                         sprintf(numbuf, "%d", font_getbd(dev_font(n_f)));
  81                         return numbuf;
  82                 case 'c':
  83                         sprintf(numbuf, "%d", in_lnum());
  84                         return numbuf;
  85                 case 'k':
  86                         sprintf(numbuf, "%d", f_hpos());
  87                         return numbuf;
  88                 case 'm':
  89                         sprintf(numbuf, "#%02x%02x%02x",
  90                                 CLR_R(n_m), CLR_G(n_m), CLR_B(n_m));
  91                         return numbuf;
  92                 case 't':
  93                         sprintf(numbuf, "%d", f_nexttrap());
  94                         return numbuf;
  95                 case 'z':
  96                         if (f_divreg() >= 0)
  97                                 sprintf(numbuf, "%s", map_name(f_divreg()));
  98                         return numbuf;
  99                 case 'F':
 100                         sprintf(numbuf, "%s", in_filename());
 101                         return numbuf;
 102                 case 'D':
 103                         sprintf(numbuf, "%s", directory(in_filename()));
 104                         return numbuf;
 105                 case '$':
 106                         sprintf(numbuf, "%d", in_nargs());
 107                         return numbuf;
 108                 }
 109         }
 110         if (s[0] == '.' && !strcmp(".neat", s))
 111                 return "1";
 112         if (s[0] == '.' && s[1] == 'e' && s[2] == 'v' && !s[3])
 113                 return map_name(env_id);
 114         if (s[0] == '$' && s[1] == '$' && !s[2]) {
 115                 sprintf(numbuf, "%d", getpid());
 116                 return numbuf;
 117         }
 118         if (s[0] == 'y' && s[1] == 'r' && !s[2]) {
 119                 sprintf(numbuf, "%02d", *nreg(id));
 120                 return numbuf;
 121         }
 122         if (!nregs_fmt[id] || num_fmt(numbuf, *nreg(id), nregs_fmt[id]))
 123                 sprintf(numbuf, "%d", *nreg(id));
 124         return numbuf;
 125 }
 126
 127 void num_set(int id, int val)
 128 {
 129         if (!nregs_fmt[id])
 130                 nregs_fmt[id] = '0';
 131         *nreg(id) = val;
 132 }
 133
 134 void num_setinc(int id, int val)
 135 {
 136         nregs_inc[id] = val;
 137 }
 138
 139 void num_inc(int id, int pos)
 140 {
 141         *nreg(id) += pos > 0 ? nregs_inc[id] : -nregs_inc[id];
 142 }
 143
 144 void num_del(int id)
 145 {
 146         *nreg(id) = 0;
 147         nregs_inc[id] = 0;
 148         nregs_fmt[id] = 0;
 149 }
 150
 151 void str_set(int id, char *s)
 152 {
 153         int len = strlen(s) + 1;
 154         if (sregs[id])
 155                 free(sregs[id]);
 156         sregs[id] = xmalloc(len);
 157         memcpy(sregs[id], s, len);
 158         sregs_dat[id] = NULL;
 159 }
 160
 161 char *str_get(int id)
 162 {
 163         return sregs[id];
 164 }
 165
 166 void *str_dget(int id)
 167 {
 168         return sregs_dat[id];
 169 }
 170
 171 void str_dset(int id, void *d)
 172 {
 173         sregs_dat[id] = d;
 174 }
 175
 176 void str_rm(int id)
 177 {
 178         if (sregs[id])
 179                 free(sregs[id]);
 180         sregs[id] = NULL;
 181         sregs_dat[id] = NULL;
 182 }
 183
 184 void str_rn(int src, int dst)
 185 {
 186         if (!sregs[src] && !sregs_dat[src])
 187                 return;
 188         str_rm(dst);
 189         sregs[dst] = sregs[src];
 190         sregs_dat[dst] = sregs_dat[src];
 191         sregs[src] = NULL;
 192         sregs_dat[src] = NULL;
 193 }
 194
 195 static struct env *env_alloc(void)
 196 {
 197         struct env *env = xmalloc(sizeof(*env));
 198         memset(env, 0, sizeof(*env));
 199         wb_init(&env->wb);
 200         env->fmt = fmt_alloc();
 201         return env;
 202 }
 203
 204 static void env_free(struct env *env)
 205 {
 206         fmt_free(env->fmt);
 207         wb_done(&env->wb);
 208         free(env);
 209 }
 210
 211 static void env_set(int id)
 212 {
 213         int i;
 214         env = envs[id];
 215         env_id = id;
 216         if (!env) {
 217                 envs[id] = env_alloc();
 218                 env = envs[id];
 219                 n_f = 1;
 220                 n_i = 0;
 221                 n_j = AD_B;
 222                 n_l = SC_IN * 65 / 10;
 223                 n_L = 1;
 224                 n_s = 10;
 225                 n_u = 1;
 226                 n_v = 12 * SC_PT;
 227                 n_s0 = n_s;
 228                 n_f0 = n_f;
 229                 n_na = 0;
 230                 n_lt = SC_IN * 65 / 10;
 231                 n_hy = 1;
 232                 n_ss = 12;
 233                 n_sss = 12;
 234                 n_nM = 1;
 235                 n_nS = 1;
 236                 strcpy(env->hc, "\\%");
 237                 strcpy(env->lc, ".");
 238                 for (i = 0; i < NTABS; i++)
 239                         env->tabs[i] = i * SC_IN / 2;
 240         }
 241 }
 242
 243 static void init_time(void)
 244 {
 245         time_t t = time(NULL);
 246         struct tm *tm = localtime(&t);
 247         num_set(map("dw"), tm->tm_wday + 1);
 248         num_set(map("dy"), tm->tm_mday);
 249         num_set(map("mo"), tm->tm_mon + 1);
 250         num_set(map("yr"), tm->tm_year % 100);
 251 }
 252
 253 static void init_globals(void)
 254 {
 255         n_o = SC_IN;
 256         n_p = SC_IN * 11;
 257         n_lg = 1;
 258         n_kn = 1;
 259         num_set(map(".H"), 1);
 260         num_set(map(".V"), 1);
 261 }
 262
 263 void env_init(void)
 264 {
 265         int i;
 266         init_time();
 267         init_globals();
 268         for (i = 0; i < LEN(eregs); i++)
 269                 eregs_idx[map(eregs[i])] = i + 1;
 270         env_set(map("0"));
 271 }
 272
 273 void env_done(void)
 274 {
 275         int i;
 276         for (i = 0; i < LEN(envs); i++)
 277                 if (envs[i])
 278                         env_free(envs[i]);
 279         for (i = 0; i < LEN(sregs); i++)
 280                 free(sregs[i]);
 281 }
 282
 283 static int oenv[NPREV];         /* environment stack */
 284 static int nenv;
 285
 286 void tr_ev(char **args)
 287 {
 288         int id = -1;
 289         if (args[1])
 290                 id = map(args[1]);
 291         else
 292                 id = nenv ? oenv[--nenv] : -1;
 293         if (id < 0)
 294                 return;
 295         if (args[1] && env && nenv < NPREV)
 296                 oenv[nenv++] = env_id;
 297         env_set(id);
 298 }
 299
 300 struct fmt *env_fmt(void)
 301 {
 302         return env->fmt;
 303 }
 304
 305 struct wb *env_wb(void)
 306 {
 307         return &env->wb;
 308 }
 309
 310 char *env_hc(void)
 311 {
 312         return env->hc;
 313 }
 314
 315 char *env_mc(void)
 316 {
 317         return env->mc;
 318 }
 319
 320 char *env_tc(void)
 321 {
 322         return env->tc;
 323 }
 324
 325 char *env_lc(void)
 326 {
 327         return env->lc;
 328 }
 329
 330 /* saving and restoring registers around diverted lines */
 331 struct odiv {
 332         int f, s, m, f0, s0, m0;
 333 };
 334
 335 static struct odiv odivs[NPREV];        /* state before diverted text */
 336 static int nodivs;
 337
 338 /* begin outputting diverted line */
 339 void odiv_beg(void)
 340 {
 341         struct odiv *o = &odivs[nodivs++];
 342         o->f = n_f;
 343         o->s = n_s;
 344         o->m = n_m;
 345         o->f0 = n_f0;
 346         o->s0 = n_s0;
 347         o->m0 = n_m0;
 348 }
 349
 350 /* end outputting diverted line */
 351 void odiv_end(void)
 352 {
 353         struct odiv *o = &odivs[--nodivs];
 354         n_f = o->f;
 355         n_s = o->s;
 356         n_m = o->m;
 357         n_f0 = o->f0;
 358         n_s0 = o->s0;
 359         n_m0 = o->m0;
 360 }
 361
 362 void tr_ta(char **args)
 363 {
 364         int i;
 365         char *s;
 366         for (i = 0; i < NARGS && args[i]; i++) {
 367                 env->tabs[i] = eval_re(args[i], i > 0 ? env->tabs[i - 1] : 0, 'm');
 368                 s = args[i][0] ? strchr(args[i], '\0') - 1 : "";
 369                 env->tabs_type[i] = strchr("LRC", *s) ? *s : 'L';
 370         }
 371 }
 372
 373 static int tab_idx(int pos)
 374 {
 375         int i;
 376         for (i = 0; i < LEN(env->tabs); i++)
 377                 if (env->tabs[i] > pos)
 378                         return i;
 379         return -1;
 380 }
 381
 382 int tab_next(int pos)
 383 {
 384         int i = tab_idx(pos);
 385         return i >= 0 ? env->tabs[i] : pos;
 386 }
 387
 388 int tab_type(int pos)
 389 {
 390         int i = tab_idx(pos);
 391         return i >= 0 && env->tabs_type[i] ? env->tabs_type[i] : 'L';
 392 }
 393
 394 /* number register format (.af) */
 395 #define NF_LSH          8               /* number format length shifts */
 396 #define NF_FMT          0x00ff          /* number format mask */
 397
 398 /* the format of a number register (returns a static buffer) */
 399 char *num_getfmt(int id)
 400 {
 401         static char fmtbuf[128];
 402         char *s = fmtbuf;
 403         int i;
 404         if ((nregs_fmt[id] & NF_FMT) == '0') {
 405                 *s++ = '0';
 406                 i = nregs_fmt[id] >> NF_LSH;
 407                 while (i-- > 1)
 408                         *s++ = '0';
 409         } else if (nregs_fmt[id]) {
 410                 *s++ = nregs_fmt[id] & NF_FMT;
 411         }
 412         *s = '\0';
 413         return fmtbuf;
 414 }
 415
 416 void num_setfmt(int id, char *s)
 417 {
 418         int i = 0;
 419         if (strchr("iIaA", s[0])) {
 420                 nregs_fmt[id] = s[0];
 421         } else {
 422                 while (isdigit(s[i]))
 423                         i++;
 424                 nregs_fmt[id] = '0' | (i << NF_LSH);
 425         }
 426 }
 427
 428 static void nf_reverse(char *s)
 429 {
 430         char r[128];
 431         int i, l;
 432         strcpy(r, s);
 433         l = strlen(r);
 434         for (i = 0; i < l; i++)
 435                 s[i] = r[l - i - 1];
 436 }
 437
 438 static void nf_roman(char *s, int n, char *I, char *V)
 439 {
 440         int i;
 441         if (!n)
 442                 return;
 443         if (n % 5 == 4) {
 444                 *s++ = n % 10 == 9 ? I[1] : V[0];
 445                 *s++ = I[0];
 446         } else {
 447                 for (i = 0; i < n % 5; i++)
 448                         *s++ = I[0];
 449                 if (n % 10 >= 5)
 450                         *s++ = V[0];
 451         }
 452         *s = '\0';
 453         nf_roman(s, n / 10, I + 1, V + 1);
 454 }
 455
 456 static void nf_alpha(char *s, int n, int a)
 457 {
 458         while (n) {
 459                 *s++ = a + ((n - 1) % 26);
 460                 n /= 26;
 461         }
 462         *s = '\0';
 463 }
 464
 465 /* returns nonzero on failure */
 466 static int num_fmt(char *s, int n, int fmt)
 467 {
 468         int type = fmt & NF_FMT;
 469         int len;
 470         if (n < 0) {
 471                 n = -n;
 472                 *s++ = '-';
 473         }
 474         if ((type == 'i' || type == 'I') && n > 0 && n < 40000) {
 475                 if (type == 'i')
 476                         nf_roman(s, n, "ixcmz", "vldw");
 477                 else
 478                         nf_roman(s, n, "IXCMZ", "VLDW");
 479                 nf_reverse(s);
 480                 return 0;
 481         }
 482         if ((type == 'a' || type == 'A') && n > 0) {
 483                 nf_alpha(s, n, type);
 484                 nf_reverse(s);
 485                 return 0;
 486         }
 487         if (type == '0') {
 488                 sprintf(s, "%d", n);
 489                 len = strlen(s);
 490                 while (len++ < fmt >> NF_LSH)
 491                         *s++ = '0';
 492                 sprintf(s, "%d", n);
 493                 return 0;
 494         }
 495         return 1;
 496 }