in.c

   1 /* input stream management */
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include "roff.h"
   6
   7 struct inbuf {
   8         char path[64];          /* for file buffers */
   9         FILE *fin;
  10         char *buf;              /* for string buffers */
  11         char **args;
  12         int unbuf[8];           /* unread characters */
  13         int un;                 /* number of unread characters */
  14         int pos;
  15         int len;
  16         int lnum;               /* file line number */
  17         struct inbuf *prev;
  18 };
  19
  20 static struct inbuf *buf;
  21 static char files[NFILES][PATHLEN];
  22 static int nfiles;
  23 static int cfile;
  24
  25 static char **args_init(char **args);
  26 static void args_free(char **args);
  27
  28 static void in_new(void)
  29 {
  30         struct inbuf *next = xmalloc(sizeof(*next));
  31         memset(next, 0, sizeof(*next));
  32         next->prev = buf;
  33         buf = next;
  34 }
  35
  36 void in_push(char *s, char **args)
  37 {
  38         int len = strlen(s);
  39         in_new();
  40         buf->buf = xmalloc(len + 1);
  41         buf->len = len;
  42         strcpy(buf->buf, s);
  43         buf->args = args ? args_init(args) : NULL;
  44 }
  45
  46 void in_so(char *path)
  47 {
  48         FILE *fin = path && path[0] ? fopen(path, "r") : stdin;
  49         if (fin) {
  50                 in_new();
  51                 buf->fin = fin;
  52                 buf->lnum = 1;
  53                 if (path)
  54                         snprintf(buf->path, sizeof(buf->path), "%s", path);
  55         }
  56 }
  57
  58 void in_lf(char *path, int lnum)
  59 {
  60         struct inbuf *cur = buf;
  61         while (cur && !cur->fin)
  62                 cur = cur->prev;
  63         if (path)
  64                 snprintf(cur->path, sizeof(cur->path), "%s", path);
  65         cur->lnum = lnum;
  66 }
  67
  68 void in_queue(char *path)
  69 {
  70         if (nfiles < NFILES)
  71                 snprintf(files[nfiles++], PATHLEN - 1, "%s", path ? path : "");
  72 }
  73
  74 static void in_pop(void)
  75 {
  76         struct inbuf *old = buf;
  77         buf = buf->prev;
  78         if (old->args)
  79                 args_free(old->args);
  80         if (old->fin && old->fin != stdin)
  81                 fclose(old->fin);
  82         free(old->buf);
  83         free(old);
  84 }
  85
  86 void in_nx(char *path)
  87 {
  88         while (buf)
  89                 in_pop();
  90         if (path)
  91                 in_so(path);
  92 }
  93
  94 void in_ex(void)
  95 {
  96         while (buf)
  97                 in_pop();
  98         cfile = nfiles;
  99 }
 100
 101 static int in_nextfile(void)
 102 {
 103         while (!buf && cfile < nfiles)
 104                 in_so(files[cfile++]);
 105         return !buf;
 106 }
 107
 108 int in_next(void)
 109 {
 110         int c;
 111         while (buf || !in_nextfile()) {
 112                 if (buf->un)
 113                         return buf->unbuf[--buf->un];
 114                 if (buf->buf && buf->pos < buf->len)
 115                         break;
 116                 if (!buf->buf && (c = getc(buf->fin)) >= 0) {
 117                         if (c == '\n')
 118                                 buf->lnum++;
 119                         return c;
 120                 }
 121                 in_pop();
 122         }
 123         return buf ? (unsigned char) buf->buf[buf->pos++] : -1;
 124 }
 125
 126 void in_back(int c)
 127 {
 128         if (c < 0)
 129                 return;
 130         if (buf)
 131                 buf->unbuf[buf->un++] = c;
 132 }
 133
 134 int in_top(void)
 135 {
 136         return buf && buf->un ? buf->unbuf[buf->un - 1] : -1;
 137 }
 138
 139 char *in_arg(int i)
 140 {
 141         struct inbuf *cur = buf;
 142         while (cur && !cur->args)
 143                 cur = cur->prev;
 144         return cur && cur->args && cur->args[i - 1] ? cur->args[i - 1] : "";
 145 }
 146
 147 int in_nargs(void)
 148 {
 149         struct inbuf *cur = buf;
 150         int n = 0;
 151         while (cur && !cur->args)
 152                 cur = cur->prev;
 153         while (cur && cur->args && cur->args[n])
 154                 n++;
 155         return n;
 156 }
 157
 158 char *in_filename(void)
 159 {
 160         struct inbuf *cur = buf;
 161         while (cur && !cur->fin)
 162                 cur = cur->prev;
 163         return cur && cur->path[0] ? cur->path : "-";
 164 }
 165
 166 int in_lnum(void)
 167 {
 168         struct inbuf *cur = buf;
 169         while (cur && !cur->fin)
 170                 cur = cur->prev;
 171         return cur ? cur->lnum : 0;
 172 }
 173
 174 static char **args_init(char **args)
 175 {
 176         char **out = xmalloc(NARGS * sizeof(*out));
 177         int i;
 178         for (i = 0; i < NARGS; i++) {
 179                 out[i] = NULL;
 180                 if (args[i]) {
 181                         int len = strlen(args[i]) + 1;
 182                         out[i] = xmalloc(len);
 183                         memcpy(out[i], args[i], len);
 184                 }
 185         }
 186         return out;
 187 }
 188
 189 static void args_free(char **args)
 190 {
 191         int i;
 192         for (i = 0; i < NARGS; i++)
 193                 if (args[i])
 194                         free(args[i]);
 195         free(args);
 196 }