troff/reg.cc

   1 // -*- C++ -*-
   2 /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   3      Written by James Clark (jjc@jclark.com)
   4
   5 This file is part of groff.
   6
   7 groff is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 groff is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with groff; see the file COPYING.  If not, write to the Free Software
  19 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20
  21 #include "troff.h"
  22 #include "symbol.h"
  23 #include "dictionary.h"
  24 #include "token.h"
  25 #include "request.h"
  26 #include "reg.h"
  27
  28 object_dictionary number_reg_dictionary(101);
  29
  30 int reg::get_value(units * /*d*/)
  31 {
  32   return 0;
  33 }
  34
  35 void reg::increment()
  36 {
  37   error("can't increment read-only register");
  38 }
  39
  40 void reg::decrement()
  41 {
  42   error("can't decrement read-only register");
  43 }
  44
  45 void reg::set_increment(units /*n*/)
  46 {
  47   error("can't auto increment read-only register");
  48 }
  49
  50 void reg::alter_format(char /*f*/, int /*w*/)
  51 {
  52   error("can't alter format of read-only register");
  53 }
  54
  55 const char *reg::get_format()
  56 {
  57   return "0";
  58 }
  59
  60 void reg::set_value(units /*n*/)
  61 {
  62   error("can't write read-only register");
  63 }
  64
  65 general_reg::general_reg() : format('1'), width(0), inc(0)
  66 {
  67 }
  68
  69 static const char *number_value_to_ascii(int value, char format, int width)
  70 {
  71   static char buf[128];         // must be at least 21
  72   switch(format) {
  73   case '1':
  74     if (width <= 0)
  75       return itoa(value);
  76     else if (width > sizeof(buf) - 2)
  77       sprintf(buf, "%.*d", sizeof(buf) - 2, int(value));
  78     else
  79       sprintf(buf, "%.*d", width, int(value));
  80     break;
  81   case 'i':
  82   case 'I':
  83     {
  84       char *p = buf;
  85       // troff uses z and w to represent 10000 and 5000 in Roman
  86       // numerals; I can find no historical basis for this usage
  87       const char *s = format == 'i' ? "zwmdclxvi" : "ZWMDCLXVI";
  88       int n = int(value);
  89       if (n >= 40000 || n <= -40000) {
  90         error("magnitude of `%1' too big for i or I format", n);
  91         return itoa(n);
  92       }
  93       if (n == 0) {
  94         *p++ = '0';
  95         *p = 0;
  96         break;
  97       }
  98       if (n < 0) {
  99         *p++ = '-';
 100         n = -n;
 101       }
 102       while (n >= 10000) {
 103         *p++ = s[0];
 104         n -= 10000;
 105       }
 106       for (int i = 1000; i > 0; i /= 10, s += 2) {
 107         int m = n/i;
 108         n -= m*i;
 109         switch (m) {
 110         case 3:
 111           *p++ = s[2];
 112           /* falls through */
 113         case 2:
 114           *p++ = s[2];
 115           /* falls through */
 116         case 1:
 117           *p++ = s[2];
 118           break;
 119         case 4:
 120           *p++ = s[2];
 121           *p++ = s[1];
 122           break;
 123         case 8:
 124           *p++ = s[1];
 125           *p++ = s[2];
 126           *p++ = s[2];
 127           *p++ = s[2];
 128           break;
 129         case 7:
 130           *p++ = s[1];
 131           *p++ = s[2];
 132           *p++ = s[2];
 133           break;
 134         case 6:
 135           *p++ = s[1];
 136           *p++ = s[2];
 137           break;
 138         case 5:
 139           *p++ = s[1];
 140           break;
 141         case 9:
 142           *p++ = s[2];
 143           *p++ = s[0];
 144         }
 145       }
 146       *p = 0;
 147       break;
 148     }
 149   case 'a':
 150   case 'A':
 151     {
 152       int n = value;
 153       char *p = buf;
 154       if (n == 0) {
 155         *p++ = '0';
 156         *p = 0;
 157       }
 158       else {
 159         if (n < 0) {
 160           n = -n;
 161           *p++ = '-';
 162         }
 163         // this is a bit tricky
 164         while (n > 0) {
 165           int d = n % 26;
 166           if (d == 0)
 167             d = 26;
 168           n -= d;
 169           n /= 26;
 170           *p++ = format + d - 1;
 171         }
 172         *p-- = 0;
 173         char *q = buf[0] == '-' ? buf+1 : buf;
 174         while (q < p) {
 175           char temp = *q;
 176           *q = *p;
 177           *p = temp;
 178           --p;
 179           ++q;
 180         }
 181       }
 182       break;
 183     }
 184   default:
 185     assert(0);
 186     break;
 187   }
 188   return buf;
 189 }
 190
 191 const char *general_reg::get_string()
 192 {
 193   units n;
 194   if (!get_value(&n))
 195     return "";
 196   return number_value_to_ascii(n, format, width);
 197 }
 198
 199
 200 void general_reg::increment()
 201 {
 202   int n;
 203   if (get_value(&n))
 204     set_value(n + inc);
 205 }
 206
 207 void general_reg::decrement()
 208 {
 209   int n;
 210   if (get_value(&n))
 211     set_value(n - inc);
 212 }
 213
 214 void general_reg::set_increment(units n)
 215 {
 216   inc = n;
 217 }
 218
 219 void general_reg::alter_format(char f, int w)
 220 {
 221   format = f;
 222   width = w;
 223 }
 224
 225 static const char *number_format_to_ascii(char format, int width)
 226 {
 227   static char buf[24];
 228   if (format == '1') {
 229     if (width > 0) {
 230       int n = width;
 231       if (n > int(sizeof(buf)) - 1)
 232         n = int(sizeof(buf)) - 1;
 233       sprintf(buf, "%.*d", n, 0);
 234       return buf;
 235     }
 236     else
 237       return "0";
 238   }
 239   else {
 240     buf[0] = format;
 241     buf[1] = '\0';
 242     return buf;
 243   }
 244 }
 245
 246 const char *general_reg::get_format()
 247 {
 248   return number_format_to_ascii(format, width);
 249 }
 250
 251 class number_reg : public general_reg {
 252   units value;
 253 public:
 254   number_reg();
 255   int get_value(units *);
 256   void set_value(units);
 257 };
 258
 259 number_reg::number_reg() : value(0)
 260 {
 261 }
 262
 263 int number_reg::get_value(units *res)
 264 {
 265   *res = value;
 266   return 1;
 267 }
 268
 269 void number_reg::set_value(units n)
 270 {
 271   value = n;
 272 }
 273
 274 variable_reg::variable_reg(units *p) : ptr(p)
 275 {
 276 }
 277
 278 void variable_reg::set_value(units n)
 279 {
 280   *ptr = n;
 281 }
 282
 283 int variable_reg::get_value(units *res)
 284 {
 285   *res = *ptr;
 286   return 1;
 287 }
 288
 289 void define_number_reg()
 290 {
 291   symbol nm = get_name(1);
 292   if (nm.is_null()) {
 293     skip_line();
 294     return;
 295   }
 296   reg *r = (reg *)number_reg_dictionary.lookup(nm);
 297   units v;
 298   units prev_value;
 299   if (!r || !r->get_value(&prev_value))
 300     prev_value = 0;
 301   if (get_number(&v, 'u', prev_value)) {
 302     if (r == 0) {
 303       r = new number_reg;
 304       number_reg_dictionary.define(nm, r);
 305     }
 306     r->set_value(v);
 307     if (tok.space() && has_arg() && get_number(&v, 'u'))
 308       r->set_increment(v);
 309   }
 310   skip_line();
 311 }
 312
 313 #if 0
 314 void inline_define_reg()
 315 {
 316   token start;
 317   start.next();
 318   if (!start.delimiter(1))
 319     return;
 320   tok.next();
 321   symbol nm = get_name(1);
 322   if (nm.is_null())
 323     return;
 324   reg *r = (reg *)number_reg_dictionary.lookup(nm);
 325   if (r == 0) {
 326     r = new number_reg;
 327     number_reg_dictionary.define(nm, r);
 328   }
 329   units v;
 330   units prev_value;
 331   if (!r->get_value(&prev_value))
 332     prev_value = 0;
 333   if (get_number(&v, 'u', prev_value)) {
 334     r->set_value(v);
 335     if (start != tok) {
 336       if (get_number(&v, 'u')) {
 337         r->set_increment(v);
 338         if (start != tok)
 339           warning(WARN_DELIM, "closing delimiter does not match");
 340       }
 341     }
 342   }
 343 }
 344 #endif
 345
 346 void set_number_reg(symbol nm, units n)
 347 {
 348   reg *r = (reg *)number_reg_dictionary.lookup(nm);
 349   if (r == 0) {
 350     r = new number_reg;
 351     number_reg_dictionary.define(nm, r);
 352   }
 353   r->set_value(n);
 354 }
 355
 356 reg *lookup_number_reg(symbol nm)
 357 {
 358   reg *r = (reg *)number_reg_dictionary.lookup(nm);
 359   if (r == 0) {
 360     warning(WARN_REG, "number register `%1' not defined", nm.contents());
 361     r = new number_reg;
 362     number_reg_dictionary.define(nm, r);
 363   }
 364   return r;
 365 }
 366
 367 void alter_format()
 368 {
 369   symbol nm = get_name(1);
 370   if (nm.is_null()) {
 371     skip_line();
 372     return;
 373   }
 374   reg *r = (reg *)number_reg_dictionary.lookup(nm);
 375   if (r == 0) {
 376     r = new number_reg;
 377     number_reg_dictionary.define(nm, r);
 378   }
 379   tok.skip();
 380   char c = tok.ch();
 381   if (csdigit(c)) {
 382     int n = 0;
 383     do {
 384       ++n;
 385       tok.next();
 386     } while (csdigit(tok.ch()));
 387     r->alter_format('1', n);
 388   }
 389   else if (c == 'i' || c == 'I' || c == 'a' || c == 'A')
 390     r->alter_format(c);
 391   else if (tok.newline() || tok.eof())
 392     warning(WARN_MISSING, "missing number register format");
 393   else
 394     error("bad number register format (got %1)", tok.description());
 395   skip_line();
 396 }
 397
 398 void remove_reg()
 399 {
 400   for (;;) {
 401     symbol s = get_name();
 402     if (s.is_null())
 403       break;
 404     number_reg_dictionary.remove(s);
 405   }
 406   skip_line();
 407 }
 408
 409 void alias_reg()
 410 {
 411   symbol s1 = get_name(1);
 412   if (!s1.is_null()) {
 413     symbol s2 = get_name(1);
 414     if (!s2.is_null()) {
 415       if (!number_reg_dictionary.alias(s1, s2))
 416         warning(WARN_REG, "number register `%1' not defined", s2.contents());
 417     }
 418   }
 419   skip_line();
 420 }
 421
 422 void rename_reg()
 423 {
 424   symbol s1 = get_name(1);
 425   if (!s1.is_null()) {
 426     symbol s2 = get_name(1);
 427     if (!s2.is_null())
 428       number_reg_dictionary.rename(s1, s2);
 429   }
 430   skip_line();
 431 }
 432
 433 void print_number_regs()
 434 {
 435   object_dictionary_iterator iter(number_reg_dictionary);
 436   reg *r;
 437   symbol s;
 438   while (iter.get(&s, (object **)&r)) {
 439     assert(!s.is_null());
 440     errprint("%1\t", s.contents());
 441     const char *p = r->get_string();
 442     if (p)
 443       errprint(p);
 444     errprint("\n");
 445   }
 446   fflush(stderr);
 447   skip_line();
 448 }
 449
 450 void init_reg_requests()
 451 {
 452   init_request("rr", remove_reg);
 453   init_request("nr", define_number_reg);
 454   init_request("af", alter_format);
 455   init_request("aln", alias_reg);
 456   init_request("rnn", rename_reg);
 457   init_request("pnr", print_number_regs);
 458 }