1606 lines
30 KiB
C
1606 lines
30 KiB
C
/* chew
|
|
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001,
|
|
2002, 2003
|
|
Free Software Foundation, Inc.
|
|
Contributed by steve chamberlain @cygnus
|
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|
|
|
/* Yet another way of extracting documentation from source.
|
|
No, I haven't finished it yet, but I hope you people like it better
|
|
than the old way
|
|
|
|
sac
|
|
|
|
Basically, this is a sort of string forth, maybe we should call it
|
|
struth?
|
|
|
|
You define new words thus:
|
|
: <newword> <oldwords> ;
|
|
|
|
*/
|
|
|
|
/* Primitives provided by the program:
|
|
|
|
Two stacks are provided, a string stack and an integer stack.
|
|
|
|
Internal state variables:
|
|
internal_wanted - indicates whether `-i' was passed
|
|
internal_mode - user-settable
|
|
|
|
Commands:
|
|
push_text
|
|
! - pop top of integer stack for address, pop next for value; store
|
|
@ - treat value on integer stack as the address of an integer; push
|
|
that integer on the integer stack after popping the "address"
|
|
hello - print "hello\n" to stdout
|
|
stdout - put stdout marker on TOS
|
|
stderr - put stderr marker on TOS
|
|
print - print TOS-1 on TOS (eg: "hello\n" stdout print)
|
|
skip_past_newline
|
|
catstr - fn icatstr
|
|
copy_past_newline - append input, up to and including newline into TOS
|
|
dup - fn other_dup
|
|
drop - discard TOS
|
|
idrop - ditto
|
|
remchar - delete last character from TOS
|
|
get_stuff_in_command
|
|
do_fancy_stuff - translate <<foo>> to @code{foo} in TOS
|
|
bulletize - if "o" lines found, prepend @itemize @bullet to TOS
|
|
and @item to each "o" line; append @end itemize
|
|
courierize - put @example around . and | lines, translate {* *} { }
|
|
exit - fn chew_exit
|
|
swap
|
|
outputdots - strip out lines without leading dots
|
|
paramstuff - convert full declaration into "PARAMS" form if not already
|
|
maybecatstr - do catstr if internal_mode == internal_wanted, discard
|
|
value in any case
|
|
translatecomments - turn {* and *} into comment delimiters
|
|
kill_bogus_lines - get rid of extra newlines
|
|
indent
|
|
internalmode - pop from integer stack, set `internalmode' to that value
|
|
print_stack_level - print current stack depth to stderr
|
|
strip_trailing_newlines - go ahead, guess...
|
|
[quoted string] - push string onto string stack
|
|
[word starting with digit] - push atol(str) onto integer stack
|
|
|
|
A command must be all upper-case, and alone on a line.
|
|
|
|
Foo. */
|
|
|
|
#include "ansidecl.h"
|
|
#include "sysdep.h"
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
#define DEF_SIZE 5000
|
|
#define STACK 50
|
|
|
|
int internal_wanted;
|
|
int internal_mode;
|
|
|
|
int warning;
|
|
|
|
/* Here is a string type ... */
|
|
|
|
typedef struct buffer
|
|
{
|
|
char *ptr;
|
|
unsigned long write_idx;
|
|
unsigned long size;
|
|
} string_type;
|
|
|
|
#ifdef __STDC__
|
|
static void init_string_with_size (string_type *, unsigned int);
|
|
static void init_string (string_type *);
|
|
static int find (string_type *, char *);
|
|
static void write_buffer (string_type *, FILE *);
|
|
static void delete_string (string_type *);
|
|
static char *addr (string_type *, unsigned int);
|
|
static char at (string_type *, unsigned int);
|
|
static void catchar (string_type *, int);
|
|
static void overwrite_string (string_type *, string_type *);
|
|
static void catbuf (string_type *, char *, unsigned int);
|
|
static void cattext (string_type *, char *);
|
|
static void catstr (string_type *, string_type *);
|
|
#endif
|
|
|
|
static void
|
|
init_string_with_size (buffer, size)
|
|
string_type *buffer;
|
|
unsigned int size;
|
|
{
|
|
buffer->write_idx = 0;
|
|
buffer->size = size;
|
|
buffer->ptr = malloc (size);
|
|
}
|
|
|
|
static void
|
|
init_string (buffer)
|
|
string_type *buffer;
|
|
{
|
|
init_string_with_size (buffer, DEF_SIZE);
|
|
}
|
|
|
|
static int
|
|
find (str, what)
|
|
string_type *str;
|
|
char *what;
|
|
{
|
|
unsigned int i;
|
|
char *p;
|
|
p = what;
|
|
for (i = 0; i < str->write_idx && *p; i++)
|
|
{
|
|
if (*p == str->ptr[i])
|
|
p++;
|
|
else
|
|
p = what;
|
|
}
|
|
return (*p == 0);
|
|
}
|
|
|
|
static void
|
|
write_buffer (buffer, f)
|
|
string_type *buffer;
|
|
FILE *f;
|
|
{
|
|
fwrite (buffer->ptr, buffer->write_idx, 1, f);
|
|
}
|
|
|
|
static void
|
|
delete_string (buffer)
|
|
string_type *buffer;
|
|
{
|
|
free (buffer->ptr);
|
|
}
|
|
|
|
static char *
|
|
addr (buffer, idx)
|
|
string_type *buffer;
|
|
unsigned int idx;
|
|
{
|
|
return buffer->ptr + idx;
|
|
}
|
|
|
|
static char
|
|
at (buffer, pos)
|
|
string_type *buffer;
|
|
unsigned int pos;
|
|
{
|
|
if (pos >= buffer->write_idx)
|
|
return 0;
|
|
return buffer->ptr[pos];
|
|
}
|
|
|
|
static void
|
|
catchar (buffer, ch)
|
|
string_type *buffer;
|
|
int ch;
|
|
{
|
|
if (buffer->write_idx == buffer->size)
|
|
{
|
|
buffer->size *= 2;
|
|
buffer->ptr = realloc (buffer->ptr, buffer->size);
|
|
}
|
|
|
|
buffer->ptr[buffer->write_idx++] = ch;
|
|
}
|
|
|
|
static void
|
|
overwrite_string (dst, src)
|
|
string_type *dst;
|
|
string_type *src;
|
|
{
|
|
free (dst->ptr);
|
|
dst->size = src->size;
|
|
dst->write_idx = src->write_idx;
|
|
dst->ptr = src->ptr;
|
|
}
|
|
|
|
static void
|
|
catbuf (buffer, buf, len)
|
|
string_type *buffer;
|
|
char *buf;
|
|
unsigned int len;
|
|
{
|
|
if (buffer->write_idx + len >= buffer->size)
|
|
{
|
|
while (buffer->write_idx + len >= buffer->size)
|
|
buffer->size *= 2;
|
|
buffer->ptr = realloc (buffer->ptr, buffer->size);
|
|
}
|
|
memcpy (buffer->ptr + buffer->write_idx, buf, len);
|
|
buffer->write_idx += len;
|
|
}
|
|
|
|
static void
|
|
cattext (buffer, string)
|
|
string_type *buffer;
|
|
char *string;
|
|
{
|
|
catbuf (buffer, string, (unsigned int) strlen (string));
|
|
}
|
|
|
|
static void
|
|
catstr (dst, src)
|
|
string_type *dst;
|
|
string_type *src;
|
|
{
|
|
catbuf (dst, src->ptr, src->write_idx);
|
|
}
|
|
|
|
static unsigned int
|
|
skip_white_and_stars (src, idx)
|
|
string_type *src;
|
|
unsigned int idx;
|
|
{
|
|
char c;
|
|
while ((c = at (src, idx)),
|
|
isspace ((unsigned char) c)
|
|
|| (c == '*'
|
|
/* Don't skip past end-of-comment or star as first
|
|
character on its line. */
|
|
&& at (src, idx +1) != '/'
|
|
&& at (src, idx -1) != '\n'))
|
|
idx++;
|
|
return idx;
|
|
}
|
|
|
|
/***********************************************************************/
|
|
|
|
string_type stack[STACK];
|
|
string_type *tos;
|
|
|
|
unsigned int idx = 0; /* Pos in input buffer */
|
|
string_type *ptr; /* and the buffer */
|
|
typedef void (*stinst_type)();
|
|
stinst_type *pc;
|
|
stinst_type sstack[STACK];
|
|
stinst_type *ssp = &sstack[0];
|
|
long istack[STACK];
|
|
long *isp = &istack[0];
|
|
|
|
typedef int *word_type;
|
|
|
|
struct dict_struct
|
|
{
|
|
char *word;
|
|
struct dict_struct *next;
|
|
stinst_type *code;
|
|
int code_length;
|
|
int code_end;
|
|
int var;
|
|
};
|
|
|
|
typedef struct dict_struct dict_type;
|
|
|
|
static void
|
|
die (msg)
|
|
char *msg;
|
|
{
|
|
fprintf (stderr, "%s\n", msg);
|
|
exit (1);
|
|
}
|
|
|
|
static void
|
|
check_range ()
|
|
{
|
|
if (tos < stack)
|
|
die ("underflow in string stack");
|
|
if (tos >= stack + STACK)
|
|
die ("overflow in string stack");
|
|
}
|
|
|
|
static void
|
|
icheck_range ()
|
|
{
|
|
if (isp < istack)
|
|
die ("underflow in integer stack");
|
|
if (isp >= istack + STACK)
|
|
die ("overflow in integer stack");
|
|
}
|
|
|
|
#ifdef __STDC__
|
|
static void exec (dict_type *);
|
|
static void call (void);
|
|
static void remchar (void), strip_trailing_newlines (void), push_number (void);
|
|
static void push_text (void);
|
|
static void remove_noncomments (string_type *, string_type *);
|
|
static void print_stack_level (void);
|
|
static void paramstuff (void), translatecomments (void);
|
|
static void outputdots (void), courierize (void), bulletize (void);
|
|
static void do_fancy_stuff (void);
|
|
static int iscommand (string_type *, unsigned int);
|
|
static int copy_past_newline (string_type *, unsigned int, string_type *);
|
|
static void icopy_past_newline (void), kill_bogus_lines (void), indent (void);
|
|
static void get_stuff_in_command (void), swap (void), other_dup (void);
|
|
static void drop (void), idrop (void);
|
|
static void icatstr (void), skip_past_newline (void), internalmode (void);
|
|
static void maybecatstr (void);
|
|
static char *nextword (char *, char **);
|
|
dict_type *lookup_word (char *);
|
|
static void perform (void);
|
|
dict_type *newentry (char *);
|
|
unsigned int add_to_definition (dict_type *, stinst_type);
|
|
void add_intrinsic (char *, void (*)());
|
|
void add_var (char *);
|
|
void compile (char *);
|
|
static void bang (void);
|
|
static void atsign (void);
|
|
static void hello (void);
|
|
static void stdout_ (void);
|
|
static void stderr_ (void);
|
|
static void print (void);
|
|
static void read_in (string_type *, FILE *);
|
|
static void usage (void);
|
|
static void chew_exit (void);
|
|
#endif
|
|
|
|
static void
|
|
exec (word)
|
|
dict_type *word;
|
|
{
|
|
pc = word->code;
|
|
while (*pc)
|
|
(*pc) ();
|
|
}
|
|
|
|
static void
|
|
call ()
|
|
{
|
|
stinst_type *oldpc = pc;
|
|
dict_type *e;
|
|
e = (dict_type *) (pc[1]);
|
|
exec (e);
|
|
pc = oldpc + 2;
|
|
}
|
|
|
|
static void
|
|
remchar ()
|
|
{
|
|
if (tos->write_idx)
|
|
tos->write_idx--;
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
strip_trailing_newlines ()
|
|
{
|
|
while ((isspace ((unsigned char) at (tos, tos->write_idx - 1))
|
|
|| at (tos, tos->write_idx - 1) == '\n')
|
|
&& tos->write_idx > 0)
|
|
tos->write_idx--;
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
push_number ()
|
|
{
|
|
isp++;
|
|
icheck_range ();
|
|
pc++;
|
|
*isp = (long) (*pc);
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
push_text ()
|
|
{
|
|
tos++;
|
|
check_range ();
|
|
init_string (tos);
|
|
pc++;
|
|
cattext (tos, *((char **) pc));
|
|
pc++;
|
|
}
|
|
|
|
/* This function removes everything not inside comments starting on
|
|
the first char of the line from the string, also when copying
|
|
comments, removes blank space and leading *'s.
|
|
Blank lines are turned into one blank line. */
|
|
|
|
static void
|
|
remove_noncomments (src, dst)
|
|
string_type *src;
|
|
string_type *dst;
|
|
{
|
|
unsigned int idx = 0;
|
|
|
|
while (at (src, idx))
|
|
{
|
|
/* Now see if we have a comment at the start of the line. */
|
|
if (at (src, idx) == '\n'
|
|
&& at (src, idx + 1) == '/'
|
|
&& at (src, idx + 2) == '*')
|
|
{
|
|
idx += 3;
|
|
|
|
idx = skip_white_and_stars (src, idx);
|
|
|
|
/* Remove leading dot */
|
|
if (at (src, idx) == '.')
|
|
idx++;
|
|
|
|
/* Copy to the end of the line, or till the end of the
|
|
comment. */
|
|
while (at (src, idx))
|
|
{
|
|
if (at (src, idx) == '\n')
|
|
{
|
|
/* end of line, echo and scrape of leading blanks */
|
|
if (at (src, idx + 1) == '\n')
|
|
catchar (dst, '\n');
|
|
catchar (dst, '\n');
|
|
idx++;
|
|
idx = skip_white_and_stars (src, idx);
|
|
}
|
|
else if (at (src, idx) == '*' && at (src, idx + 1) == '/')
|
|
{
|
|
idx += 2;
|
|
cattext (dst, "\nENDDD\n");
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
catchar (dst, at (src, idx));
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_stack_level ()
|
|
{
|
|
fprintf (stderr, "current string stack depth = %d, ", tos - stack);
|
|
fprintf (stderr, "current integer stack depth = %d\n", isp - istack);
|
|
pc++;
|
|
}
|
|
|
|
/* turn:
|
|
foobar name(stuff);
|
|
into:
|
|
foobar
|
|
name PARAMS ((stuff));
|
|
and a blank line.
|
|
*/
|
|
|
|
static void
|
|
paramstuff ()
|
|
{
|
|
unsigned int openp;
|
|
unsigned int fname;
|
|
unsigned int idx;
|
|
unsigned int len;
|
|
string_type out;
|
|
init_string (&out);
|
|
|
|
#define NO_PARAMS 1
|
|
|
|
/* Make sure that it's not already param'd or proto'd. */
|
|
if (NO_PARAMS
|
|
|| find (tos, "PARAMS") || find (tos, "PROTO") || !find (tos, "("))
|
|
{
|
|
catstr (&out, tos);
|
|
}
|
|
else
|
|
{
|
|
/* Find the open paren. */
|
|
for (openp = 0; at (tos, openp) != '(' && at (tos, openp); openp++)
|
|
;
|
|
|
|
fname = openp;
|
|
/* Step back to the fname. */
|
|
fname--;
|
|
while (fname && isspace ((unsigned char) at (tos, fname)))
|
|
fname--;
|
|
while (fname
|
|
&& !isspace ((unsigned char) at (tos,fname))
|
|
&& at (tos,fname) != '*')
|
|
fname--;
|
|
|
|
fname++;
|
|
|
|
/* Output type, omitting trailing whitespace character(s), if
|
|
any. */
|
|
for (len = fname; 0 < len; len--)
|
|
{
|
|
if (!isspace ((unsigned char) at (tos, len - 1)))
|
|
break;
|
|
}
|
|
for (idx = 0; idx < len; idx++)
|
|
catchar (&out, at (tos, idx));
|
|
|
|
cattext (&out, "\n"); /* Insert a newline between type and fnname */
|
|
|
|
/* Output function name, omitting trailing whitespace
|
|
character(s), if any. */
|
|
for (len = openp; 0 < len; len--)
|
|
{
|
|
if (!isspace ((unsigned char) at (tos, len - 1)))
|
|
break;
|
|
}
|
|
for (idx = fname; idx < len; idx++)
|
|
catchar (&out, at (tos, idx));
|
|
|
|
cattext (&out, " PARAMS (");
|
|
|
|
for (idx = openp; at (tos, idx) && at (tos, idx) != ';'; idx++)
|
|
catchar (&out, at (tos, idx));
|
|
|
|
cattext (&out, ");\n\n");
|
|
}
|
|
overwrite_string (tos, &out);
|
|
pc++;
|
|
|
|
}
|
|
|
|
/* turn {*
|
|
and *} into comments */
|
|
|
|
static void
|
|
translatecomments ()
|
|
{
|
|
unsigned int idx = 0;
|
|
string_type out;
|
|
init_string (&out);
|
|
|
|
while (at (tos, idx))
|
|
{
|
|
if (at (tos, idx) == '{' && at (tos, idx + 1) == '*')
|
|
{
|
|
cattext (&out, "/*");
|
|
idx += 2;
|
|
}
|
|
else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
|
|
{
|
|
cattext (&out, "*/");
|
|
idx += 2;
|
|
}
|
|
else
|
|
{
|
|
catchar (&out, at (tos, idx));
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
overwrite_string (tos, &out);
|
|
|
|
pc++;
|
|
}
|
|
|
|
#if 0
|
|
|
|
/* This is not currently used. */
|
|
|
|
/* turn everything not starting with a . into a comment */
|
|
|
|
static void
|
|
manglecomments ()
|
|
{
|
|
unsigned int idx = 0;
|
|
string_type out;
|
|
init_string (&out);
|
|
|
|
while (at (tos, idx))
|
|
{
|
|
if (at (tos, idx) == '\n' && at (tos, idx + 1) == '*')
|
|
{
|
|
cattext (&out, " /*");
|
|
idx += 2;
|
|
}
|
|
else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
|
|
{
|
|
cattext (&out, "*/");
|
|
idx += 2;
|
|
}
|
|
else
|
|
{
|
|
catchar (&out, at (tos, idx));
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
overwrite_string (tos, &out);
|
|
|
|
pc++;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Mod tos so that only lines with leading dots remain */
|
|
static void
|
|
outputdots ()
|
|
{
|
|
unsigned int idx = 0;
|
|
string_type out;
|
|
init_string (&out);
|
|
|
|
while (at (tos, idx))
|
|
{
|
|
if (at (tos, idx) == '\n' && at (tos, idx + 1) == '.')
|
|
{
|
|
char c;
|
|
idx += 2;
|
|
|
|
while ((c = at (tos, idx)) && c != '\n')
|
|
{
|
|
if (c == '{' && at (tos, idx + 1) == '*')
|
|
{
|
|
cattext (&out, "/*");
|
|
idx += 2;
|
|
}
|
|
else if (c == '*' && at (tos, idx + 1) == '}')
|
|
{
|
|
cattext (&out, "*/");
|
|
idx += 2;
|
|
}
|
|
else
|
|
{
|
|
catchar (&out, c);
|
|
idx++;
|
|
}
|
|
}
|
|
catchar (&out, '\n');
|
|
}
|
|
else
|
|
{
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
overwrite_string (tos, &out);
|
|
pc++;
|
|
}
|
|
|
|
/* Find lines starting with . and | and put example around them on tos */
|
|
static void
|
|
courierize ()
|
|
{
|
|
string_type out;
|
|
unsigned int idx = 0;
|
|
int command = 0;
|
|
|
|
init_string (&out);
|
|
|
|
while (at (tos, idx))
|
|
{
|
|
if (at (tos, idx) == '\n'
|
|
&& (at (tos, idx +1 ) == '.'
|
|
|| at (tos, idx + 1) == '|'))
|
|
{
|
|
cattext (&out, "\n@example\n");
|
|
do
|
|
{
|
|
idx += 2;
|
|
|
|
while (at (tos, idx) && at (tos, idx) != '\n')
|
|
{
|
|
if (command > 1)
|
|
{
|
|
/* We are inside {} parameters of some command;
|
|
Just pass through until matching brace. */
|
|
if (at (tos, idx) == '{')
|
|
++command;
|
|
else if (at (tos, idx) == '}')
|
|
--command;
|
|
}
|
|
else if (command != 0)
|
|
{
|
|
if (at (tos, idx) == '{')
|
|
++command;
|
|
else if (!islower ((unsigned char) at (tos, idx)))
|
|
--command;
|
|
}
|
|
else if (at (tos, idx) == '@'
|
|
&& islower ((unsigned char) at (tos, idx + 1)))
|
|
{
|
|
++command;
|
|
}
|
|
else if (at (tos, idx) == '{' && at (tos, idx + 1) == '*')
|
|
{
|
|
cattext (&out, "/*");
|
|
idx += 2;
|
|
continue;
|
|
}
|
|
else if (at (tos, idx) == '*' && at (tos, idx + 1) == '}')
|
|
{
|
|
cattext (&out, "*/");
|
|
idx += 2;
|
|
continue;
|
|
}
|
|
else if (at (tos, idx) == '{'
|
|
|| at (tos, idx) == '}')
|
|
{
|
|
catchar (&out, '@');
|
|
}
|
|
|
|
catchar (&out, at (tos, idx));
|
|
idx++;
|
|
}
|
|
catchar (&out, '\n');
|
|
}
|
|
while (at (tos, idx) == '\n'
|
|
&& ((at (tos, idx + 1) == '.')
|
|
|| (at (tos, idx + 1) == '|')))
|
|
;
|
|
cattext (&out, "@end example");
|
|
}
|
|
else
|
|
{
|
|
catchar (&out, at (tos, idx));
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
overwrite_string (tos, &out);
|
|
pc++;
|
|
}
|
|
|
|
/* Finds any lines starting with "o ", if there are any, then turns
|
|
on @itemize @bullet, and @items each of them. Then ends with @end
|
|
itemize, inplace at TOS*/
|
|
|
|
static void
|
|
bulletize ()
|
|
{
|
|
unsigned int idx = 0;
|
|
int on = 0;
|
|
string_type out;
|
|
init_string (&out);
|
|
|
|
while (at (tos, idx))
|
|
{
|
|
if (at (tos, idx) == '@'
|
|
&& at (tos, idx + 1) == '*')
|
|
{
|
|
cattext (&out, "*");
|
|
idx += 2;
|
|
}
|
|
else if (at (tos, idx) == '\n'
|
|
&& at (tos, idx + 1) == 'o'
|
|
&& isspace ((unsigned char) at (tos, idx + 2)))
|
|
{
|
|
if (!on)
|
|
{
|
|
cattext (&out, "\n@itemize @bullet\n");
|
|
on = 1;
|
|
|
|
}
|
|
cattext (&out, "\n@item\n");
|
|
idx += 3;
|
|
}
|
|
else
|
|
{
|
|
catchar (&out, at (tos, idx));
|
|
if (on && at (tos, idx) == '\n'
|
|
&& at (tos, idx + 1) == '\n'
|
|
&& at (tos, idx + 2) != 'o')
|
|
{
|
|
cattext (&out, "@end itemize");
|
|
on = 0;
|
|
}
|
|
idx++;
|
|
|
|
}
|
|
}
|
|
if (on)
|
|
{
|
|
cattext (&out, "@end itemize\n");
|
|
}
|
|
|
|
delete_string (tos);
|
|
*tos = out;
|
|
pc++;
|
|
}
|
|
|
|
/* Turn <<foo>> into @code{foo} in place at TOS*/
|
|
|
|
static void
|
|
do_fancy_stuff ()
|
|
{
|
|
unsigned int idx = 0;
|
|
string_type out;
|
|
init_string (&out);
|
|
while (at (tos, idx))
|
|
{
|
|
if (at (tos, idx) == '<'
|
|
&& at (tos, idx + 1) == '<'
|
|
&& !isspace ((unsigned char) at (tos, idx + 2)))
|
|
{
|
|
/* This qualifies as a << startup. */
|
|
idx += 2;
|
|
cattext (&out, "@code{");
|
|
while (at (tos, idx)
|
|
&& at (tos, idx) != '>' )
|
|
{
|
|
catchar (&out, at (tos, idx));
|
|
idx++;
|
|
|
|
}
|
|
cattext (&out, "}");
|
|
idx += 2;
|
|
}
|
|
else
|
|
{
|
|
catchar (&out, at (tos, idx));
|
|
idx++;
|
|
}
|
|
}
|
|
delete_string (tos);
|
|
*tos = out;
|
|
pc++;
|
|
|
|
}
|
|
|
|
/* A command is all upper case,and alone on a line. */
|
|
|
|
static int
|
|
iscommand (ptr, idx)
|
|
string_type *ptr;
|
|
unsigned int idx;
|
|
{
|
|
unsigned int len = 0;
|
|
while (at (ptr, idx))
|
|
{
|
|
if (isupper ((unsigned char) at (ptr, idx))
|
|
|| at (ptr, idx) == ' ' || at (ptr, idx) == '_')
|
|
{
|
|
len++;
|
|
idx++;
|
|
}
|
|
else if (at (ptr, idx) == '\n')
|
|
{
|
|
if (len > 3)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
copy_past_newline (ptr, idx, dst)
|
|
string_type *ptr;
|
|
unsigned int idx;
|
|
string_type *dst;
|
|
{
|
|
int column = 0;
|
|
|
|
while (at (ptr, idx) && at (ptr, idx) != '\n')
|
|
{
|
|
if (at (ptr, idx) == '\t')
|
|
{
|
|
/* Expand tabs. Neither makeinfo nor TeX can cope well with
|
|
them. */
|
|
do
|
|
catchar (dst, ' ');
|
|
while (++column & 7);
|
|
}
|
|
else
|
|
{
|
|
catchar (dst, at (ptr, idx));
|
|
column++;
|
|
}
|
|
idx++;
|
|
|
|
}
|
|
catchar (dst, at (ptr, idx));
|
|
idx++;
|
|
return idx;
|
|
|
|
}
|
|
|
|
static void
|
|
icopy_past_newline ()
|
|
{
|
|
tos++;
|
|
check_range ();
|
|
init_string (tos);
|
|
idx = copy_past_newline (ptr, idx, tos);
|
|
pc++;
|
|
}
|
|
|
|
/* indent
|
|
Take the string at the top of the stack, do some prettying. */
|
|
|
|
static void
|
|
kill_bogus_lines ()
|
|
{
|
|
int sl;
|
|
|
|
int idx = 0;
|
|
int c;
|
|
int dot = 0;
|
|
|
|
string_type out;
|
|
init_string (&out);
|
|
/* Drop leading nl. */
|
|
while (at (tos, idx) == '\n')
|
|
{
|
|
idx++;
|
|
}
|
|
c = idx;
|
|
|
|
/* If the first char is a '.' prepend a newline so that it is
|
|
recognized properly later. */
|
|
if (at (tos, idx) == '.')
|
|
catchar (&out, '\n');
|
|
|
|
/* Find the last char. */
|
|
while (at (tos, idx))
|
|
{
|
|
idx++;
|
|
}
|
|
|
|
/* Find the last non white before the nl. */
|
|
idx--;
|
|
|
|
while (idx && isspace ((unsigned char) at (tos, idx)))
|
|
idx--;
|
|
idx++;
|
|
|
|
/* Copy buffer upto last char, but blank lines before and after
|
|
dots don't count. */
|
|
sl = 1;
|
|
|
|
while (c < idx)
|
|
{
|
|
if (at (tos, c) == '\n'
|
|
&& at (tos, c + 1) == '\n'
|
|
&& at (tos, c + 2) == '.')
|
|
{
|
|
/* Ignore two newlines before a dot. */
|
|
c++;
|
|
}
|
|
else if (at (tos, c) == '.' && sl)
|
|
{
|
|
/* remember that this line started with a dot. */
|
|
dot = 2;
|
|
}
|
|
else if (at (tos, c) == '\n'
|
|
&& at (tos, c + 1) == '\n'
|
|
&& dot)
|
|
{
|
|
c++;
|
|
/* Ignore two newlines when last line was dot. */
|
|
}
|
|
|
|
catchar (&out, at (tos, c));
|
|
if (at (tos, c) == '\n')
|
|
{
|
|
sl = 1;
|
|
|
|
if (dot == 2)
|
|
dot = 1;
|
|
else
|
|
dot = 0;
|
|
}
|
|
else
|
|
sl = 0;
|
|
|
|
c++;
|
|
|
|
}
|
|
|
|
/* Append nl. */
|
|
catchar (&out, '\n');
|
|
pc++;
|
|
delete_string (tos);
|
|
*tos = out;
|
|
|
|
}
|
|
|
|
static void
|
|
indent ()
|
|
{
|
|
string_type out;
|
|
int tab = 0;
|
|
int idx = 0;
|
|
int ol = 0;
|
|
init_string (&out);
|
|
while (at (tos, idx))
|
|
{
|
|
switch (at (tos, idx))
|
|
{
|
|
case '\n':
|
|
cattext (&out, "\n");
|
|
idx++;
|
|
if (tab && at (tos, idx))
|
|
{
|
|
cattext (&out, " ");
|
|
}
|
|
ol = 0;
|
|
break;
|
|
case '(':
|
|
tab++;
|
|
if (ol == 0)
|
|
cattext (&out, " ");
|
|
idx++;
|
|
cattext (&out, "(");
|
|
ol = 1;
|
|
break;
|
|
case ')':
|
|
tab--;
|
|
cattext (&out, ")");
|
|
idx++;
|
|
ol = 1;
|
|
|
|
break;
|
|
default:
|
|
catchar (&out, at (tos, idx));
|
|
ol = 1;
|
|
|
|
idx++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pc++;
|
|
delete_string (tos);
|
|
*tos = out;
|
|
|
|
}
|
|
|
|
static void
|
|
get_stuff_in_command ()
|
|
{
|
|
tos++;
|
|
check_range ();
|
|
init_string (tos);
|
|
|
|
while (at (ptr, idx))
|
|
{
|
|
if (iscommand (ptr, idx))
|
|
break;
|
|
idx = copy_past_newline (ptr, idx, tos);
|
|
}
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
swap ()
|
|
{
|
|
string_type t;
|
|
|
|
t = tos[0];
|
|
tos[0] = tos[-1];
|
|
tos[-1] = t;
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
other_dup ()
|
|
{
|
|
tos++;
|
|
check_range ();
|
|
init_string (tos);
|
|
catstr (tos, tos - 1);
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
drop ()
|
|
{
|
|
tos--;
|
|
check_range ();
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
idrop ()
|
|
{
|
|
isp--;
|
|
icheck_range ();
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
icatstr ()
|
|
{
|
|
tos--;
|
|
check_range ();
|
|
catstr (tos, tos + 1);
|
|
delete_string (tos + 1);
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
skip_past_newline ()
|
|
{
|
|
while (at (ptr, idx)
|
|
&& at (ptr, idx) != '\n')
|
|
idx++;
|
|
idx++;
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
internalmode ()
|
|
{
|
|
internal_mode = *(isp);
|
|
isp--;
|
|
icheck_range ();
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
maybecatstr ()
|
|
{
|
|
if (internal_wanted == internal_mode)
|
|
{
|
|
catstr (tos - 1, tos);
|
|
}
|
|
delete_string (tos);
|
|
tos--;
|
|
check_range ();
|
|
pc++;
|
|
}
|
|
|
|
char *
|
|
nextword (string, word)
|
|
char *string;
|
|
char **word;
|
|
{
|
|
char *word_start;
|
|
int idx;
|
|
char *dst;
|
|
char *src;
|
|
|
|
int length = 0;
|
|
|
|
while (isspace ((unsigned char) *string) || *string == '-')
|
|
{
|
|
if (*string == '-')
|
|
{
|
|
while (*string && *string != '\n')
|
|
string++;
|
|
|
|
}
|
|
else
|
|
{
|
|
string++;
|
|
}
|
|
}
|
|
if (!*string)
|
|
return 0;
|
|
|
|
word_start = string;
|
|
if (*string == '"')
|
|
{
|
|
do
|
|
{
|
|
string++;
|
|
length++;
|
|
if (*string == '\\')
|
|
{
|
|
string += 2;
|
|
length += 2;
|
|
}
|
|
}
|
|
while (*string != '"');
|
|
}
|
|
else
|
|
{
|
|
while (!isspace ((unsigned char) *string))
|
|
{
|
|
string++;
|
|
length++;
|
|
|
|
}
|
|
}
|
|
|
|
*word = malloc (length + 1);
|
|
|
|
dst = *word;
|
|
src = word_start;
|
|
|
|
for (idx = 0; idx < length; idx++)
|
|
{
|
|
if (src[idx] == '\\')
|
|
switch (src[idx + 1])
|
|
{
|
|
case 'n':
|
|
*dst++ = '\n';
|
|
idx++;
|
|
break;
|
|
case '"':
|
|
case '\\':
|
|
*dst++ = src[idx + 1];
|
|
idx++;
|
|
break;
|
|
default:
|
|
*dst++ = '\\';
|
|
break;
|
|
}
|
|
else
|
|
*dst++ = src[idx];
|
|
}
|
|
*dst++ = 0;
|
|
|
|
if (*string)
|
|
return string + 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
dict_type *root;
|
|
|
|
dict_type *
|
|
lookup_word (word)
|
|
char *word;
|
|
{
|
|
dict_type *ptr = root;
|
|
while (ptr)
|
|
{
|
|
if (strcmp (ptr->word, word) == 0)
|
|
return ptr;
|
|
ptr = ptr->next;
|
|
}
|
|
if (warning)
|
|
fprintf (stderr, "Can't find %s\n", word);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
perform ()
|
|
{
|
|
tos = stack;
|
|
|
|
while (at (ptr, idx))
|
|
{
|
|
/* It's worth looking through the command list. */
|
|
if (iscommand (ptr, idx))
|
|
{
|
|
char *next;
|
|
dict_type *word;
|
|
|
|
(void) nextword (addr (ptr, idx), &next);
|
|
|
|
word = lookup_word (next);
|
|
|
|
if (word)
|
|
{
|
|
exec (word);
|
|
}
|
|
else
|
|
{
|
|
if (warning)
|
|
fprintf (stderr, "warning, %s is not recognised\n", next);
|
|
skip_past_newline ();
|
|
}
|
|
|
|
}
|
|
else
|
|
skip_past_newline ();
|
|
}
|
|
}
|
|
|
|
dict_type *
|
|
newentry (word)
|
|
char *word;
|
|
{
|
|
dict_type *new = (dict_type *) malloc (sizeof (dict_type));
|
|
new->word = word;
|
|
new->next = root;
|
|
root = new;
|
|
new->code = (stinst_type *) malloc (sizeof (stinst_type));
|
|
new->code_length = 1;
|
|
new->code_end = 0;
|
|
return new;
|
|
}
|
|
|
|
unsigned int
|
|
add_to_definition (entry, word)
|
|
dict_type *entry;
|
|
stinst_type word;
|
|
{
|
|
if (entry->code_end == entry->code_length)
|
|
{
|
|
entry->code_length += 2;
|
|
entry->code =
|
|
(stinst_type *) realloc ((char *) (entry->code),
|
|
entry->code_length * sizeof (word_type));
|
|
}
|
|
entry->code[entry->code_end] = word;
|
|
|
|
return entry->code_end++;
|
|
}
|
|
|
|
void
|
|
add_intrinsic (name, func)
|
|
char *name;
|
|
void (*func) ();
|
|
{
|
|
dict_type *new = newentry (name);
|
|
add_to_definition (new, func);
|
|
add_to_definition (new, 0);
|
|
}
|
|
|
|
void
|
|
add_var (name)
|
|
char *name;
|
|
{
|
|
dict_type *new = newentry (name);
|
|
add_to_definition (new, push_number);
|
|
add_to_definition (new, (stinst_type) (&(new->var)));
|
|
add_to_definition (new, 0);
|
|
}
|
|
|
|
void
|
|
compile (string)
|
|
char *string;
|
|
{
|
|
/* Add words to the dictionary. */
|
|
char *word;
|
|
string = nextword (string, &word);
|
|
while (string && *string && word[0])
|
|
{
|
|
if (strcmp (word, "var") == 0)
|
|
{
|
|
string = nextword (string, &word);
|
|
|
|
add_var (word);
|
|
string = nextword (string, &word);
|
|
}
|
|
else if (word[0] == ':')
|
|
{
|
|
dict_type *ptr;
|
|
/* Compile a word and add to dictionary. */
|
|
string = nextword (string, &word);
|
|
|
|
ptr = newentry (word);
|
|
string = nextword (string, &word);
|
|
while (word[0] != ';')
|
|
{
|
|
switch (word[0])
|
|
{
|
|
case '"':
|
|
/* got a string, embed magic push string
|
|
function */
|
|
add_to_definition (ptr, push_text);
|
|
add_to_definition (ptr, (stinst_type) (word + 1));
|
|
break;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
/* Got a number, embedd the magic push number
|
|
function */
|
|
add_to_definition (ptr, push_number);
|
|
add_to_definition (ptr, (stinst_type) atol (word));
|
|
break;
|
|
default:
|
|
add_to_definition (ptr, call);
|
|
add_to_definition (ptr, (stinst_type) lookup_word (word));
|
|
}
|
|
|
|
string = nextword (string, &word);
|
|
}
|
|
add_to_definition (ptr, 0);
|
|
string = nextword (string, &word);
|
|
}
|
|
else
|
|
{
|
|
fprintf (stderr, "syntax error at %s\n", string - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
bang ()
|
|
{
|
|
*(long *) ((isp[0])) = isp[-1];
|
|
isp -= 2;
|
|
icheck_range ();
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
atsign ()
|
|
{
|
|
isp[0] = *(long *) (isp[0]);
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
hello ()
|
|
{
|
|
printf ("hello\n");
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
stdout_ ()
|
|
{
|
|
isp++;
|
|
icheck_range ();
|
|
*isp = 1;
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
stderr_ ()
|
|
{
|
|
isp++;
|
|
icheck_range ();
|
|
*isp = 2;
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
print ()
|
|
{
|
|
if (*isp == 1)
|
|
write_buffer (tos, stdout);
|
|
else if (*isp == 2)
|
|
write_buffer (tos, stderr);
|
|
else
|
|
fprintf (stderr, "print: illegal print destination `%ld'\n", *isp);
|
|
isp--;
|
|
tos--;
|
|
icheck_range ();
|
|
check_range ();
|
|
pc++;
|
|
}
|
|
|
|
static void
|
|
read_in (str, file)
|
|
string_type *str;
|
|
FILE *file;
|
|
{
|
|
char buff[10000];
|
|
unsigned int r;
|
|
do
|
|
{
|
|
r = fread (buff, 1, sizeof (buff), file);
|
|
catbuf (str, buff, r);
|
|
}
|
|
while (r);
|
|
buff[0] = 0;
|
|
|
|
catbuf (str, buff, 1);
|
|
}
|
|
|
|
static void
|
|
usage ()
|
|
{
|
|
fprintf (stderr, "usage: -[d|i|g] <file >file\n");
|
|
exit (33);
|
|
}
|
|
|
|
/* There is no reliable way to declare exit. Sometimes it returns
|
|
int, and sometimes it returns void. Sometimes it changes between
|
|
OS releases. Trying to get it declared correctly in the hosts file
|
|
is a pointless waste of time. */
|
|
|
|
static void
|
|
chew_exit ()
|
|
{
|
|
exit (0);
|
|
}
|
|
|
|
int
|
|
main (ac, av)
|
|
int ac;
|
|
char *av[];
|
|
{
|
|
unsigned int i;
|
|
string_type buffer;
|
|
string_type pptr;
|
|
|
|
init_string (&buffer);
|
|
init_string (&pptr);
|
|
init_string (stack + 0);
|
|
tos = stack + 1;
|
|
ptr = &pptr;
|
|
|
|
add_intrinsic ("push_text", push_text);
|
|
add_intrinsic ("!", bang);
|
|
add_intrinsic ("@", atsign);
|
|
add_intrinsic ("hello", hello);
|
|
add_intrinsic ("stdout", stdout_);
|
|
add_intrinsic ("stderr", stderr_);
|
|
add_intrinsic ("print", print);
|
|
add_intrinsic ("skip_past_newline", skip_past_newline);
|
|
add_intrinsic ("catstr", icatstr);
|
|
add_intrinsic ("copy_past_newline", icopy_past_newline);
|
|
add_intrinsic ("dup", other_dup);
|
|
add_intrinsic ("drop", drop);
|
|
add_intrinsic ("idrop", idrop);
|
|
add_intrinsic ("remchar", remchar);
|
|
add_intrinsic ("get_stuff_in_command", get_stuff_in_command);
|
|
add_intrinsic ("do_fancy_stuff", do_fancy_stuff);
|
|
add_intrinsic ("bulletize", bulletize);
|
|
add_intrinsic ("courierize", courierize);
|
|
/* If the following line gives an error, exit() is not declared in the
|
|
../hosts/foo.h file for this host. Fix it there, not here! */
|
|
/* No, don't fix it anywhere; see comment on chew_exit--Ian Taylor. */
|
|
add_intrinsic ("exit", chew_exit);
|
|
add_intrinsic ("swap", swap);
|
|
add_intrinsic ("outputdots", outputdots);
|
|
add_intrinsic ("paramstuff", paramstuff);
|
|
add_intrinsic ("maybecatstr", maybecatstr);
|
|
add_intrinsic ("translatecomments", translatecomments);
|
|
add_intrinsic ("kill_bogus_lines", kill_bogus_lines);
|
|
add_intrinsic ("indent", indent);
|
|
add_intrinsic ("internalmode", internalmode);
|
|
add_intrinsic ("print_stack_level", print_stack_level);
|
|
add_intrinsic ("strip_trailing_newlines", strip_trailing_newlines);
|
|
|
|
/* Put a nl at the start. */
|
|
catchar (&buffer, '\n');
|
|
|
|
read_in (&buffer, stdin);
|
|
remove_noncomments (&buffer, ptr);
|
|
for (i = 1; i < (unsigned int) ac; i++)
|
|
{
|
|
if (av[i][0] == '-')
|
|
{
|
|
if (av[i][1] == 'f')
|
|
{
|
|
string_type b;
|
|
FILE *f;
|
|
init_string (&b);
|
|
|
|
f = fopen (av[i + 1], "r");
|
|
if (!f)
|
|
{
|
|
fprintf (stderr, "Can't open the input file %s\n",
|
|
av[i + 1]);
|
|
return 33;
|
|
}
|
|
|
|
read_in (&b, f);
|
|
compile (b.ptr);
|
|
perform ();
|
|
}
|
|
else if (av[i][1] == 'i')
|
|
{
|
|
internal_wanted = 1;
|
|
}
|
|
else if (av[i][1] == 'w')
|
|
{
|
|
warning = 1;
|
|
}
|
|
else
|
|
usage ();
|
|
}
|
|
}
|
|
write_buffer (stack + 0, stdout);
|
|
if (tos != stack)
|
|
{
|
|
fprintf (stderr, "finishing with current stack level %d\n",
|
|
tos - stack);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|