out.c

   1 #include <ctype.h>
   2 #include <stdarg.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include "roff.h"
   7
   8 static int out_nl = 1;
   9
  10 /* output troff code; newlines may appear only at the end of s */
  11 static void out_out(char *s, va_list ap)
  12 {
  13         out_nl = strchr(s, '\n') != NULL;
  14         vfprintf(stdout, s, ap);
  15 }
  16
  17 /* output troff code; no preceding newline is necessary */
  18 static void outnn(char *s, ...)
  19 {
  20         va_list ap;
  21         va_start(ap, s);
  22         out_out(s, ap);
  23         va_end(ap);
  24 }
  25
  26 /* output troff cmd; should appear after a newline */
  27 void out(char *s, ...)
  28 {
  29         va_list ap;
  30         if (!out_nl)
  31                 outnn("\n");
  32         va_start(ap, s);
  33         out_out(s, ap);
  34         va_end(ap);
  35 }
  36
  37 int utf8len(int c)
  38 {
  39         if (c <= 0x7f)
  40                 return 1;
  41         if (c >= 0xfc)
  42                 return 6;
  43         if (c >= 0xf8)
  44                 return 5;
  45         if (c >= 0xf0)
  46                 return 4;
  47         if (c >= 0xe0)
  48                 return 3;
  49         if (c >= 0xc0)
  50                 return 2;
  51         return c != 0;
  52 }
  53
  54 int utf8read(char **s, char *d)
  55 {
  56         int l = utf8len((unsigned char) **s);
  57         int i;
  58         for (i = 0; i < l; i++)
  59                 d[i] = (*s)[i];
  60         d[l] = '\0';
  61         *s += l;
  62         return l;
  63 }
  64
  65 static int o_s = 10;
  66 static int o_f = 1;
  67 static int o_m = 0;
  68
  69 static void out_ps(int n)
  70 {
  71         if (o_s != n) {
  72                 o_s = n;
  73                 out("s%d\n", o_s);
  74         }
  75 }
  76
  77 static void out_ft(int n)
  78 {
  79         if (n >= 0 && o_f != n) {
  80                 o_f = n;
  81                 out("f%d\n", o_f);
  82         }
  83 }
  84
  85 static void out_clr(int n)
  86 {
  87         if (n >= 0 && o_m != n) {
  88                 o_m = n;
  89                 out("m%s\n", clr_str(o_m));
  90         }
  91 }
  92
  93 static void escarg(char **sp, char *d, int cmd)
  94 {
  95         char *s = *sp;
  96         int q;
  97         if (strchr(ESC_P, cmd)) {
  98                 if (cmd == 's' && (*s == '-' || *s == '+'))
  99                         *d++ = *s++;
 100                 if (*s == '(') {
 101                         s++;
 102                         *d++ = *s++;
 103                         *d++ = *s++;
 104                 } else if (!n_cp && *s == '[') {
 105                         s++;
 106                         while (*s && *s != ']')
 107                                 *d++ = *s++;
 108                         if (*s == ']')
 109                                 s++;
 110                 } else {
 111                         *d++ = *s++;
 112                         if (cmd == 's' && s[-1] >= '1' && s[-1] <= '3')
 113                                 if (isdigit(*s))
 114                                         *d++ = *s++;
 115                 }
 116         }
 117         if (strchr(ESC_Q, cmd)) {
 118                 q = *s++;
 119                 while (*s && *s != q)
 120                         *d++ = *s++;
 121                 if (*s == q)
 122                         s++;
 123         }
 124         if (cmd == 'z')
 125                 *d++ = *s++;
 126         *d = '\0';
 127         *sp = s;
 128 }
 129
 130 static int tok_num(char **s, int scale)
 131 {
 132         char tok[ILNLEN];
 133         char *d = tok;
 134         while (isspace(**s))
 135                 (*s)++;
 136         while (**s && !isspace(**s))
 137                 *d++ = *(*s)++;
 138         *d = '\0';
 139         return eval(tok, scale);
 140 }
 141
 142 static void out_draw(char *s)
 143 {
 144         int c = *s++;
 145         out("D%c", c);
 146         switch (c) {
 147         case 'l':
 148                 outnn(" %d", tok_num(&s, 'm'));
 149                 outnn(" %d", tok_num(&s, 'v'));
 150                 outnn(" .");                    /* dpost requires this */
 151                 break;
 152         case 'c':
 153                 outnn(" %d", tok_num(&s, 'm'));
 154                 break;
 155         case 'e':
 156                 outnn(" %d", tok_num(&s, 'm'));
 157                 outnn(" %d", tok_num(&s, 'v'));
 158                 break;
 159         case 'a':
 160                 outnn(" %d", tok_num(&s, 'm'));
 161                 outnn(" %d", tok_num(&s, 'v'));
 162                 outnn(" %d", tok_num(&s, 'm'));
 163                 outnn(" %d", tok_num(&s, 'v'));
 164                 break;
 165         default:
 166                 outnn(" %d", tok_num(&s, 'm'));
 167                 outnn(" %d", tok_num(&s, 'v'));
 168                 while (*s) {
 169                         outnn(" %d", tok_num(&s, 'm'));
 170                         outnn(" %d", tok_num(&s, 'v'));
 171                 }
 172                 break;
 173         }
 174         outnn("\n");
 175 }
 176
 177 /*
 178  * read a glyph or output troff request
 179  *
 180  * This functions reads from s either an output troff request
 181  * (only the ones emitted by wb.c) or a glyph name and updates
 182  * s.  The return value is the name of the troff request (the
 183  * argument is copied into d) or zero for glyph names (it is
 184  * copied into d).  Returns -1 when the end of s is reached.
 185  */
 186 int out_readc(char **s, char *d)
 187 {
 188         char *r = d;
 189         if (!**s)
 190                 return -1;
 191         utf8read(s, d);
 192         if (d[0] == c_ec) {
 193                 utf8read(s, d + 1);
 194                 if (d[1] == '(') {
 195                         utf8read(s, d);
 196                         utf8read(s, d + strlen(d));
 197                 } else if (!n_cp && d[1] == '[') {
 198                         while (**s && **s != ']')
 199                                 *r++ = *(*s)++;
 200                         if (**s == ']')
 201                                 (*s)++;
 202                 } else if (strchr("CDfhmsvXx", d[1])) {
 203                         int c = d[1];
 204                         escarg(s, d, d[1]);
 205                         return c == 'C' ? 0 : c;
 206                 }
 207         }
 208         if (d[0] == c_ni)
 209                 utf8read(s, d + 1);
 210         return 0;
 211 }
 212
 213 void out_line(char *s)
 214 {
 215         struct glyph *g;
 216         char c[ILNLEN + GNLEN * 4];
 217         int t;
 218         while ((t = out_readc(&s, c)) >= 0) {
 219                 if (!t) {
 220                         if (c[0] == c_ni || (c[0] == '\\' && c[1] == '\\')) {
 221                                 c[0] = c[1];
 222                                 c[1] = '\0';
 223                         }
 224                         if (c[0] == '\t' || c[0] == '\x01' || !strcmp(c_hc, c))
 225                                 continue;
 226                         g = dev_glyph(c, o_f);
 227                         if (utf8len((unsigned char) c[0]) == strlen(c))
 228                                 outnn("c%s%s", c, c[1] ? "\n" : "");
 229                         else
 230                                 out("C%s\n", c[0] == c_ec && c[1] == '(' ? c + 2 : c);
 231                         outnn("h%d", charwid(g ? g->wid : SC_DW, o_s));
 232                         continue;
 233                 }
 234                 switch (t) {
 235                 case 'D':
 236                         out_draw(c);
 237                         break;
 238                 case 'f':
 239                         out_ft(dev_pos(c));
 240                         break;
 241                 case 'h':
 242                         outnn("h%d", eval(c, 'm'));
 243                         break;
 244                 case 'm':
 245                         if (!n_cp)
 246                                 out_clr(clr_get(c));
 247                         break;
 248                 case 's':
 249                         out_ps(eval_re(c, o_s, '\0'));
 250                         break;
 251                 case 'v':
 252                         outnn("v%d", eval(c, 'v'));
 253                         break;
 254                 case 'X':
 255                         out("x X %s\n", c);
 256                         break;
 257                 }
 258         }
 259 }