bfd/doc/chew.c

   1 /* chew
   2    Copyright (C) 1990-2023 Free Software Foundation, Inc.
   3    Contributed by steve chamberlain @cygnus
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 /* Yet another way of extracting documentation from source.
  23    No, I haven't finished it yet, but I hope you people like it better
  24    than the old way
  25
  26    sac
  27
  28    Basically, this is a sort of string forth, maybe we should call it
  29    struth?
  30
  31    You define new words thus:
  32    : <newword> <oldwords> ;
  33
  34    Variables are defined using:
  35    variable NAME
  36
  37 */
  38
  39 /* Primitives provided by the program:
  40
  41    Two stacks are provided, a string stack and an integer stack.
  42
  43    Internal state variables:
  44         internal_wanted - indicates whether `-i' was passed
  45         internal_mode - user-settable
  46
  47    Commands:
  48         push_text
  49         ! - pop top of integer stack for address, pop next for value; store
  50         @ - treat value on integer stack as the address of an integer; push
  51                 that integer on the integer stack after popping the "address"
  52         hello - print "hello\n" to stdout
  53         stdout - put stdout marker on TOS
  54         stderr - put stderr marker on TOS
  55         print - print TOS-1 on TOS (eg: "hello\n" stdout print)
  56         skip_past_newline
  57         catstr - fn icatstr
  58         copy_past_newline - append input, up to and including newline into TOS
  59         dup - fn other_dup
  60         drop - discard TOS
  61         idrop - ditto
  62         remchar - delete last character from TOS
  63         get_stuff_in_command
  64         do_fancy_stuff - translate <<foo>> to @code{foo} in TOS
  65         bulletize - if "o" lines found, prepend @itemize @bullet to TOS
  66                 and @item to each "o" line; append @end itemize
  67         courierize - put @example around . and | lines, translate {* *} { }
  68         exit - fn chew_exit
  69         swap
  70         outputdots - strip out lines without leading dots
  71         maybecatstr - do catstr if internal_mode == internal_wanted, discard
  72                 value in any case
  73         catstrif - do catstr if top of integer stack is nonzero
  74         translatecomments - turn {* and *} into comment delimiters
  75         kill_bogus_lines - get rid of extra newlines
  76         indent
  77         print_stack_level - print current stack depth to stderr
  78         strip_trailing_newlines - go ahead, guess...
  79         [quoted string] - push string onto string stack
  80         [word starting with digit] - push atol(str) onto integer stack
  81
  82         internalmode - the internalmode variable (evaluates to address)
  83
  84    A command must be all upper-case, and alone on a line.
  85
  86    Foo.  */
  87
  88 #include <assert.h>
  89 #include <stdio.h>
  90 #include <ctype.h>
  91 #include <stdlib.h>
  92 #include <string.h>
  93 #include <stdint.h>
  94 #include <inttypes.h>
  95
  96 #define DEF_SIZE 5000
  97 #define STACK 50
  98
  99 /* Here is a string type ...  */
 100
 101 typedef struct buffer
 102 {
 103   char *ptr;
 104   unsigned long write_idx;
 105   unsigned long size;
 106 } string_type;
 107
 108 /* Compiled programs consist of arrays of these.  */
 109
 110 typedef union
 111 {
 112   void (*f) (void);
 113   struct dict_struct *e;
 114   char *s;
 115   intptr_t l;
 116 } pcu;
 117
 118 typedef struct dict_struct
 119 {
 120   char *word;
 121   struct dict_struct *next;
 122   pcu *code;
 123   int code_length;
 124   int code_end;
 125 } dict_type;
 126
 127 int internal_wanted;
 128 intptr_t *internal_mode;
 129
 130 int warning;
 131
 132 string_type stack[STACK];
 133 string_type *tos;
 134
 135 unsigned int idx = 0; /* Pos in input buffer */
 136 string_type *ptr; /* and the buffer */
 137
 138 intptr_t istack[STACK];
 139 intptr_t *isp = &istack[0];
 140
 141 dict_type *root;
 142
 143 pcu *pc;
 144
 145 static void
 146 die (char *msg)
 147 {
 148   fprintf (stderr, "%s\n", msg);
 149   exit (1);
 150 }
 151
 152 void *
 153 xmalloc (size_t size)
 154 {
 155   void *newmem;
 156
 157   if (size == 0)
 158     size = 1;
 159   newmem = malloc (size);
 160   if (!newmem)
 161     die ("out of memory");
 162
 163   return newmem;
 164 }
 165
 166 void *
 167 xrealloc (void *oldmem, size_t size)
 168 {
 169   void *newmem;
 170
 171   if (size == 0)
 172     size = 1;
 173   if (!oldmem)
 174     newmem = malloc (size);
 175   else
 176     newmem = realloc (oldmem, size);
 177   if (!newmem)
 178     die ("out of memory");
 179
 180   return newmem;
 181 }
 182
 183 char *
 184 xstrdup (const char *s)
 185 {
 186   size_t len = strlen (s) + 1;
 187   char *ret = xmalloc (len);
 188   return memcpy (ret, s, len);
 189 }
 190
 191 static void
 192 init_string_with_size (string_type *buffer, unsigned int size)
 193 {
 194   buffer->write_idx = 0;
 195   buffer->size = size;
 196   buffer->ptr = xmalloc (size);
 197 }
 198
 199 static void
 200 init_string (string_type *buffer)
 201 {
 202   init_string_with_size (buffer, DEF_SIZE);
 203 }
 204
 205 static int
 206 find (string_type *str, char *what)
 207 {
 208   unsigned int i;
 209   char *p;
 210   p = what;
 211   for (i = 0; i < str->write_idx && *p; i++)
 212     {
 213       if (*p == str->ptr[i])
 214         p++;
 215       else
 216         p = what;
 217     }
 218   return (*p == 0);
 219 }
 220
 221 static void
 222 write_buffer (string_type *buffer, FILE *f)
 223 {
 224   if (buffer->write_idx != 0
 225       && fwrite (buffer->ptr, buffer->write_idx, 1, f) != 1)
 226     die ("cannot write output");
 227 }
 228
 229 static void
 230 delete_string (string_type *buffer)
 231 {
 232   free (buffer->ptr);
 233   buffer->ptr = NULL;
 234 }
 235
 236 static char *
 237 addr (string_type *buffer, unsigned int idx)
 238 {
 239   return buffer->ptr + idx;
 240 }
 241
 242 static char
 243 at (string_type *buffer, unsigned int pos)
 244 {
 245   if (pos >= buffer->write_idx)
 246     return 0;
 247   return buffer->ptr[pos];
 248 }
 249
 250 static void
 251 catchar (string_type *buffer, int ch)
 252 {
 253   if (buffer->write_idx == buffer->size)
 254     {
 255       buffer->size *= 2;
 256       buffer->ptr = xrealloc (buffer->ptr, buffer->size);
 257     }
 258
 259   buffer->ptr[buffer->write_idx++] = ch;
 260 }
 261
 262 static void
 263 overwrite_string (string_type *dst, string_type *src)
 264 {
 265   free (dst->ptr);
 266   dst->size = src->size;
 267   dst->write_idx = src->write_idx;
 268   dst->ptr = src->ptr;
 269 }
 270
 271 static void
 272 catbuf (string_type *buffer, char *buf, unsigned int len)
 273 {
 274   if (buffer->write_idx + len >= buffer->size)
 275     {
 276       while (buffer->write_idx + len >= buffer->size)
 277         buffer->size *= 2;
 278       buffer->ptr = xrealloc (buffer->ptr, buffer->size);
 279     }
 280   memcpy (buffer->ptr + buffer->write_idx, buf, len);
 281   buffer->write_idx += len;
 282 }
 283
 284 static void
 285 cattext (string_type *buffer, char *string)
 286 {
 287   catbuf (buffer, string, (unsigned int) strlen (string));
 288 }
 289
 290 static void
 291 catstr (string_type *dst, string_type *src)
 292 {
 293   catbuf (dst, src->ptr, src->write_idx);
 294 }
 295
 296 static unsigned int
 297 skip_white_and_stars (string_type *src, unsigned int idx)
 298 {
 299   char c;
 300   while ((c = at (src, idx)),
 301          isspace ((unsigned char) c)
 302          || (c == '*'
 303              /* Don't skip past end-of-comment or star as first
 304                 character on its line.  */
 305              && at (src, idx +1) != '/'
 306              && at (src, idx -1) != '\n'))
 307     idx++;
 308   return idx;
 309 }
 310
 311 static unsigned int
 312 skip_past_newline_1 (string_type *ptr, unsigned int idx)
 313 {
 314   while (at (ptr, idx)
 315          && at (ptr, idx) != '\n')
 316     idx++;
 317   if (at (ptr, idx) == '\n')
 318     return idx + 1;
 319   return idx;
 320 }
 321
 322 static void
 323 check_range (void)
 324 {
 325   if (tos < stack)
 326     die ("underflow in string stack");
 327   if (tos >= stack + STACK)
 328     die ("overflow in string stack");
 329 }
 330
 331 static void
 332 icheck_range (void)
 333 {
 334   if (isp < istack)
 335     die ("underflow in integer stack");
 336   if (isp >= istack + STACK)
 337     die ("overflow in integer stack");
 338 }
 339
 340 static void
 341 exec (dict_type *word)
 342 {
 343   pc = word->code;
 344   while (pc->f)
 345     pc->f ();
 346 }
 347
 348 static void
 349 call (void)
 350 {
 351   pcu *oldpc = pc;
 352   dict_type *e = pc[1].e;
 353   exec (e);
 354   pc = oldpc + 2;
 355 }
 356
 357 static void
 358 remchar (void)
 359 {
 360   if (tos->write_idx)
 361     tos->write_idx--;
 362   pc++;
 363 }
 364
 365 static void
 366 strip_trailing_newlines (void)
 367 {
 368   while ((isspace ((unsigned char) at (tos, tos->write_idx - 1))
 369           || at (tos, tos->write_idx - 1) == '\n')
 370          && tos->write_idx > 0)
 371     tos->write_idx--;
 372   pc++;
 373 }
 374
 375 static void
 376 push_number (void)
 377 {
 378   isp++;
 379   icheck_range ();
 380   pc++;
 381   *isp = pc->l;
 382   pc++;
 383 }
 384
 385 /* This is a wrapper for push_number just so we can correctly free the
 386    variable at the end.  */
 387 static void
 388 push_variable (void)
 389 {
 390   push_number ();
 391 }
 392
 393 static void
 394 push_text (void)
 395 {
 396   tos++;
 397   check_range ();
 398   init_string (tos);
 399   pc++;
 400   cattext (tos, pc->s);
 401   pc++;
 402 }
 403
 404 /* This function removes everything not inside comments starting on
 405    the first char of the line from the  string, also when copying
 406    comments, removes blank space and leading *'s.
 407    Blank lines are turned into one blank line.  */
 408
 409 static void
 410 remove_noncomments (string_type *src, string_type *dst)
 411 {
 412   unsigned int idx = 0;
 413
 414   while (at (src, idx))
 415     {
 416       /* Now see if we have a comment at the start of the line.  */
 417       if (at (src, idx) == '\n'
 418           && at (src, idx + 1) == '/'
 419           && at (src, idx + 2) == '*')
 420         {
 421           idx += 3;
 422
 423           idx = skip_white_and_stars (src, idx);
 424
 425           /* Remove leading dot */
 426           if (at (src, idx) == '.')
 427             idx++;
 428
 429           /* Copy to the end of the line, or till the end of the
 430              comment.  */
 431           while (at (src, idx))
 432             {
 433               if (at (src, idx) == '\n')
 434                 {
 435                   /* end of line, echo and scrape of leading blanks  */
 436                   if (at (src, idx + 1) == '\n')
 437                     catchar (dst, '\n');
 438                   catchar (dst, '\n');
 439                   idx++;
 440                   idx = skip_white_and_stars (src, idx);
 441                 }
 442               else if (at (src, idx) == '*' && at (src, idx + 1) == '/')
 443                 {
 444                   idx += 2;
 445                   cattext (dst, "\nENDDD\n");
 446                   break;
 447                 }
 448               else
 449                 {
 450                   catchar (dst, at (src, idx));
 451                   idx++;
 452                 }
 453             }
 454         }
 455       else
 456         idx++;
 457     }
 458 }
 459
 460 static void
 461 print_stack_level (void)
 462 {
 463   fprintf (stderr, "current string stack depth = %ld, ",
 464            (long) (tos - stack));
 465   fprintf (stderr, "current integer stack depth = %ld\n",
 466            (long) (isp - istack));
 467   pc++;
 468 }
 469
 470 /* turn {*
 471    and *} into comments */
 472
 473 static void
 474 translatecomments (void)
 475 {
 476   unsigned int idx = 0;
 477   string_type out;
 478   init_string (&out);
 479
 480   while (at (tos, idx))
 481     {
 482       if (at (tos, idx) == '{' && at (tos, idx + 1) == '*')
 483         {
 484           cattext (&out, "/*");
 485           idx += 2;
 486         }
 487       else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
 488         {
 489           cattext (&out, "*/");
 490           idx += 2;
 491         }
 492       else
 493         {
 494           catchar (&out, at (tos, idx));
 495           idx++;
 496         }
 497     }
 498
 499   overwrite_string (tos, &out);
 500
 501   pc++;
 502 }
 503
 504 /* Mod tos so that only lines with leading dots remain */
 505 static void
 506 outputdots (void)
 507 {
 508   unsigned int idx = 0;
 509   string_type out;
 510   init_string (&out);
 511
 512   while (at (tos, idx))
 513     {
 514       /* Every iteration begins at the start of a line.  */
 515       if (at (tos, idx) == '.')
 516         {
 517           char c;
 518           int spaces;
 519
 520           idx++;
 521           spaces = 0;
 522           while ((c = at (tos, idx)) && c != '\n')
 523             {
 524               if (spaces >= 0)
 525                 {
 526                   if (c == ' ')
 527                     {
 528                       spaces++;
 529                       idx++;
 530                       continue;
 531                     }
 532                   else
 533                     {
 534                       while (spaces >= 8)
 535                         {
 536                           catchar (&out, '\t');
 537                           spaces -= 8;
 538                         }
 539                       while (spaces-- > 0)
 540                         catchar (&out, ' ');
 541                     }
 542                 }
 543               if (c == '{' && at (tos, idx + 1) == '*')
 544                 {
 545                   cattext (&out, "/*");
 546                   idx += 2;
 547                 }
 548               else if (c == '*' && at (tos, idx + 1) == '}')
 549                 {
 550                   cattext (&out, "*/");
 551                   idx += 2;
 552                 }
 553               else
 554                 {
 555                   catchar (&out, c);
 556                   idx++;
 557                 }
 558             }
 559           if (c == '\n')
 560             idx++;
 561           catchar (&out, '\n');
 562         }
 563       else
 564         {
 565           idx = skip_past_newline_1 (tos, idx);
 566         }
 567     }
 568
 569   overwrite_string (tos, &out);
 570   pc++;
 571 }
 572
 573 /* Find lines starting with . and | and put example around them on tos */
 574 static void
 575 courierize (void)
 576 {
 577   string_type out;
 578   unsigned int idx = 0;
 579   int command = 0;
 580
 581   init_string (&out);
 582
 583   while (at (tos, idx))
 584     {
 585       if (at (tos, idx) == '\n'
 586           && (at (tos, idx +1 ) == '.'
 587               || at (tos, idx + 1) == '|'))
 588         {
 589           cattext (&out, "\n@example\n");
 590           do
 591             {
 592               idx += 2;
 593
 594               while (at (tos, idx) && at (tos, idx) != '\n')
 595                 {
 596                   if (command > 1)
 597                     {
 598                       /* We are inside {} parameters of some command;
 599                          Just pass through until matching brace.  */
 600                       if (at (tos, idx) == '{')
 601                         ++command;
 602                       else if (at (tos, idx) == '}')
 603                         --command;
 604                     }
 605                   else if (command != 0)
 606                     {
 607                       if (at (tos, idx) == '{')
 608                         ++command;
 609                       else if (!islower ((unsigned char) at (tos, idx)))
 610                         --command;
 611                     }
 612                   else if (at (tos, idx) == '@'
 613                            && islower ((unsigned char) at (tos, idx + 1)))
 614                     {
 615                       ++command;
 616                     }
 617                   else if (at (tos, idx) == '{' && at (tos, idx + 1) == '*')
 618                     {
 619                       cattext (&out, "/*");
 620                       idx += 2;
 621                       continue;
 622                     }
 623                   else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
 624                     {
 625                       cattext (&out, "*/");
 626                       idx += 2;
 627                       continue;
 628                     }
 629                   else if (at (tos, idx) == '{'
 630                            || at (tos, idx) == '}')
 631                     {
 632                       catchar (&out, '@');
 633                     }
 634
 635                   catchar (&out, at (tos, idx));
 636                   idx++;
 637                 }
 638               catchar (&out, '\n');
 639             }
 640           while (at (tos, idx) == '\n'
 641                  && ((at (tos, idx + 1) == '.')
 642                      || (at (tos, idx + 1) == '|')))
 643             ;
 644           cattext (&out, "@end example");
 645         }
 646       else
 647         {
 648           catchar (&out, at (tos, idx));
 649           idx++;
 650         }
 651     }
 652
 653   overwrite_string (tos, &out);
 654   pc++;
 655 }
 656
 657 /* Finds any lines starting with "o ", if there are any, then turns
 658    on @itemize @bullet, and @items each of them. Then ends with @end
 659    itemize, inplace at TOS*/
 660
 661 static void
 662 bulletize (void)
 663 {
 664   unsigned int idx = 0;
 665   int on = 0;
 666   string_type out;
 667   init_string (&out);
 668
 669   while (at (tos, idx))
 670     {
 671       if (at (tos, idx) == '@'
 672           && at (tos, idx + 1) == '*')
 673         {
 674           cattext (&out, "*");
 675           idx += 2;
 676         }
 677       else if (at (tos, idx) == '\n'
 678                && at (tos, idx + 1) == 'o'
 679                && isspace ((unsigned char) at (tos, idx + 2)))
 680         {
 681           if (!on)
 682             {
 683               cattext (&out, "\n@itemize @bullet\n");
 684               on = 1;
 685
 686             }
 687           cattext (&out, "\n@item\n");
 688           idx += 3;
 689         }
 690       else
 691         {
 692           catchar (&out, at (tos, idx));
 693           if (on && at (tos, idx) == '\n'
 694               && at (tos, idx + 1) == '\n'
 695               && at (tos, idx + 2) != 'o')
 696             {
 697               cattext (&out, "@end itemize");
 698               on = 0;
 699             }
 700           idx++;
 701
 702         }
 703     }
 704   if (on)
 705     {
 706       cattext (&out, "@end itemize\n");
 707     }
 708
 709   delete_string (tos);
 710   *tos = out;
 711   pc++;
 712 }
 713
 714 /* Turn <<foo>> into @code{foo} in place at TOS*/
 715
 716 static void
 717 do_fancy_stuff (void)
 718 {
 719   unsigned int idx = 0;
 720   string_type out;
 721   init_string (&out);
 722   while (at (tos, idx))
 723     {
 724       if (at (tos, idx) == '<'
 725           && at (tos, idx + 1) == '<'
 726           && !isspace ((unsigned char) at (tos, idx + 2)))
 727         {
 728           /* This qualifies as a << startup.  */
 729           idx += 2;
 730           cattext (&out, "@code{");
 731           while (at (tos, idx)
 732                  && at (tos, idx) != '>' )
 733             {
 734               catchar (&out, at (tos, idx));
 735               idx++;
 736
 737             }
 738           cattext (&out, "}");
 739           idx += 2;
 740         }
 741       else
 742         {
 743           catchar (&out, at (tos, idx));
 744           idx++;
 745         }
 746     }
 747   delete_string (tos);
 748   *tos = out;
 749   pc++;
 750
 751 }
 752
 753 /* A command is all upper case,and alone on a line.  */
 754
 755 static int
 756 iscommand (string_type *ptr, unsigned int idx)
 757 {
 758   unsigned int len = 0;
 759   while (at (ptr, idx))
 760     {
 761       if (isupper ((unsigned char) at (ptr, idx))
 762           || at (ptr, idx) == ' ' || at (ptr, idx) == '_')
 763         {
 764           len++;
 765           idx++;
 766         }
 767       else if (at (ptr, idx) == '\n')
 768         {
 769           if (len > 3)
 770             return 1;
 771           return 0;
 772         }
 773       else
 774         return 0;
 775     }
 776   return 0;
 777 }
 778
 779 static int
 780 copy_past_newline (string_type *ptr, unsigned int idx, string_type *dst)
 781 {
 782   int column = 0;
 783
 784   while (at (ptr, idx) && at (ptr, idx) != '\n')
 785     {
 786       if (at (ptr, idx) == '\t')
 787         {
 788           /* Expand tabs.  Neither makeinfo nor TeX can cope well with
 789              them.  */
 790           do
 791             catchar (dst, ' ');
 792           while (++column & 7);
 793         }
 794       else
 795         {
 796           catchar (dst, at (ptr, idx));
 797           column++;
 798         }
 799       idx++;
 800
 801     }
 802   catchar (dst, at (ptr, idx));
 803   idx++;
 804   return idx;
 805
 806 }
 807
 808 static void
 809 icopy_past_newline (void)
 810 {
 811   tos++;
 812   check_range ();
 813   init_string (tos);
 814   idx = copy_past_newline (ptr, idx, tos);
 815   pc++;
 816 }
 817
 818 static void
 819 kill_bogus_lines (void)
 820 {
 821   int sl;
 822
 823   int idx = 0;
 824   int c;
 825   int dot = 0;
 826
 827   string_type out;
 828   init_string (&out);
 829   /* Drop leading nl.  */
 830   while (at (tos, idx) == '\n')
 831     {
 832       idx++;
 833     }
 834   c = idx;
 835
 836   /* If the first char is a '.' prepend a newline so that it is
 837      recognized properly later.  */
 838   if (at (tos, idx) == '.')
 839     catchar (&out, '\n');
 840
 841   /* Find the last char.  */
 842   while (at (tos, idx))
 843     {
 844       idx++;
 845     }
 846
 847   /* Find the last non white before the nl.  */
 848   idx--;
 849
 850   while (idx && isspace ((unsigned char) at (tos, idx)))
 851     idx--;
 852   idx++;
 853
 854   /* Copy buffer upto last char, but blank lines before and after
 855      dots don't count.  */
 856   sl = 1;
 857
 858   while (c < idx)
 859     {
 860       if (at (tos, c) == '\n'
 861           && at (tos, c + 1) == '\n'
 862           && at (tos, c + 2) == '.')
 863         {
 864           /* Ignore two newlines before a dot.  */
 865           c++;
 866         }
 867       else if (at (tos, c) == '.' && sl)
 868         {
 869           /* remember that this line started with a dot.  */
 870           dot = 2;
 871         }
 872       else if (at (tos, c) == '\n'
 873                && at (tos, c + 1) == '\n'
 874                && dot)
 875         {
 876           c++;
 877           /* Ignore two newlines when last line was dot.  */
 878         }
 879
 880       catchar (&out, at (tos, c));
 881       if (at (tos, c) == '\n')
 882         {
 883           sl = 1;
 884
 885           if (dot == 2)
 886             dot = 1;
 887           else
 888             dot = 0;
 889         }
 890       else
 891         sl = 0;
 892
 893       c++;
 894
 895     }
 896
 897   /* Append nl.  */
 898   catchar (&out, '\n');
 899   pc++;
 900   delete_string (tos);
 901   *tos = out;
 902
 903 }
 904
 905 static void
 906 collapse_whitespace (void)
 907 {
 908   int last_was_ws = 0;
 909   int idx;
 910
 911   string_type out;
 912   init_string (&out);
 913
 914   for (idx = 0; at (tos, idx) != 0; ++idx)
 915     {
 916       char c = at (tos, idx);
 917       if (isspace (c))
 918         {
 919           if (!last_was_ws)
 920             {
 921               catchar (&out, ' ');
 922               last_was_ws = 1;
 923             }
 924         }
 925       else
 926         {
 927           catchar (&out, c);
 928           last_was_ws = 0;
 929         }
 930     }
 931
 932   pc++;
 933   delete_string (tos);
 934   *tos = out;
 935 }
 936
 937 /* indent
 938    Take the string at the top of the stack, do some prettying.  */
 939
 940 static void
 941 indent (void)
 942 {
 943   string_type out;
 944   int tab = 0;
 945   int idx = 0;
 946   int ol = 0;
 947   init_string (&out);
 948   while (at (tos, idx))
 949     {
 950       switch (at (tos, idx))
 951         {
 952         case '\n':
 953           catchar (&out, '\n');
 954           idx++;
 955           if (tab && at (tos, idx))
 956             {
 957               int i;
 958               for (i = 0; i < tab - 1; i += 2)
 959                 catchar (&out, '\t');
 960               if (i < tab)
 961                 cattext (&out, "    ");
 962             }
 963           ol = 0;
 964           break;
 965         case '(':
 966           if (ol == 0)
 967             {
 968               int i;
 969               for (i = 1; i < tab - 1; i += 2)
 970                 catchar (&out, '\t');
 971               if (i < tab)
 972                 cattext (&out, "    ");
 973               cattext (&out, "   ");
 974             }
 975           tab++;
 976           idx++;
 977           catchar (&out, '(');
 978           ol = 1;
 979           break;
 980         case ')':
 981           tab--;
 982           catchar (&out, ')');
 983           idx++;
 984           ol = 1;
 985           break;
 986         default:
 987           catchar (&out, at (tos, idx));
 988           ol = 1;
 989           idx++;
 990           break;
 991         }
 992     }
 993
 994   pc++;
 995   delete_string (tos);
 996   *tos = out;
 997
 998 }
 999
1000 static void
1001 get_stuff_in_command (void)
1002 {
1003   tos++;
1004   check_range ();
1005   init_string (tos);
1006
1007   while (at (ptr, idx))
1008     {
1009       if (iscommand (ptr, idx))
1010         break;
1011       idx = copy_past_newline (ptr, idx, tos);
1012     }
1013   pc++;
1014 }
1015
1016 static void
1017 swap (void)
1018 {
1019   string_type t;
1020
1021   t = tos[0];
1022   tos[0] = tos[-1];
1023   tos[-1] = t;
1024   pc++;
1025 }
1026
1027 static void
1028 other_dup (void)
1029 {
1030   tos++;
1031   check_range ();
1032   init_string (tos);
1033   catstr (tos, tos - 1);
1034   pc++;
1035 }
1036
1037 static void
1038 drop (void)
1039 {
1040   tos--;
1041   check_range ();
1042   delete_string (tos + 1);
1043   pc++;
1044 }
1045
1046 static void
1047 idrop (void)
1048 {
1049   isp--;
1050   icheck_range ();
1051   pc++;
1052 }
1053
1054 static void
1055 icatstr (void)
1056 {
1057   tos--;
1058   check_range ();
1059   catstr (tos, tos + 1);
1060   delete_string (tos + 1);
1061   pc++;
1062 }
1063
1064 static void
1065 skip_past_newline (void)
1066 {
1067   idx = skip_past_newline_1 (ptr, idx);
1068   pc++;
1069 }
1070
1071 static void
1072 maybecatstr (void)
1073 {
1074   if (internal_wanted == *internal_mode)
1075     {
1076       catstr (tos - 1, tos);
1077     }
1078   delete_string (tos);
1079   tos--;
1080   check_range ();
1081   pc++;
1082 }
1083
1084 static void
1085 catstrif (void)
1086 {
1087   int cond = isp[0];
1088   isp--;
1089   icheck_range ();
1090   if (cond)
1091     catstr (tos - 1, tos);
1092   delete_string (tos);
1093   tos--;
1094   check_range ();
1095   pc++;
1096 }
1097
1098 char *
1099 nextword (char *string, char **word)
1100 {
1101   char *word_start;
1102   int idx;
1103   char *dst;
1104   char *src;
1105
1106   int length = 0;
1107
1108   while (isspace ((unsigned char) *string) || *string == '-')
1109     {
1110       if (*string == '-')
1111         {
1112           while (*string && *string != '\n')
1113             string++;
1114
1115         }
1116       else
1117         {
1118           string++;
1119         }
1120     }
1121   if (!*string)
1122     {
1123       *word = NULL;
1124       return NULL;
1125     }
1126
1127   word_start = string;
1128   if (*string == '"')
1129     {
1130       do
1131         {
1132           string++;
1133           length++;
1134           if (*string == '\\')
1135             {
1136               string += 2;
1137               length += 2;
1138             }
1139         }
1140       while (*string != '"');
1141     }
1142   else
1143     {
1144       while (!isspace ((unsigned char) *string))
1145         {
1146           string++;
1147           length++;
1148
1149         }
1150     }
1151
1152   *word = xmalloc (length + 1);
1153
1154   dst = *word;
1155   src = word_start;
1156
1157   for (idx = 0; idx < length; idx++)
1158     {
1159       if (src[idx] == '\\')
1160         switch (src[idx + 1])
1161           {
1162           case 'n':
1163             *dst++ = '\n';
1164             idx++;
1165             break;
1166           case '"':
1167           case '\\':
1168             *dst++ = src[idx + 1];
1169             idx++;
1170             break;
1171           default:
1172             *dst++ = '\\';
1173             break;
1174           }
1175       else
1176         *dst++ = src[idx];
1177     }
1178   *dst++ = 0;
1179
1180   if (*string)
1181     return string + 1;
1182   else
1183     return NULL;
1184 }
1185
1186 dict_type *
1187 lookup_word (char *word)
1188 {
1189   dict_type *ptr = root;
1190   while (ptr)
1191     {
1192       if (strcmp (ptr->word, word) == 0)
1193         return ptr;
1194       ptr = ptr->next;
1195     }
1196   if (warning)
1197     fprintf (stderr, "Can't find %s\n", word);
1198   return NULL;
1199 }
1200
1201 static void
1202 free_words (void)
1203 {
1204   dict_type *ptr = root;
1205
1206   while (ptr)
1207     {
1208       dict_type *next;
1209
1210       free (ptr->word);
1211       if (ptr->code)
1212         {
1213           int i;
1214           for (i = 0; i < ptr->code_end - 1; i ++)
1215             if (ptr->code[i].f == push_text
1216                 && ptr->code[i + 1].s)
1217               {
1218                 free (ptr->code[i + 1].s - 1);
1219                 ++i;
1220               }
1221             else if (ptr->code[i].f == push_variable)
1222               {
1223                 free ((void *) ptr->code[i + 1].l);
1224                 ++i;
1225               }
1226           free (ptr->code);
1227         }
1228       next = ptr->next;
1229       free (ptr);
1230       ptr = next;
1231     }
1232 }
1233
1234 static void
1235 perform (void)
1236 {
1237   tos = stack;
1238
1239   while (at (ptr, idx))
1240     {
1241       /* It's worth looking through the command list.  */
1242       if (iscommand (ptr, idx))
1243         {
1244           char *next;
1245           dict_type *word;
1246
1247           (void) nextword (addr (ptr, idx), &next);
1248
1249           word = lookup_word (next);
1250
1251           if (word)
1252             {
1253               exec (word);
1254             }
1255           else
1256             {
1257               if (warning)
1258                 fprintf (stderr, "warning, %s is not recognised\n", next);
1259               idx = skip_past_newline_1 (ptr, idx);
1260             }
1261           free (next);
1262         }
1263       else
1264         idx = skip_past_newline_1 (ptr, idx);
1265     }
1266 }
1267
1268 dict_type *
1269 newentry (char *word)
1270 {
1271   dict_type *new_d = xmalloc (sizeof (*new_d));
1272   new_d->word = word;
1273   new_d->next = root;
1274   root = new_d;
1275   new_d->code = xmalloc (sizeof (*new_d->code));
1276   new_d->code_length = 1;
1277   new_d->code_end = 0;
1278   return new_d;
1279 }
1280
1281 unsigned int
1282 add_to_definition (dict_type *entry, pcu word)
1283 {
1284   if (entry->code_end == entry->code_length)
1285     {
1286       entry->code_length += 2;
1287       entry->code = xrealloc (entry->code,
1288                               entry->code_length * sizeof (*entry->code));
1289     }
1290   entry->code[entry->code_end] = word;
1291
1292   return entry->code_end++;
1293 }
1294
1295 void
1296 add_intrinsic (char *name, void (*func) (void))
1297 {
1298   dict_type *new_d = newentry (xstrdup (name));
1299   pcu p = { func };
1300   add_to_definition (new_d, p);
1301   p.f = 0;
1302   add_to_definition (new_d, p);
1303 }
1304
1305 static void
1306 add_variable (char *name, intptr_t *loc)
1307 {
1308   dict_type *new_d = newentry (name);
1309   pcu p = { push_variable };
1310   add_to_definition (new_d, p);
1311   p.l = (intptr_t) loc;
1312   add_to_definition (new_d, p);
1313   p.f = 0;
1314   add_to_definition (new_d, p);
1315 }
1316
1317 static void
1318 add_intrinsic_variable (const char *name, intptr_t *loc)
1319 {
1320   add_variable (xstrdup (name), loc);
1321 }
1322
1323 void
1324 compile (char *string)
1325 {
1326   /* Add words to the dictionary.  */
1327   char *word;
1328
1329   string = nextword (string, &word);
1330   while (string && *string && word[0])
1331     {
1332       if (word[0] == ':')
1333         {
1334           dict_type *ptr;
1335           pcu p;
1336
1337           /* Compile a word and add to dictionary.  */
1338           free (word);
1339           string = nextword (string, &word);
1340           if (!string)
1341             continue;
1342           ptr = newentry (word);
1343           string = nextword (string, &word);
1344           if (!string)
1345             {
1346               free (ptr->code);
1347               free (ptr);
1348               continue;
1349             }
1350
1351           while (word[0] != ';')
1352             {
1353               switch (word[0])
1354                 {
1355                 case '"':
1356                   /* got a string, embed magic push string
1357                      function */
1358                   p.f = push_text;
1359                   add_to_definition (ptr, p);
1360                   p.s = word + 1;
1361                   add_to_definition (ptr, p);
1362                   break;
1363                 case '0':
1364                 case '1':
1365                 case '2':
1366                 case '3':
1367                 case '4':
1368                 case '5':
1369                 case '6':
1370                 case '7':
1371                 case '8':
1372                 case '9':
1373                   /* Got a number, embedd the magic push number
1374                      function */
1375                   p.f = push_number;
1376                   add_to_definition (ptr, p);
1377                   p.l = atol (word);
1378                   add_to_definition (ptr, p);
1379                   free (word);
1380                   break;
1381                 default:
1382                   p.f = call;
1383                   add_to_definition (ptr, p);
1384                   p.e = lookup_word (word);
1385                   add_to_definition (ptr, p);
1386                   free (word);
1387                 }
1388
1389               string = nextword (string, &word);
1390             }
1391           p.f = 0;
1392           add_to_definition (ptr, p);
1393           free (word);
1394           string = nextword (string, &word);
1395         }
1396       else if (strcmp (word, "variable") == 0)
1397         {
1398           free (word);
1399           string = nextword (string, &word);
1400           if (!string)
1401             continue;
1402           intptr_t *loc = xmalloc (sizeof (intptr_t));
1403           *loc = 0;
1404           add_variable (word, loc);
1405           string = nextword (string, &word);
1406         }
1407       else
1408         {
1409           fprintf (stderr, "syntax error at %s\n", string - 1);
1410         }
1411     }
1412   free (word);
1413 }
1414
1415 static void
1416 bang (void)
1417 {
1418   *(intptr_t *) ((isp[0])) = isp[-1];
1419   isp -= 2;
1420   icheck_range ();
1421   pc++;
1422 }
1423
1424 static void
1425 atsign (void)
1426 {
1427   isp[0] = *(intptr_t *) (isp[0]);
1428   pc++;
1429 }
1430
1431 static void
1432 hello (void)
1433 {
1434   printf ("hello\n");
1435   pc++;
1436 }
1437
1438 static void
1439 stdout_ (void)
1440 {
1441   isp++;
1442   icheck_range ();
1443   *isp = 1;
1444   pc++;
1445 }
1446
1447 static void
1448 stderr_ (void)
1449 {
1450   isp++;
1451   icheck_range ();
1452   *isp = 2;
1453   pc++;
1454 }
1455
1456 static void
1457 print (void)
1458 {
1459   if (*isp == 1)
1460     write_buffer (tos, stdout);
1461   else if (*isp == 2)
1462     write_buffer (tos, stderr);
1463   else
1464     fprintf (stderr, "print: illegal print destination `%" PRIdPTR "'\n", *isp);
1465   isp--;
1466   tos--;
1467   icheck_range ();
1468   check_range ();
1469   pc++;
1470 }
1471
1472 static void
1473 read_in (string_type *str, FILE *file)
1474 {
1475   char buff[10000];
1476   unsigned int r;
1477   do
1478     {
1479       r = fread (buff, 1, sizeof (buff), file);
1480       catbuf (str, buff, r);
1481     }
1482   while (r);
1483   buff[0] = 0;
1484
1485   catbuf (str, buff, 1);
1486 }
1487
1488 static void
1489 usage (void)
1490 {
1491   fprintf (stderr, "usage: -[d|i|g] <file >file\n");
1492   exit (33);
1493 }
1494
1495 /* There is no reliable way to declare exit.  Sometimes it returns
1496    int, and sometimes it returns void.  Sometimes it changes between
1497    OS releases.  Trying to get it declared correctly in the hosts file
1498    is a pointless waste of time.  */
1499
1500 static void
1501 chew_exit (void)
1502 {
1503   exit (0);
1504 }
1505
1506 int
1507 main (int ac, char *av[])
1508 {
1509   unsigned int i;
1510   string_type buffer;
1511   string_type pptr;
1512
1513   init_string (&buffer);
1514   init_string (&pptr);
1515   init_string (stack + 0);
1516   tos = stack + 1;
1517   ptr = &pptr;
1518
1519   add_intrinsic ("push_text", push_text);
1520   add_intrinsic ("!", bang);
1521   add_intrinsic ("@", atsign);
1522   add_intrinsic ("hello", hello);
1523   add_intrinsic ("stdout", stdout_);
1524   add_intrinsic ("stderr", stderr_);
1525   add_intrinsic ("print", print);
1526   add_intrinsic ("skip_past_newline", skip_past_newline);
1527   add_intrinsic ("catstr", icatstr);
1528   add_intrinsic ("copy_past_newline", icopy_past_newline);
1529   add_intrinsic ("dup", other_dup);
1530   add_intrinsic ("drop", drop);
1531   add_intrinsic ("idrop", idrop);
1532   add_intrinsic ("remchar", remchar);
1533   add_intrinsic ("get_stuff_in_command", get_stuff_in_command);
1534   add_intrinsic ("do_fancy_stuff", do_fancy_stuff);
1535   add_intrinsic ("bulletize", bulletize);
1536   add_intrinsic ("courierize", courierize);
1537   /* If the following line gives an error, exit() is not declared in the
1538      ../hosts/foo.h file for this host.  Fix it there, not here!  */
1539   /* No, don't fix it anywhere; see comment on chew_exit--Ian Taylor.  */
1540   add_intrinsic ("exit", chew_exit);
1541   add_intrinsic ("swap", swap);
1542   add_intrinsic ("outputdots", outputdots);
1543   add_intrinsic ("maybecatstr", maybecatstr);
1544   add_intrinsic ("catstrif", catstrif);
1545   add_intrinsic ("translatecomments", translatecomments);
1546   add_intrinsic ("kill_bogus_lines", kill_bogus_lines);
1547   add_intrinsic ("indent", indent);
1548   add_intrinsic ("print_stack_level", print_stack_level);
1549   add_intrinsic ("strip_trailing_newlines", strip_trailing_newlines);
1550   add_intrinsic ("collapse_whitespace", collapse_whitespace);
1551
1552   internal_mode = xmalloc (sizeof (intptr_t));
1553   *internal_mode = 0;
1554   add_intrinsic_variable ("internalmode", internal_mode);
1555
1556   /* Put a nl at the start.  */
1557   catchar (&buffer, '\n');
1558
1559   read_in (&buffer, stdin);
1560   remove_noncomments (&buffer, ptr);
1561   for (i = 1; i < (unsigned int) ac; i++)
1562     {
1563       if (av[i][0] == '-')
1564         {
1565           if (av[i][1] == 'f')
1566             {
1567               string_type b;
1568               FILE *f;
1569               init_string (&b);
1570
1571               f = fopen (av[i + 1], "r");
1572               if (!f)
1573                 {
1574                   fprintf (stderr, "Can't open the input file %s\n",
1575                            av[i + 1]);
1576                   return 33;
1577                 }
1578
1579               read_in (&b, f);
1580               compile (b.ptr);
1581               perform ();
1582               delete_string (&b);
1583             }
1584           else if (av[i][1] == 'i')
1585             {
1586               internal_wanted = 1;
1587             }
1588           else if (av[i][1] == 'w')
1589             {
1590               warning = 1;
1591             }
1592           else
1593             usage ();
1594         }
1595     }
1596   write_buffer (stack + 0, stdout);
1597   free_words ();
1598   delete_string (&pptr);
1599   delete_string (&buffer);
1600   if (tos != stack)
1601     {
1602       fprintf (stderr, "finishing with current stack level %ld\n",
1603                (long) (tos - stack));
1604       return 1;
1605     }
1606   return 0;
1607 }