X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/b5b61c616b6a42a9f3a9cc0e9aeaf5124e7cffc5..e53c6322978d2f8cb8a8aa893c20727aa82cd09c:/src/output.c

diff --git a/src/output.c b/src/output.c
index 34d6b06a..573eb0ca 100644
--- a/src/output.c
+++ b/src/output.c
@@ -1,5 +1,5 @@
 /* Output the generated parsing program for bison,
-   Copyright 1984, 1986, 1989, 1992, 2000, 2001
+   Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
@@ -89,7 +89,9 @@
    negative short int.  Used to flag ??  */
 
 #include "system.h"
+#include "bitsetv.h"
 #include "quotearg.h"
+#include "error.h"
 #include "getargs.h"
 #include "files.h"
 #include "gram.h"
@@ -102,6 +104,12 @@
 #include "conflicts.h"
 #include "muscle_tab.h"
 
+/* From lib/readpipe.h.  */
+FILE *readpipe PARAMS ((const char *, ...));
+
+/* From src/scan-skel.l. */
+int skel_lex PARAMS ((void));
+extern FILE *skel_in;
 
 static int nvectors;
 static int nentries;
@@ -125,7 +133,7 @@ static struct obstack format_obstack;
 int error_verbose = 0;
 
 /* Returns the number of lines of S.  */
-static size_t
+size_t
 get_lines_number (const char *s)
 {
   size_t lines = 0;
@@ -219,7 +227,7 @@ output_gram (void)
 static void
 output_stos (void)
 {
-  int i;
+  size_t i;
   short *values = (short *) alloca (sizeof (short) * nstates);
   for (i = 0; i < nstates; ++i)
     values[i] = states[i]->accessing_symbol;
@@ -268,8 +276,9 @@ output_rule_data (void)
       obstack_sgrow (&format_obstack, ", ");
       j += strsize;
     }
-  /* add a NULL entry to list of tokens */
-  obstack_sgrow (&format_obstack, "NULL");
+  /* Add a NULL entry to list of tokens (well, 0, as NULL might not be
+     defined).  */
+  obstack_sgrow (&format_obstack, "0");
 
   /* Finish table and store. */
   obstack_1grow (&format_obstack, 0);
@@ -348,7 +357,7 @@ action_row (state_t *state)
 	for (j = 0; j < ntokens; j++)
 	  /* and record this rule as the rule to use if that
 	     token follows.  */
-	  if (BITISSET (LA (state->lookaheadsp + i), j))
+	  if (bitset_test (LA[state->lookaheadsp + i], j))
 	    actrow[j] = -LAruleno[state->lookaheadsp + i];
     }
 
@@ -480,7 +489,7 @@ save_row (int state)
 static void
 token_actions (void)
 {
-  int i;
+  size_t i;
   short *yydefact = XCALLOC (short, nstates);
 
   actrow = XCALLOC (short, ntokens);
@@ -503,8 +512,8 @@ token_actions (void)
 | Output the actions to OOUT.  |
 `-----------------------------*/
 
-static void
-actions_output (FILE *out, size_t *line)
+void
+actions_output (FILE *out)
 {
   int rule;
   for (rule = 1; rule < nrules + 1; ++rule)
@@ -523,14 +532,6 @@ actions_output (FILE *out, size_t *line)
 	fprintf (out, "{ %s%s }\n    break;\n\n",
 		 rules[rule].action,
 		 yacc_flag ? ";" : "");
-
-	/* We always output 4 '\n' per action.  */
-	*line += 4;
-	/* Plus one if !no_lines_flag.  */
-	if (!no_lines_flag)
-	  ++*line;
-	/* Get the number of lines written by the user.  */
-	*line += get_lines_number (rules[rule].action);
       }
 }
 
@@ -539,12 +540,12 @@ actions_output (FILE *out, size_t *line)
 | Output the guards to OOUT.  |
 `----------------------------*/
 
-static void
-guards_output (FILE *out, size_t *line)
+void
+guards_output (FILE *out)
 {
   int rule;
   for (rule = 1; rule < nrules + 1; ++rule)
-    if (rules[rule].action)
+    if (rules[rule].guard)
       {
 	fprintf (out, "  case %d:\n", rule);
 
@@ -555,14 +556,6 @@ guards_output (FILE *out, size_t *line)
 				   muscle_find ("filename")));
 	fprintf (out, "{ %s; }\n    break;\n\n",
 		 rules[rule].guard);
-
-	/* We always output 4 '\n' per action.  */
-	*line += 4;
-	/* Plus one if !no_lines_flag.  */
-	if (!no_lines_flag)
-	  ++*line;
-	/* Get the number of lines written by the user.  */
-	*line += get_lines_number (rules[rule].guard);
       }
 }
 
@@ -571,10 +564,11 @@ guards_output (FILE *out, size_t *line)
 | Output the tokens definition to OOUT.  |
 `---------------------------------------*/
 
-static void
-token_definitions_output (FILE *out, size_t *line)
+void
+token_definitions_output (FILE *out)
 {
   int i;
+  int first = 1;
   for (i = 0; i < ntokens; ++i)
     {
       bucket *symbol = symbols[i];
@@ -601,16 +595,13 @@ token_definitions_output (FILE *out, size_t *line)
       if (strchr (symbol->tag, '.') || strchr (symbol->tag, '$'))
 	continue;
 
-      fprintf (out, "# define %s\t%d\n",
-	       symbol->tag, number);
-      ++*line;
+      fprintf (out, "%s  [[[%s]], [%d]]",
+	       first ? "" : ",\n", symbol->tag, number);
       if (semantic_parser)
-	{
-	  /* FIXME: This is probably wrong, and should be just as
-	     above. --akim.  */
-	  fprintf (out, "# define T%s\t%d\n", symbol->tag, symbol->value);
-	  ++*line;
-	}
+	/* FIXME: This is probably wrong, and should be just as
+	   above. --akim.  */
+	fprintf (out, "# define T%s\t%d\n", symbol->tag, symbol->value);
+      first = 0;
     }
 }
 
@@ -653,9 +644,9 @@ save_column (int symbol, int default_state)
 static int
 default_goto (int symbol)
 {
-  int i;
-  int m = goto_map[symbol];
-  int n = goto_map[symbol + 1];
+  size_t i;
+  size_t m = goto_map[symbol];
+  size_t n = goto_map[symbol + 1];
   int default_state = -1;
   int max = 0;
 
@@ -753,7 +744,7 @@ matching_state (int vector)
   int w;
   int prev;
 
-  if (i >= nstates)
+  if (i >= (int) nstates)
     return -1;
 
   t = tally[i];
@@ -925,7 +916,7 @@ output_check (void)
 static void
 output_actions (void)
 {
-  int i;
+  size_t i;
   nvectors = nstates + nvars;
 
   froms = XCALLOC (short *, nvectors);
@@ -934,7 +925,7 @@ output_actions (void)
   width = XCALLOC (short, nvectors);
 
   token_actions ();
-  XFREE (LA);
+  bitsetv_free (LA);
   XFREE (LAruleno);
 
   goto_actions ();
@@ -961,124 +952,80 @@ output_actions (void)
 }
 
 
-/*------------------------------------------------------------.
-| Copy the parser code from SKEL_FILENAME into OOUT obstack.  |
-| and do the muscle substitution.                             |
-`------------------------------------------------------------*/
+/*---------------------------.
+| Call the skeleton parser.  |
+`---------------------------*/
 
 static void
-output_parser (const char *skel_filename, FILE *out)
+output_skeleton (void)
 {
-  int c;
-  FILE *fskel;
-  size_t output_line;
-  size_t skeleton_line;
-
-  fskel = xfopen (skel_filename, "r");
-
-  /* New output code.  */
-  output_line = 1;
-  skeleton_line = 1;
-  c = getc (fskel);
-  while (c != EOF)
-    {
-      if (c != '%')
-	{
-	  if (c == '\n')
-	    {
-	      ++output_line;
-	      ++skeleton_line;
-	    }
-	  putc (c, out);
-	  c = getc (fskel);
-	}
-      else if ((c = getc (fskel)) == '%')
-	{
-	  /* Read the muscle.  */
-	  const char *muscle_key = 0;
-	  const char *muscle_value = 0;
-
-	  while (isalnum (c = getc (fskel)) || c == '-')
-	    obstack_1grow (&muscle_obstack, c);
-	  obstack_1grow (&muscle_obstack, 0);
-
-	  /* Output the right value, or see if it's something special.  */
-	  muscle_key = obstack_finish (&muscle_obstack);
-	  muscle_value = muscle_find (muscle_key);
-	  if (!strcmp (muscle_key, "actions"))
-	    actions_output (out, &output_line);
-	  else if (!strcmp (muscle_key, "guards"))
-	    guards_output (out, &output_line);
-	  else if (!strcmp (muscle_key, "line"))
-	    fprintf (out, "%d", output_line);
-	  else if (!strcmp (muscle_key, "tokendef"))
-	    token_definitions_output (out, &output_line);
-	  else if (!strcmp (muscle_key, "skeleton-line"))
-	    fprintf (out, "%d", skeleton_line);
-	  else if (muscle_value)
-	    {
-	      fputs (muscle_value, out);
-	      output_line += get_lines_number (muscle_value);
-	    }
-	  else
-	    {
-	      fputs ("%%", out);
-	      fputs (muscle_key, out);
-	    }
-	}
-      else
-	putc ('%', out);
-    }
-
-  /* End.  */
-  xfclose (fskel);
-}
-
-/*----------------------------------------.
-| Prepare the master parser to be output  |
-`----------------------------------------*/
-
-static void
-output_master_parser (void)
-{
-  FILE *parser = xfopen (parser_file_name, "w");
-  if (!skeleton)
-    {
-      if (semantic_parser)
-	skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY);
-      else
-	skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
-    }
-  muscle_insert ("skeleton", skeleton);
-  muscle_insert ("parser-file-name", parser_file_name);
-
-  output_parser (skeleton, parser);
-  xfclose (parser);
-}
-
-
-/* FIXME. */
-
-#define MUSCLE_INSERT_INT(Key, Value)				\
-{								\
-  obstack_fgrow1 (&muscle_obstack, "%d", Value);	       	\
-  obstack_1grow (&muscle_obstack, 0);				\
-  muscle_insert (Key, obstack_finish (&muscle_obstack));	\
-}
-
-#define MUSCLE_INSERT_STRING(Key, Value)			\
-{								\
-  obstack_sgrow (&muscle_obstack, Value);			\
-  obstack_1grow (&muscle_obstack, 0);				\
-  muscle_insert (Key, obstack_finish (&muscle_obstack));	\
-}
+  /* Store the definition of all the muscles. */
+  const char *tempdir = getenv ("TMPDIR");
+  char *tempfile = NULL;
+  FILE *out = NULL;
+  int fd;
+
+  if (tempdir == NULL)
+    tempdir = DEFAULT_TMPDIR;
+  tempfile = xmalloc (strlen (tempdir) + 11);
+  sprintf (tempfile, "%s/bsnXXXXXX", tempdir);
+  fd = mkstemp (tempfile);
+  if (fd == -1)
+    error (EXIT_FAILURE, errno, "%s", tempfile);
+
+  out = fdopen (fd, "w");
+  if (out == NULL)
+    error (EXIT_FAILURE, errno, "%s", tempfile);
+
+  /* There are no comments, especially not `#': we do want M4 expansion
+     after `#': think of CPP macros!  */
+  fputs ("m4_changecom()\n", out);
+  fputs ("m4_init()\n", out);
+
+  fputs ("m4_define([b4_actions], \n[[", out);
+  actions_output (out);
+  fputs ("]])\n\n", out);
+
+  fputs ("m4_define([b4_guards], \n[[", out);
+  guards_output (out);
+  fputs ("]])\n\n", out);
+
+  fputs ("m4_define([b4_tokens], \n[", out);
+  token_definitions_output (out);
+  fputs ("])\n\n", out);
+
+  muscles_m4_output (out);
+
+  fputs ("m4_wrap([m4_divert_pop(0)])\n", out);
+  fputs ("m4_divert_push(0)dnl\n", out);
+  xfclose (out);
 
-#define MUSCLE_INSERT_PREFIX(Key, Value)	       			\
-{									\
-  obstack_fgrow2 (&muscle_obstack, "%s%s", 				\
-		  spec_name_prefix ? spec_name_prefix : "yy", Value);	\
-  obstack_1grow (&muscle_obstack, 0);					\
-  muscle_insert (Key, obstack_finish (&muscle_obstack));	       	\
+  /* Invoke m4 on the definition of the muscles, and the skeleton. */
+  {
+    const char *bison_pkgdatadir = getenv ("BISON_PKGDATADIR");
+    const char *m4 = getenv ("M4");
+    if (!m4)
+      m4 = M4;
+    if (!bison_pkgdatadir)
+      bison_pkgdatadir = PKGDATADIR;
+    if (trace_flag)
+      fprintf (stderr,
+	       "running: %s -I %s m4sugar/m4sugar.m4 %s %s\n",
+	       m4, bison_pkgdatadir, tempfile, skeleton);
+    skel_in = readpipe (m4,
+			"-I", bison_pkgdatadir,
+			"m4sugar/m4sugar.m4",
+			tempfile,
+			skeleton,
+			NULL);
+    if (!skel_in)
+      error (EXIT_FAILURE, errno, "cannot run m4");
+    skel_lex ();
+
+    /* If `debugging', keep this file alive. */
+    if (!trace_flag)
+      unlink (tempfile);
+  }
 }
 
 static void
@@ -1091,77 +1038,39 @@ prepare (void)
   MUSCLE_INSERT_INT ("debug", debug_flag);
   MUSCLE_INSERT_INT ("final", final_state);
   MUSCLE_INSERT_INT ("maxtok", max_user_token_number);
-  MUSCLE_INSERT_INT ("error-verbose", error_verbose);
+  MUSCLE_INSERT_INT ("error_verbose", error_verbose);
   MUSCLE_INSERT_STRING ("prefix", spec_name_prefix ? spec_name_prefix : "yy");
 
+  /* FIXME: This is wrong: the muscles should decide whether they hold
+     a copy or not, but the situation is too obscure currently.  */
+  MUSCLE_INSERT_STRING ("output_infix", output_infix ? output_infix : "");
+  MUSCLE_INSERT_STRING ("output_prefix", short_base_name);
+  MUSCLE_INSERT_STRING ("output_parser_name", parser_file_name);
+  MUSCLE_INSERT_STRING ("output_header_name", spec_defines_file);
+
   MUSCLE_INSERT_INT ("nnts", nvars);
   MUSCLE_INSERT_INT ("nrules", nrules);
   MUSCLE_INSERT_INT ("nstates", nstates);
   MUSCLE_INSERT_INT ("ntokens", ntokens);
 
-  MUSCLE_INSERT_INT ("locations-flag", locations_flag);
-}
-
-
-/*-------------------------.
-| Output the header file.  |
-`-------------------------*/
+  MUSCLE_INSERT_INT ("locations_flag", locations_flag);
+  MUSCLE_INSERT_INT ("defines_flag", defines_flag);
 
-static void
-header_output (void)
-{
-  size_t dummy_line;
-  FILE *out = xfopen (spec_defines_file, "w");
-  char *macro_name = compute_header_macro ();
-
-  fprintf (out, "#ifndef %s\n", macro_name);
-  fprintf (out, "# define %s\n\n", macro_name);
-
-  token_definitions_output (out, &dummy_line);
-  fprintf (out, "\
-#ifndef YYSTYPE\n\
-typedef %s
-yystype;\n\
-# define YYSTYPE yystype\n\
-#endif\n",
-		    muscle_find ("stype"));
-
-  if (!pure_parser)
-    fprintf (out, "\nextern YYSTYPE %slval;\n",
-	     spec_name_prefix ? spec_name_prefix : "yy");
-
-  if (locations_flag)
-    {
-      fputs ("\n\n", out);
-      fprintf (out, "\
-#ifndef YYLTYPE\n\
-typedef struct yyltype\n\
-{\n\
-  int first_line;\n\
-  int first_column;\n\
-  int last_line;\n\
-  int last_column;\n\
-} yyltype;\n\
-# define YYLTYPE yyltype\n\
-#endif\n");
-      if (!pure_parser)
-	fprintf (out, "\nextern YYLTYPE %slloc;\n",
-		 spec_name_prefix ? spec_name_prefix : "yy");
-    }
+  /* Copy definitions in directive.  */
+  obstack_1grow (&attrs_obstack, 0);
+  muscle_insert ("prologue", obstack_finish (&attrs_obstack));
 
-  if (semantic_parser)
+  /* Find the right skeleton file.  */
+  if (!skeleton)
     {
-      int i;
-
-      for (i = ntokens; i < nsyms; i++)
-	/* don't make these for dummy nonterminals made by gensym.  */
-	if (*symbols[i]->tag != '@')
-	  fprintf (out, "# define NT%s\t%d\n", symbols[i]->tag, i);
+      if (semantic_parser)
+	skeleton = "bison.hairy";
+      else
+	skeleton = "bison.simple";
     }
 
-  fprintf (out, "\n#endif /* not %s */\n", macro_name);
-  free (macro_name);
-  xfclose (out);
+  /* Parse the skeleton file and output the needed parsers.  */
+  muscle_insert ("skeleton", skeleton);
 }
 
 
@@ -1177,24 +1086,16 @@ output (void)
   output_token_translations ();
   output_gram ();
 
-  XFREE (ritem);
   if (semantic_parser)
     output_stos ();
   output_rule_data ();
   output_actions ();
 
   prepare ();
-  /* Copy definitions in directive.  */
-  obstack_1grow (&attrs_obstack, 0);
-  muscle_insert ("prologue", obstack_finish (&attrs_obstack));
 
-  /* Output the parser. */
-  output_master_parser ();
-  /* Output the header if needed. */
-  if (defines_flag)
-    header_output ();
+  /* Process the selected skeleton file.  */
+  output_skeleton ();
 
-  free (rules + 1);
   obstack_free (&muscle_obstack, NULL);
   obstack_free (&format_obstack, NULL);
   obstack_free (&action_obstack, NULL);