dev.c

   1 /* output device */
   2 #include <ctype.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include "roff.h"
   7
   8 static char dev_dir[PATHLEN];   /* device directory */
   9 static char dev_dev[PATHLEN];   /* output device name */
  10 int dev_res;                    /* device resolution */
  11 int dev_uwid;                   /* device unitwidth */
  12 int dev_hor;                    /* minimum horizontal movement */
  13 int dev_ver;                    /* minimum vertical movement */
  14
  15 /* mounted fonts */
  16 static char fn_name[NFONTS][FNLEN];     /* font names */
  17 static struct font *fn_font[NFONTS];    /* font structs */
  18 static int fn_n;                        /* number of device fonts */
  19
  20 /* .fspecial request */
  21 static char fspecial_fn[NFONTS][FNLEN]; /* .fspecial first arguments */
  22 static char fspecial_sp[NFONTS][FNLEN]; /* .fspecial special fonts */
  23 static int fspecial_n;                  /* number of fonts in fspecial_sp[] */
  24
  25 static void skipline(FILE* filp)
  26 {
  27         int c;
  28         do {
  29                 c = getc(filp);
  30         } while (c != '\n' && c != EOF);
  31 }
  32
  33 static void dev_prologue(void)
  34 {
  35         out("x T %s\n", dev_dev);
  36         out("x res %d %d %d\n", dev_res, dev_hor, dev_ver);
  37         out("x init\n");
  38 }
  39
  40 /* find a position for the given font */
  41 static int dev_position(char *id)
  42 {
  43         int i;
  44         for (i = 1; i < NFONTS; i++)    /* already mounted */
  45                 if (!strcmp(fn_name[i], id))
  46                         return i;
  47         for (i = 1; i < NFONTS; i++)    /* the first empty position */
  48                 if (!fn_font[i])
  49                         return i;
  50         return 0;                       /* no room left */
  51 }
  52
  53 int dev_mnt(int pos, char *id, char *name)
  54 {
  55         char path[PATHLEN];
  56         struct font *fn;
  57         if (pos >= NFONTS)
  58                 return -1;
  59         if (strchr(name, '/'))
  60                 snprintf(path, sizeof(path), "%s", name);
  61         else
  62                 snprintf(path, sizeof(path), "%s/dev%s/%s", dev_dir, dev_dev, name);
  63         fn = font_open(path);
  64         if (!fn)
  65                 return -1;
  66         if (pos < 0)
  67                 pos = dev_position(id);
  68         if (fn_font[pos])
  69                 font_close(fn_font[pos]);
  70         if (fn_name[pos] != name)       /* ignore if fn_name[pos] is passed */
  71                 snprintf(fn_name[pos], sizeof(fn_name[pos]), "%s", id);
  72         fn_font[pos] = fn;
  73         out("x font %d %s\n", pos, name);
  74         return pos;
  75 }
  76
  77 int dev_open(char *dir, char *dev)
  78 {
  79         char path[PATHLEN];
  80         char tok[ILNLEN];
  81         int i;
  82         FILE *desc;
  83         snprintf(dev_dir, sizeof(dev_dir), "%s", dir);
  84         snprintf(dev_dev, sizeof(dev_dev), "%s", dev);
  85         snprintf(path, sizeof(path), "%s/dev%s/DESC", dir, dev);
  86         desc = fopen(path, "r");
  87         if (!desc)
  88                 return 1;
  89         while (fscanf(desc, "%s", tok) == 1) {
  90                 if (tok[0] == '#') {
  91                         skipline(desc);
  92                         continue;
  93                 }
  94                 if (!strcmp("fonts", tok)) {
  95                         fscanf(desc, "%d", &fn_n);
  96                         for (i = 0; i < fn_n; i++)
  97                                 fscanf(desc, "%s", fn_name[i + 1]);
  98                         fn_n++;
  99                         continue;
 100                 }
 101                 if (!strcmp("sizes", tok)) {
 102                         while (fscanf(desc, "%s", tok) == 1)
 103                                 if (!strcmp("0", tok))
 104                                         break;
 105                         continue;
 106                 }
 107                 if (!strcmp("res", tok)) {
 108                         fscanf(desc, "%d", &dev_res);
 109                         continue;
 110                 }
 111                 if (!strcmp("unitwidth", tok)) {
 112                         fscanf(desc, "%d", &dev_uwid);
 113                         continue;
 114                 }
 115                 if (!strcmp("hor", tok)) {
 116                         fscanf(desc, "%d", &dev_hor);
 117                         continue;
 118                 }
 119                 if (!strcmp("ver", tok)) {
 120                         fscanf(desc, "%d", &dev_ver);
 121                         continue;
 122                 }
 123                 if (!strcmp("charset", tok))
 124                         break;
 125                 skipline(desc);
 126         }
 127         fclose(desc);
 128         dev_prologue();
 129         for (i = 0; i < fn_n; i++)
 130                 if (*fn_name[i])
 131                         dev_mnt(i, fn_name[i], fn_name[i]);
 132         return 0;
 133 }
 134
 135 static void dev_epilogue(void)
 136 {
 137         out("x trailer\n");
 138         out("x stop\n");
 139 }
 140
 141 void dev_close(void)
 142 {
 143         int i;
 144         dev_epilogue();
 145         for (i = 0; i < NFONTS; i++) {
 146                 if (fn_font[i])
 147                         font_close(fn_font[i]);
 148                 fn_font[i] = NULL;
 149         }
 150 }
 151
 152 /* glyph handling functions */
 153
 154 static struct glyph *dev_find(char *c, int fn, int byid)
 155 {
 156         struct glyph *(*find)(struct font *fn, char *name);
 157         struct glyph *g;
 158         int i;
 159         find = byid ? font_glyph : font_find;
 160         if ((g = find(fn_font[fn], c)))
 161                 return g;
 162         for (i = 0; i < fspecial_n; i++)
 163                 if (dev_pos(fspecial_fn[i]) == fn && dev_pos(fspecial_sp[i]) >= 0)
 164                         if ((g = find(dev_font(dev_pos(fspecial_sp[i])), c)))
 165                                 return g;
 166         for (i = 0; i < NFONTS; i++)
 167                 if (fn_font[i] && font_special(fn_font[i]))
 168                         if ((g = find(fn_font[i], c)))
 169                                 return g;
 170         return NULL;
 171 }
 172
 173 struct glyph *dev_glyph(char *c, int fn)
 174 {
 175         if ((c[0] == c_ec || c[0] == c_ni) && c[1] == c_ec)
 176                 c++;
 177         if (c[0] == c_ec && c[1] == '(')
 178                 c += 2;
 179         c = cmap_map(c);
 180         if (!strncmp("GID=", c, 4))
 181                 return dev_find(c + 4, fn, 1);
 182         return dev_find(c, fn, 0);
 183 }
 184
 185 /* return the mounted position of a font */
 186 int dev_pos(char *id)
 187 {
 188         int i;
 189         if (isdigit(id[0])) {
 190                 int num = atoi(id);
 191                 if (num < 0 || num >= NFONTS || !fn_font[num]) {
 192                         errmsg("neatroff: bad font position %s\n", id);
 193                         return -1;
 194                 }
 195                 return num;
 196         }
 197         for (i = 1; i < NFONTS; i++)
 198                 if (!strcmp(fn_name[i], id))
 199                         return i;
 200         if (!strcmp(fn_name[0], id))
 201                 return 0;
 202         return dev_mnt(0, id, id);
 203 }
 204
 205 /* return the mounted position of a font struct */
 206 int dev_fontpos(struct font *fn)
 207 {
 208         int i;
 209         for (i = 0; i < NFONTS; i++)
 210                 if (fn_font[i] == fn)
 211                         return i;
 212         return 0;
 213 }
 214
 215 /* return the font struct at pos */
 216 struct font *dev_font(int pos)
 217 {
 218         return pos >= 0 && pos < NFONTS ? fn_font[pos] : NULL;
 219 }
 220
 221 void tr_fspecial(char **args)
 222 {
 223         char *fn = args[1];
 224         int i;
 225         if (!fn) {
 226                 fspecial_n = 0;
 227                 return;
 228         }
 229         for (i = 2; i < NARGS; i++) {
 230                 if (args[i] && fspecial_n < LEN(fspecial_fn)) {
 231                         snprintf(fspecial_fn[fspecial_n],
 232                                 sizeof(fspecial_fn[fspecial_n]), "%s", fn);
 233                         snprintf(fspecial_sp[fspecial_n],
 234                                 sizeof(fspecial_sp[fspecial_n]), "%s", args[i]);
 235                         fspecial_n++;
 236                 }
 237         }
 238 }