unsigned long size;
} string_type;
-typedef void (*stinst_type)();
+typedef void (*stinst_type) (void);
typedef struct dict_struct
{
stinst_type *pc;
-#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 *);
-static void die (char *);
-#endif
-
static void
-die (msg)
- char *msg;
+die (char *msg)
{
fprintf (stderr, "%s\n", msg);
exit (1);
}
static void
-init_string_with_size (buffer, size)
- string_type *buffer;
- unsigned int size;
+init_string_with_size (string_type *buffer, unsigned int size)
{
buffer->write_idx = 0;
buffer->size = size;
}
static void
-init_string (buffer)
- string_type *buffer;
+init_string (string_type *buffer)
{
init_string_with_size (buffer, DEF_SIZE);
}
static int
-find (str, what)
- string_type *str;
- char *what;
+find (string_type *str, char *what)
{
unsigned int i;
char *p;
}
static void
-write_buffer (buffer, f)
- string_type *buffer;
- FILE *f;
+write_buffer (string_type *buffer, FILE *f)
{
if (buffer->write_idx != 0
&& fwrite (buffer->ptr, buffer->write_idx, 1, f) != 1)
}
static void
-delete_string (buffer)
- string_type *buffer;
+delete_string (string_type *buffer)
{
free (buffer->ptr);
buffer->ptr = NULL;
}
static char *
-addr (buffer, idx)
- string_type *buffer;
- unsigned int idx;
+addr (string_type *buffer, unsigned int idx)
{
return buffer->ptr + idx;
}
static char
-at (buffer, pos)
- string_type *buffer;
- unsigned int pos;
+at (string_type *buffer, unsigned int pos)
{
if (pos >= buffer->write_idx)
return 0;
}
static void
-catchar (buffer, ch)
- string_type *buffer;
- int ch;
+catchar (string_type *buffer, int ch)
{
if (buffer->write_idx == buffer->size)
{
}
static void
-overwrite_string (dst, src)
- string_type *dst;
- string_type *src;
+overwrite_string (string_type *dst, string_type *src)
{
free (dst->ptr);
dst->size = src->size;
}
static void
-catbuf (buffer, buf, len)
- string_type *buffer;
- char *buf;
- unsigned int len;
+catbuf (string_type *buffer, char *buf, unsigned int len)
{
if (buffer->write_idx + len >= buffer->size)
{
}
static void
-cattext (buffer, string)
- string_type *buffer;
- char *string;
+cattext (string_type *buffer, char *string)
{
catbuf (buffer, string, (unsigned int) strlen (string));
}
static void
-catstr (dst, src)
- string_type *dst;
- string_type *src;
+catstr (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;
+skip_white_and_stars (string_type *src, unsigned int idx)
{
char c;
while ((c = at (src, idx)),
}
static unsigned int
-skip_past_newline_1 (ptr, idx)
- string_type *ptr;
- unsigned int idx;
+skip_past_newline_1 (string_type *ptr, unsigned int idx)
{
while (at (ptr, idx)
&& at (ptr, idx) != '\n')
}
static void
-check_range ()
+check_range (void)
{
if (tos < stack)
die ("underflow in string stack");
}
static void
-icheck_range ()
+icheck_range (void)
{
if (isp < istack)
die ("underflow in integer 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 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;
+exec (dict_type *word)
{
pc = word->code;
while (*pc)
}
static void
-call ()
+call (void)
{
stinst_type *oldpc = pc;
dict_type *e;
}
static void
-remchar ()
+remchar (void)
{
if (tos->write_idx)
tos->write_idx--;
}
static void
-strip_trailing_newlines ()
+strip_trailing_newlines (void)
{
while ((isspace ((unsigned char) at (tos, tos->write_idx - 1))
|| at (tos, tos->write_idx - 1) == '\n')
}
static void
-push_number ()
+push_number (void)
{
isp++;
icheck_range ();
}
static void
-push_text ()
+push_text (void)
{
tos++;
check_range ();
Blank lines are turned into one blank line. */
static void
-remove_noncomments (src, dst)
- string_type *src;
- string_type *dst;
+remove_noncomments (string_type *src, string_type *dst)
{
unsigned int idx = 0;
}
static void
-print_stack_level ()
+print_stack_level (void)
{
fprintf (stderr, "current string stack depth = %ld, ",
(long) (tos - stack));
*/
static void
-paramstuff ()
+paramstuff (void)
{
unsigned int openp;
unsigned int fname;
and *} into comments */
static void
-translatecomments ()
+translatecomments (void)
{
unsigned int idx = 0;
string_type out;
/* Mod tos so that only lines with leading dots remain */
static void
-outputdots ()
+outputdots (void)
{
unsigned int idx = 0;
string_type out;
/* Find lines starting with . and | and put example around them on tos */
static void
-courierize ()
+courierize (void)
{
string_type out;
unsigned int idx = 0;
itemize, inplace at TOS*/
static void
-bulletize ()
+bulletize (void)
{
unsigned int idx = 0;
int on = 0;
/* Turn <<foo>> into @code{foo} in place at TOS*/
static void
-do_fancy_stuff ()
+do_fancy_stuff (void)
{
unsigned int idx = 0;
string_type out;
/* A command is all upper case,and alone on a line. */
static int
-iscommand (ptr, idx)
- string_type *ptr;
- unsigned int idx;
+iscommand (string_type *ptr, unsigned int idx)
{
unsigned int len = 0;
while (at (ptr, idx))
}
static int
-copy_past_newline (ptr, idx, dst)
- string_type *ptr;
- unsigned int idx;
- string_type *dst;
+copy_past_newline (string_type *ptr, unsigned int idx, string_type *dst)
{
int column = 0;
}
static void
-icopy_past_newline ()
+icopy_past_newline (void)
{
tos++;
check_range ();
Take the string at the top of the stack, do some prettying. */
static void
-kill_bogus_lines ()
+kill_bogus_lines (void)
{
int sl;
}
static void
-indent ()
+indent (void)
{
string_type out;
int tab = 0;
}
static void
-get_stuff_in_command ()
+get_stuff_in_command (void)
{
tos++;
check_range ();
}
static void
-swap ()
+swap (void)
{
string_type t;
}
static void
-other_dup ()
+other_dup (void)
{
tos++;
check_range ();
}
static void
-drop ()
+drop (void)
{
tos--;
check_range ();
}
static void
-idrop ()
+idrop (void)
{
isp--;
icheck_range ();
}
static void
-icatstr ()
+icatstr (void)
{
tos--;
check_range ();
}
static void
-skip_past_newline ()
+skip_past_newline (void)
{
idx = skip_past_newline_1 (ptr, idx);
pc++;
}
static void
-internalmode ()
+internalmode (void)
{
internal_mode = *(isp);
isp--;
}
static void
-maybecatstr ()
+maybecatstr (void)
{
if (internal_wanted == internal_mode)
{
}
char *
-nextword (string, word)
- char *string;
- char **word;
+nextword (char *string, char **word)
{
char *word_start;
int idx;
}
dict_type *
-lookup_word (word)
- char *word;
+lookup_word (char *word)
{
dict_type *ptr = root;
while (ptr)
}
dict_type *
-newentry (word)
- char *word;
+newentry (char *word)
{
dict_type *new_d = (dict_type *) malloc (sizeof (dict_type));
new_d->word = word;
}
unsigned int
-add_to_definition (entry, word)
- dict_type *entry;
- stinst_type word;
+add_to_definition (dict_type *entry, stinst_type word)
{
if (entry->code_end == entry->code_length)
{
}
void
-add_intrinsic (name, func)
- char *name;
- void (*func) ();
+add_intrinsic (char *name, void (*func) (void))
{
dict_type *new_d = newentry (strdup (name));
add_to_definition (new_d, func);
}
void
-compile (string)
- char *string;
+compile (char *string)
{
/* Add words to the dictionary. */
char *word;
}
static void
-bang ()
+bang (void)
{
*(long *) ((isp[0])) = isp[-1];
isp -= 2;
}
static void
-atsign ()
+atsign (void)
{
isp[0] = *(long *) (isp[0]);
pc++;
}
static void
-hello ()
+hello (void)
{
printf ("hello\n");
pc++;
}
static void
-stdout_ ()
+stdout_ (void)
{
isp++;
icheck_range ();
}
static void
-stderr_ ()
+stderr_ (void)
{
isp++;
icheck_range ();
}
static void
-print ()
+print (void)
{
if (*isp == 1)
write_buffer (tos, stdout);
}
static void
-read_in (str, file)
- string_type *str;
- FILE *file;
+read_in (string_type *str, FILE *file)
{
char buff[10000];
unsigned int r;
}
static void
-usage ()
+usage (void)
{
fprintf (stderr, "usage: -[d|i|g] <file >file\n");
exit (33);
is a pointless waste of time. */
static void
-chew_exit ()
+chew_exit (void)
{
exit (0);
}
int
-main (ac, av)
- int ac;
- char *av[];
+main (int ac, char *av[])
{
unsigned int i;
string_type buffer;