Fixes to make treelang worg with PCH gengtype.c changes.

From-SVN: r54425

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1d7f5b0613ab90437d9b974925ae48f0cb43e4c6..94b77eb8c66904c319d8982d5b50712a978a1acb 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2002-06-10  Tim Josling  <tej@melbpc.org.au>
+
+       * gengtype.c (unnamed enum containing BASE_FILE_*): Add languages
+       TREELANG and COBOL.
+       (lang_names): Add treelang and cobol.
+       (get_file_basename): Add code to support treelang and cobol as
+       4th and 5th users of c-common.c.
+
 2002-06-09  Geoffrey Keating  <geoffk@redhat.com>
 
        * Makefile.in (install-driver): Install driver as

diff --git a/gcc/gengtype.c b/gcc/gengtype.c
index 5e910df382f668f1f41cc69fe72c9a82d6579b5b..f96b6b42322de30217c574e475e639ddac899f75 100644 (file)
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -500,10 +500,13 @@ FILE * header_file;
 enum {
   BASE_FILE_C,
   BASE_FILE_OBJC,
-  BASE_FILE_CPLUSPLUS
+  BASE_FILE_CPLUSPLUS,
+  BASE_FILE_TREELANG,
+  BASE_FILE_COBOL
 };
+
 static const char *lang_names[] = {
-  "c", "objc", "cp", "f", "ada", "java"
+  "c", "objc", "cp", "treelang", "cobol", "f", "ada", "java"
 };
 #define NUM_BASE_FILES (sizeof (lang_names) / sizeof (lang_names[0]))
 FILE *base_files[NUM_BASE_FILES];
@@ -608,6 +611,10 @@ get_file_basename (f)
     basename -= 5;
   else if (startswith (basename - f, basename-5, "objc/"))
     basename -= 5;
+  else if (startswith (basename - f, basename-9, "treelang/"))
+    basename -= 9;
+  else if (startswith (basename - f, basename-6, "cobol/"))
+    basename -= 6;
 
   return basename;
 }
@@ -643,6 +650,9 @@ get_base_file_bitmap (input_file)
           || strcmp (basename, "c-decl.c") == 0
           || strcmp (basename, "c-objc-common.c") == 0)
     return 1 << BASE_FILE_C | 1 << BASE_FILE_OBJC;
+  else if (startswith (len, basename, "c-common.c"))
+    return 1 << BASE_FILE_C | 1 << BASE_FILE_OBJC| 1 << BASE_FILE_CPLUSPLUS
+      |  1 << BASE_FILE_TREELANG | 1 << BASE_FILE_COBOL;
   else if (startswith (len, basename, "c-"))
     return 1 << BASE_FILE_C | 1 << BASE_FILE_OBJC | 1 << BASE_FILE_CPLUSPLUS;
   else

diff --git a/gcc/treelang/ChangeLog b/gcc/treelang/ChangeLog
index a91b9d77c300953be17a80a57e64bff4afc151b5..bf9b6cc1e5ad5b29ace62193f715487c875959ba 100644 (file)
--- a/gcc/treelang/ChangeLog
+++ b/gcc/treelang/ChangeLog
@@ -1,3 +1,59 @@
+2002-06-10  Tim Josling  <tej@melbpc.org.au>
+
+        Cleanup 
+
+       * Make-lang.in (check-treelang). Add. Remove direct dependency of
+       'check' on 'treelang.check' as redundant.
+       
+       PCH Garbage collection regime (gengtypes.c) phase 1.
+       
+       * Make-lang.in (treelang/tree1.o). Depend on gt-treelang-tree1.h
+       gt-treelang-treelang.h gtype-treelang.h.
+       (gt-treelang-tree1.h) Depend on s-gtype.
+       (gt-treelang-treelang.h) Depend on s-gtype.
+       (gtype-treelang.h) Depend on s-gtype.
+
+       * config-lang.in (gtfiles): Define. 
+
+       * lex.l (main): Remove '#if 0' dead code.
+       (main): Move undef of IN_GCC so define of tree typedef works.
+       (all): Replace token and production by prod_token_parm_item.
+       
+       * parse.y
+       (all): Replace token and production by prod_token_parm_item.
+
+       * tree1.c (main): Remove include of "output.h".
+       (symbol_table): Add GTY details.
+       (symbol_table_ggc): Remove.
+       (treelang_init): Remove root definitions for garage collection.
+       (mark_production_used): Remove.
+       (mark_token_used): Remove.
+       (main, at end): include generated garage collection routines.
+
+       * treelang.h (category_enum ): Add parameter_category.
+       (all): Replace token and production and parameters by union
+       prod_token_parm_item containing production_part, token_part,
+       parameter_part.
+       (STATIC_STORAGE AUTOMATIC_STORAGE EXTERNAL_REFERENCE_STORAGE
+       EXTERNAL_DEFINITION_STORAGE SIGNED_CHAR UNSIGNED_CHAR SIGNED_INT
+       UNSIGNED_INT VOID_TYPE EXP_PLUS EXP_REFERENCE EXP_ASSIGN
+       EXP_FUNCTION_INVOCATION EXP_MINUS EXP_EQUALS): Move here from
+       treetree.h.
+
+       * treetree.c
+       (tm_p.h): Do not include.
+       (ansidecl.h): Move include after config.h.
+       (treelang.h): Include it.
+       (ADDROOT): Remove.
+       (all): Replace token, production and parameter by prod_token_parm_item.
+       (tree_parameter_list): Move to treelang.h as part of
+       prod_token_parm_item.
+       (STATIC_STORAGE AUTOMATIC_STORAGE EXTERNAL_REFERENCE_STORAGE
+       EXTERNAL_DEFINITION_STORAGE SIGNED_CHAR UNSIGNED_CHAR SIGNED_INT
+       UNSIGNED_INT VOID_TYPE EXP_PLUS EXP_REFERENCE EXP_ASSIGN
+       EXP_FUNCTION_INVOCATION EXP_MINUS EXP_EQUALS): Move from here to
+       treelang.h.
+
 2002-05-19  Tim Josling  <tej@melbpc.org.au>
 
        * treetree.c (warn_format_zero_length): Add. 

diff --git a/gcc/treelang/Make-lang.in b/gcc/treelang/Make-lang.in
index e77636a48c4cb567a87c63f878a0f4de4be52831..8caadaabaa9bf808a3662dede8289297d2dff988 100644 (file)
--- a/gcc/treelang/Make-lang.in
+++ b/gcc/treelang/Make-lang.in
@@ -90,7 +90,8 @@ tree1$(exeext): treelang/tree1.o treelang/treetree.o treelang/lex.o treelang/par
 
 # object file makes
 
-treelang/tree1.o: $(srcdir)/treelang/tree1.c $(srcdir)/treelang/treelang.h $(srcdir)/treelang/parse.h
+treelang/tree1.o: $(srcdir)/treelang/tree1.c $(srcdir)/treelang/treelang.h $(srcdir)/treelang/parse.h\
+       gt-treelang-tree1.h gt-treelang-treelang.h gtype-treelang.h
        $(CC) -o $@ -c $(ALL_CFLAGS) $(INCLUDES) $< 
 
 treelang/treetree.o: $(srcdir)/treelang/treetree.c $(srcdir)/treelang/treetree.h
@@ -114,6 +115,8 @@ $(srcdir)/treelang/parse.c $(srcdir)/treelang/parse.h: $(srcdir)/treelang/parse.
        --output=$(srcdir)/treelang/parse.c --defines
 # -v
 
+gt-treelang-tree1.h gt-treelang-treelang.h gtype-treelang.h : s-gtype; @true
+
 #\f
 # Build hooks:
 
@@ -246,7 +249,7 @@ treelang.distdir:
 # test hook
 # the other languages are hard coded in the main makefile.in - that seems to be wrong 
 
-check: treelang.check
+check-treelang: treelang.check
 
 TESTSUITEDIR = testsuite
 

diff --git a/gcc/treelang/config-lang.in b/gcc/treelang/config-lang.in
index 6cf1f4544f9bd6c93969874070162969842ea3e4..6392b69bddfb8cc7f831a69f858eebf572ad05c6 100644 (file)
--- a/gcc/treelang/config-lang.in
+++ b/gcc/treelang/config-lang.in
@@ -35,3 +35,6 @@ stagestuff=
 diff_excludes="-x lex.c -x parse.c -x parse.h"
 headers=
 build_by_default="no"
+
+gtfiles="\$(srcdir)/treelang/tree1.c \$(srcdir)/treelang/treelang.h"
+

diff --git a/gcc/treelang/lex.l b/gcc/treelang/lex.l
index 97b06a6b2198f6690a674c9d0b2840ef2e56a138..0d7af64ee47213b5ea1b48a79237916cf82eea44 100644 (file)
--- a/gcc/treelang/lex.l
+++ b/gcc/treelang/lex.l
@@ -33,22 +33,18 @@
  
 */
 
-/* Avoid poisoned malloc problem.  */
-#undef IN_GCC
-
-#if 0
-/* tree is defined as void* here to avoid any knowledge of tree stuff in this file.  */
-typedef void *tree;
-#endif
 #include <stdio.h>
-#if 0
-#include <ctype.h>
-#endif
 #include <memory.h>
 #include "ansidecl.h"
 #include "config.h"
 #include "system.h"
+
+/* Avoid poisoned malloc problem.  */
+#undef IN_GCC
+
+#include "config.h"
 #include "diagnostic.h"
+#include "tree.h"
 
 /* Token defs.  */
 #include "treelang.h"
@@ -81,9 +77,10 @@ static void dump_lex_value (int lexret);
 %%
 
  { 
-   yylval = my_malloc (sizeof (struct token));
-   ((struct token*)yylval)->lineno = next_tree_lineno;
-   ((struct token*)yylval)->charno = next_tree_charno;
+   /* Should really allocate only what we need. lll;.  */
+   yylval = my_malloc (sizeof (struct prod_token_parm_item));
+   ((struct prod_token_parm_item *)yylval)->tp.tok.lineno = next_tree_lineno;
+   ((struct prod_token_parm_item *)yylval)->tp.tok.charno = next_tree_charno;
  }
 
 [ \n]+ {
@@ -221,8 +218,8 @@ static void dump_lex_value (int lexret);
 [^\n]  {
   update_lineno_charno ();
   fprintf (stderr, "%s:%i:%i: Unrecognized character %c\n", in_fname, 
-           ((struct token*)yylval)->lineno, 
-           ((struct token*)yylval)->charno, yytext[0]);
+           ((struct prod_token_parm_item *)yylval)->tp.tok.lineno, 
+           ((struct prod_token_parm_item *)yylval)->tp.tok.charno, yytext[0]);
   errorcount++;
 }
 
@@ -238,8 +235,8 @@ update_lineno_charno (void)
    /* Update the values we send to caller in case we sometimes don't
       tell them about all the 'tokens' eg comments etc.  */
    int yyl;
-   ((struct token*)yylval)->lineno = next_tree_lineno;
-   ((struct token*)yylval)->charno = next_tree_charno;
+   ((struct prod_token_parm_item *)yylval)->tp.tok.lineno = next_tree_lineno;
+   ((struct prod_token_parm_item *)yylval)->tp.tok.charno = next_tree_charno;
    for ( yyl = 0; yyl < yyleng; ++yyl ) 
       {
          if ( yytext[yyl] == '\n' ) 
@@ -257,16 +254,16 @@ update_lineno_charno (void)
 void 
 update_yylval (int a)
 {
-  struct token* tok;
+  struct prod_token_parm_item * tok;
   tok=yylval;
   
   tok->category = token_category;
   tok->type = a;
-  tok->length = yyleng;
+  tok->tp.tok.length = yyleng;
   /* Have to copy yytext as it is just a ptr into the buffer at the
      moment.  */
-  tok->chars = my_malloc (yyleng + 1);
-  memcpy (tok->chars, yytext, yyleng);
+  tok->tp.tok.chars = my_malloc (yyleng + 1);
+  memcpy (tok->tp.tok.chars, yytext, yyleng);
 }
 
 /* Trace the value LEXRET and the position and token details being
@@ -277,9 +274,9 @@ dump_lex_value (int lexret)
 {
   int ix;
   fprintf (stderr, " %d l:%d c:%d ln:%d text=", lexret,
-         ((struct token*) yylval)->lineno,
-         ((struct token*) yylval)->charno,
-         ((struct token*) yylval)->length);
+         ((struct prod_token_parm_item *) yylval)->tp.tok.lineno,
+         ((struct prod_token_parm_item *) yylval)->tp.tok.charno,
+         ((struct prod_token_parm_item *) yylval)->tp.tok.length);
   for (ix = 0; ix < yyleng; ix++) 
     {
       fprintf (stderr, "%c", yytext[ix]);

diff --git a/gcc/treelang/parse.y b/gcc/treelang/parse.y
index f0c0cefa7ad5877b99d5b413f7f2aeabdbd9317d..0588e2180f80dacccd1fdf2942c683e0f94ff859 100644 (file)
--- a/gcc/treelang/parse.y
+++ b/gcc/treelang/parse.y
@@ -71,16 +71,16 @@ static void yyerror (const char *error_message);
 int yylex (void);
 int yyparse (void);
 void print_token (FILE * file, unsigned int type ATTRIBUTE_UNUSED, YYSTYPE value);
-static struct production *reverse_prod_list (struct production *old_first);
-static void ensure_not_void (unsigned int type, struct token* name);
-static int check_type_match (int type_num, struct production *exp);
-static int get_common_type (struct production *type1, struct production *type2);
-static struct production *make_integer_constant (struct token* value);
-static void set_storage (struct production *prod);
+static struct prod_token_parm_item *reverse_prod_list (struct prod_token_parm_item *old_first);
+static void ensure_not_void (unsigned int type, struct prod_token_parm_item* name);
+static int check_type_match (int type_num, struct prod_token_parm_item *exp);
+static int get_common_type (struct prod_token_parm_item *type1, struct prod_token_parm_item *type2);
+static struct prod_token_parm_item *make_integer_constant (struct prod_token_parm_item* value);
+static void set_storage (struct prod_token_parm_item *prod);
 
 /* File global variables.  */
 
-static struct production *current_function=NULL;
+static struct prod_token_parm_item *current_function=NULL;
 
 %}
 
@@ -171,14 +171,14 @@ variable_def {
 
 variable_def:
 storage typename NAME init_opt SEMICOLON {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = $3;
   prod = make_production (PROD_VARIABLE_NAME, tok);
   SYMBOL_TABLE_NAME (prod) = tok;
   EXPRESSION_TYPE (prod) = $2;
   VAR_INIT (prod) = $4;
-  NUMERIC_TYPE (prod) = NUMERIC_TYPE (( (struct production*)EXPRESSION_TYPE (prod)));
+  NUMERIC_TYPE (prod) = NUMERIC_TYPE (( (struct prod_token_parm_item*)EXPRESSION_TYPE (prod)));
   ensure_not_void (NUMERIC_TYPE (prod), tok);
   if (insert_tree_name (prod))
     {
@@ -189,26 +189,26 @@ storage typename NAME init_opt SEMICOLON {
 
   if (VAR_INIT (prod))
     {
-      if (! ((struct production*)VAR_INIT (prod))->code)
+      if (! ((struct prod_token_parm_item*)VAR_INIT (prod))->tp.pro.code)
         abort ();
     if (STORAGE_CLASS (prod) == EXTERNAL_REFERENCE_STORAGE)
       {
         fprintf (stderr, "%s:%i:%i: External reference variables may not have initial value\n", in_fname, 
-                tok->lineno, tok->charno);
+                tok->tp.tok.lineno, tok->tp.tok.charno);
         print_token (stderr, 0, tok);
         errorcount++;
         YYERROR;
       }
     }
-  prod->code = tree_code_create_variable
+  prod->tp.pro.code = tree_code_create_variable
     (STORAGE_CLASS (prod), 
-     ((struct token*)SYMBOL_TABLE_NAME (prod))->chars,
-     ((struct token*)SYMBOL_TABLE_NAME (prod))->length,
+     ((struct prod_token_parm_item*)SYMBOL_TABLE_NAME (prod))->tp.tok.chars,
+     ((struct prod_token_parm_item*)SYMBOL_TABLE_NAME (prod))->tp.tok.length,
      NUMERIC_TYPE (prod),
-     VAR_INIT (prod)? ((struct production*)VAR_INIT (prod))->code:NULL,
+     VAR_INIT (prod)? ((struct prod_token_parm_item*)VAR_INIT (prod))->tp.pro.code:NULL,
      in_fname,
-     tok->lineno);
-  if (!prod->code) 
+     tok->tp.tok.lineno);
+  if (!prod->tp.pro.code) 
     abort ();
 }
 ;
@@ -222,14 +222,14 @@ STATIC
 
 parameter:
 typename NAME {
-  struct token* tok;
-  struct production *prod;
-  struct production *prod2;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *prod2;
   tok = $2;
   prod = make_production (PROD_VARIABLE_NAME, tok);
   SYMBOL_TABLE_NAME (prod) = $2;
   EXPRESSION_TYPE (prod) = $1;
-  NUMERIC_TYPE (prod) = NUMERIC_TYPE (( (struct production*)EXPRESSION_TYPE (prod)));
+  NUMERIC_TYPE (prod) = NUMERIC_TYPE (( (struct prod_token_parm_item*)EXPRESSION_TYPE (prod)));
   ensure_not_void (NUMERIC_TYPE (prod), tok);
   if (insert_tree_name (prod))
     {
@@ -243,19 +243,19 @@ typename NAME {
 
 function_prototype:
 storage typename NAME LEFT_PARENTHESIS parameters RIGHT_PARENTHESIS SEMICOLON {
-  struct token* tok;
-  struct production *prod;
-  struct production *type;
-  struct tree_parameter_list* first_parms;
-  struct tree_parameter_list* last_parms;
-  struct tree_parameter_list* this_parms;
-  struct production *this_parm;
-  struct production *this_parm_var;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *type;
+  struct prod_token_parm_item* first_parms;
+  struct prod_token_parm_item* last_parms;
+  struct prod_token_parm_item* this_parms;
+  struct prod_token_parm_item *this_parm;
+  struct prod_token_parm_item *this_parm_var;
   tok = $3;
   prod = make_production (PROD_FUNCTION_NAME, $3);
   SYMBOL_TABLE_NAME (prod) = $3;
   EXPRESSION_TYPE (prod) = $2;
-  NUMERIC_TYPE (prod) = NUMERIC_TYPE (( (struct production*)EXPRESSION_TYPE (prod)));
+  NUMERIC_TYPE (prod) = NUMERIC_TYPE (( (struct prod_token_parm_item*)EXPRESSION_TYPE (prod)));
   PARAMETERS (prod) = reverse_prod_list ($5); 
   insert_tree_name (prod);
   STORAGE_CLASS_TOKEN (prod) = $1;
@@ -268,7 +268,7 @@ storage typename NAME LEFT_PARENTHESIS parameters RIGHT_PARENTHESIS SEMICOLON {
       
     case AUTOMATIC_STORAGE:
       fprintf (stderr, "%s:%i:%i: A function cannot be automatic\n", in_fname, 
-              tok->lineno, tok->charno);
+              tok->tp.tok.lineno, tok->tp.tok.charno);
       print_token (stderr, 0, tok);
       errorcount++;
       YYERROR;
@@ -281,7 +281,7 @@ storage typename NAME LEFT_PARENTHESIS parameters RIGHT_PARENTHESIS SEMICOLON {
   /* Create a parameter list in a non-front end specific format.  */
   for (first_parms = NULL, last_parms = NULL, this_parm = PARAMETERS (prod);
        this_parm;
-       this_parm = this_parm->next)
+       this_parm = this_parm->tp.pro.next)
     {
       if (this_parm->category != production_category)
         abort ();
@@ -290,14 +290,14 @@ storage typename NAME LEFT_PARENTHESIS parameters RIGHT_PARENTHESIS SEMICOLON {
         abort ();
       if (this_parm_var->category != production_category)
         abort ();
-      this_parms = my_malloc (sizeof (struct tree_parameter_list));
-      if (!this_parm_var->main_token)
+      this_parms = my_malloc (sizeof (struct prod_token_parm_item));
+      if (!this_parm_var->tp.pro.main_token)
         abort ();
-      this_parms->variable_name = this_parm_var->main_token->chars;
-      this_parms->type = NUMERIC_TYPE (( (struct production*)EXPRESSION_TYPE (this_parm_var)));
+      this_parms->tp.par.variable_name = this_parm_var->tp.pro.main_token->tp.tok.chars;
+      this_parms->type = NUMERIC_TYPE (( (struct prod_token_parm_item*)EXPRESSION_TYPE (this_parm_var)));
       if (last_parms)
         {
-          last_parms->next = this_parms;
+          last_parms->tp.par.next = this_parms;
           last_parms = this_parms;
         }
       else
@@ -305,55 +305,56 @@ storage typename NAME LEFT_PARENTHESIS parameters RIGHT_PARENTHESIS SEMICOLON {
           first_parms = this_parms;
           last_parms = this_parms;
         }
-      this_parms->where_to_put_var_tree = & (( (struct production*)VARIABLE (this_parm))->code);
+      this_parms->tp.par.where_to_put_var_tree = 
+        & (( (struct prod_token_parm_item*)VARIABLE (this_parm))->tp.pro.code);
     }
   FIRST_PARMS (prod) = first_parms;
 
-  prod->code = tree_code_create_function_prototype
-    (tok->chars, STORAGE_CLASS (prod), NUMERIC_TYPE (type),
-     first_parms, in_fname, tok->lineno);
+  prod->tp.pro.code = tree_code_create_function_prototype
+    (tok->tp.tok.chars, STORAGE_CLASS (prod), NUMERIC_TYPE (type),
+     first_parms, in_fname, tok->tp.tok.lineno);
 
 }
 ;
 
 function:
 NAME LEFT_BRACE {
-  struct production *proto;
-  struct production search_prod;
-  struct token* tok;
-  struct production *this_parm;
+  struct prod_token_parm_item *proto;
+  struct prod_token_parm_item search_prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *this_parm;
   tok = $1;
   SYMBOL_TABLE_NAME ((&search_prod)) = tok;
   current_function = proto = lookup_tree_name (&search_prod);
   if (!proto)
     {
       fprintf (stderr, "%s:%i:%i: Function prototype not found\n", in_fname, 
-              tok->lineno, tok->charno);
+              tok->tp.tok.lineno, tok->tp.tok.charno);
       print_token (stderr, 0, tok);
       errorcount++;
       YYERROR;
     }
-  if (!proto->code)
+  if (!proto->tp.pro.code)
     abort ();
   tree_code_create_function_initial
-    (proto->code, in_fname, tok->lineno,
+    (proto->tp.pro.code, in_fname, tok->tp.tok.lineno,
      FIRST_PARMS (current_function));
 
   /* Check all the parameters have code.  */
   for (this_parm = PARAMETERS (proto);
        this_parm;
-       this_parm = this_parm->next)
+       this_parm = this_parm->tp.pro.next)
     {
-      if (! (struct production*)VARIABLE (this_parm))
+      if (! (struct prod_token_parm_item*)VARIABLE (this_parm))
         abort ();
-      if (! (( (struct production*)VARIABLE (this_parm))->code))
+      if (! (( (struct prod_token_parm_item*)VARIABLE (this_parm))->tp.pro.code))
         abort ();
     }
 }
 variable_defs_opt statements_opt RIGHT_BRACE {
-  struct token* tok;
+  struct prod_token_parm_item* tok;
   tok = $1;
-  tree_code_create_function_wrapup (in_fname, tok->lineno);
+  tree_code_create_function_wrapup (in_fname, tok->tp.tok.lineno);
   current_function = NULL;
 }
 ;
@@ -387,48 +388,48 @@ variable_def {
 
 typename:
 INT {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = $1;
   prod = make_production (PROD_TYPE_NAME, tok);
   NUMERIC_TYPE (prod) = SIGNED_INT;
-  prod->code = tree_code_get_type (NUMERIC_TYPE (prod));
+  prod->tp.pro.code = tree_code_get_type (NUMERIC_TYPE (prod));
   $$ = prod;
 }
 |UNSIGNED INT {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = $1;
   prod = make_production (PROD_TYPE_NAME, tok);
   NUMERIC_TYPE (prod) = UNSIGNED_INT;
-  prod->code = tree_code_get_type (NUMERIC_TYPE (prod));
+  prod->tp.pro.code = tree_code_get_type (NUMERIC_TYPE (prod));
   $$ = prod;
 }
 |CHAR {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = $1;
   prod = make_production (PROD_TYPE_NAME, tok);
   NUMERIC_TYPE (prod) = SIGNED_CHAR;
-  prod->code = tree_code_get_type (NUMERIC_TYPE (prod));
+  prod->tp.pro.code = tree_code_get_type (NUMERIC_TYPE (prod));
   $$ = prod;
 }
 |UNSIGNED CHAR {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = $1;
   prod = make_production (PROD_TYPE_NAME, tok);
   NUMERIC_TYPE (prod) = UNSIGNED_CHAR;
-  prod->code = tree_code_get_type (NUMERIC_TYPE (prod));
+  prod->tp.pro.code = tree_code_get_type (NUMERIC_TYPE (prod));
   $$ = prod;
 }
 |VOID {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = $1;
   prod = make_production (PROD_TYPE_NAME, tok);
   NUMERIC_TYPE (prod) = VOID_TYPE;
-  prod->code = tree_code_get_type (NUMERIC_TYPE (prod));
+  prod->tp.pro.code = tree_code_get_type (NUMERIC_TYPE (prod));
   $$ = prod;
 }
 ;
@@ -439,9 +440,9 @@ parameter {
   $$ = $1;
 }
 |parameters COMMA parameter {
-  struct production *prod1;
+  struct prod_token_parm_item *prod1;
   prod1 = $3;
-  prod1->next = $1; /* Insert in reverse order.  */
+  prod1->tp.pro.next = $1; /* Insert in reverse order.  */
   $$ = prod1;
 }
 ;
@@ -457,9 +458,9 @@ statement {
 
 statement:
 expression SEMICOLON {
-  struct production *exp;
+  struct prod_token_parm_item *exp;
   exp = $1;
-  tree_code_output_expression_statement (exp->code, in_fname, exp->main_token->lineno);
+  tree_code_output_expression_statement (exp->tp.pro.code, in_fname, exp->tp.pro.main_token->tp.tok.lineno);
 }
 |return SEMICOLON {
   /* Nothing to do.  */
@@ -471,67 +472,67 @@ expression SEMICOLON {
 
 if_statement:
 IF LEFT_PARENTHESIS expression RIGHT_PARENTHESIS {
-  struct token* tok;
-  struct production *exp;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *exp;
   tok = $1;
   exp = $3;
-  ensure_not_void (NUMERIC_TYPE (exp), exp->main_token);
-  tree_code_if_start (exp->code, in_fname, tok->lineno);
+  ensure_not_void (NUMERIC_TYPE (exp), exp->tp.pro.main_token);
+  tree_code_if_start (exp->tp.pro.code, in_fname, tok->tp.tok.lineno);
 }
 LEFT_BRACE statements_opt RIGHT_BRACE {
   /* Just let the statements flow.  */
 }
 ELSE {
-  struct token* tok;
+  struct prod_token_parm_item* tok;
   tok = $1;
-  tree_code_if_else (in_fname, tok->lineno);
+  tree_code_if_else (in_fname, tok->tp.tok.lineno);
 }
 LEFT_BRACE statements_opt RIGHT_BRACE {
-  struct token* tok;
+  struct prod_token_parm_item* tok;
   tok = $12;
-  tree_code_if_end (in_fname, tok->lineno);
+  tree_code_if_end (in_fname, tok->tp.tok.lineno);
 }
 ;
 
 
 return:
 RETURN expression_opt {
-  struct production *type_prod;
-  struct token* ret_tok;
+  struct prod_token_parm_item *type_prod;
+  struct prod_token_parm_item* ret_tok;
   ret_tok = $1;
   type_prod = EXPRESSION_TYPE (current_function);
   if (NUMERIC_TYPE (type_prod) == VOID)
     if ($2 == NULL)
-      tree_code_generate_return (type_prod->code, NULL);
+      tree_code_generate_return (type_prod->tp.pro.code, NULL);
     else
       {
         fprintf (stderr, "%s:%i:%i: Redundant expression in return\n", in_fname, 
-                ret_tok->lineno, ret_tok->charno);
+                ret_tok->tp.tok.lineno, ret_tok->tp.tok.charno);
         print_token (stderr, 0, ret_tok);
         errorcount++;
-        tree_code_generate_return (type_prod->code, NULL);
+        tree_code_generate_return (type_prod->tp.pro.code, NULL);
       }
   else
     if ($2 == NULL)
       {
         fprintf (stderr, "%s:%i:%i: Expression missing in return\n", in_fname, 
-                ret_tok->lineno, ret_tok->charno); 
+                ret_tok->tp.tok.lineno, ret_tok->tp.tok.charno); 
         print_token (stderr, 0, ret_tok);
         errorcount++;
       }
     else
       {
-        struct production *exp;
+        struct prod_token_parm_item *exp;
         exp = $2;
         /* Check same type.  */
         if (check_type_match (NUMERIC_TYPE (type_prod), $2))
           {
-            if (!type_prod->code)
+            if (!type_prod->tp.pro.code)
               abort ();
-            if (!exp->code)
+            if (!exp->tp.pro.code)
               abort ();
             /* Generate the code. */
-            tree_code_generate_return (type_prod->code, exp->code);
+            tree_code_generate_return (type_prod->tp.pro.code, exp->tp.pro.code);
           }
       }
 }
@@ -542,9 +543,9 @@ expression_opt:
   $$ = 0;
 }
 |expression {
-  struct production *exp;
+  struct prod_token_parm_item *exp;
   exp = $1;
-  if (!exp->code)
+  if (!exp->tp.pro.code)
     abort ();
   
   $$ = $1;
@@ -559,17 +560,17 @@ INTEGER {
   $$ = $1;
 }
 |expression PLUS expression {
-  struct token* tok;
-  struct production *prod;
-  struct production *op1;
-  struct production *op2;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *op1;
+  struct prod_token_parm_item *op2;
   tree type;
   
   op1 = $1;
   op2 = $3;
   tok = $2;
-  ensure_not_void (NUMERIC_TYPE (op1), op1->main_token);
-  ensure_not_void (NUMERIC_TYPE (op2), op2->main_token);
+  ensure_not_void (NUMERIC_TYPE (op1), op1->tp.pro.main_token);
+  ensure_not_void (NUMERIC_TYPE (op2), op2->tp.pro.main_token);
   prod = make_production (PROD_PLUS_EXPRESSION, tok);
   NUMERIC_TYPE (prod) = get_common_type (op1, op2);
   if (!NUMERIC_TYPE (prod))
@@ -582,22 +583,22 @@ INTEGER {
       OP1 (prod) = $1;
       OP2 (prod) = $3;
       
-      prod->code = tree_code_get_expression
-        (EXP_PLUS, type, op1->code, op2->code, NULL);
+      prod->tp.pro.code = tree_code_get_expression
+        (EXP_PLUS, type, op1->tp.pro.code, op2->tp.pro.code, NULL);
     }
   $$ = prod;
 }
 |expression MINUS expression %prec PLUS {
-  struct token* tok;
-  struct production *prod;
-  struct production *op1;
-  struct production *op2;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *op1;
+  struct prod_token_parm_item *op2;
   tree type;
   
   op1 = $1;
   op2 = $3;
-  ensure_not_void (NUMERIC_TYPE (op1), op1->main_token);
-  ensure_not_void (NUMERIC_TYPE (op2), op2->main_token);
+  ensure_not_void (NUMERIC_TYPE (op1), op1->tp.pro.main_token);
+  ensure_not_void (NUMERIC_TYPE (op2), op2->tp.pro.main_token);
   tok = $2;
   prod = make_production (PROD_PLUS_EXPRESSION, tok);
   NUMERIC_TYPE (prod) = get_common_type (op1, op2);
@@ -611,22 +612,22 @@ INTEGER {
       OP1 (prod) = $1;
       OP2 (prod) = $3;
       
-      prod->code = tree_code_get_expression (EXP_MINUS, 
-                                          type, op1->code, op2->code, NULL);
+      prod->tp.pro.code = tree_code_get_expression (EXP_MINUS, 
+                                          type, op1->tp.pro.code, op2->tp.pro.code, NULL);
     }
   $$ = prod;
 }
 |expression EQUALS expression {
-  struct token* tok;
-  struct production *prod;
-  struct production *op1;
-  struct production *op2;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *op1;
+  struct prod_token_parm_item *op2;
   tree type;
   
   op1 = $1;
   op2 = $3;
-  ensure_not_void (NUMERIC_TYPE (op1), op1->main_token);
-  ensure_not_void (NUMERIC_TYPE (op2), op2->main_token);
+  ensure_not_void (NUMERIC_TYPE (op1), op1->tp.pro.main_token);
+  ensure_not_void (NUMERIC_TYPE (op2), op2->tp.pro.main_token);
   tok = $2;
   prod = make_production (PROD_PLUS_EXPRESSION, tok);
   NUMERIC_TYPE (prod) = SIGNED_INT;
@@ -640,22 +641,22 @@ INTEGER {
       OP1 (prod) = $1;
       OP2 (prod) = $3;
       
-      prod->code = tree_code_get_expression (EXP_EQUALS, 
-                                          type, op1->code, op2->code, NULL);
+      prod->tp.pro.code = tree_code_get_expression (EXP_EQUALS, 
+                                          type, op1->tp.pro.code, op2->tp.pro.code, NULL);
     }
   $$ = prod;
 }
 |variable_ref ASSIGN expression {
-  struct token* tok;
-  struct production *prod;
-  struct production *op1;
-  struct production *op2;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *op1;
+  struct prod_token_parm_item *op2;
   tree type;
   
   op1 = $1;
   op2 = $3;
   tok = $2;
-  ensure_not_void (NUMERIC_TYPE (op2), op2->main_token);
+  ensure_not_void (NUMERIC_TYPE (op2), op2->tp.pro.main_token);
   prod = make_production (PROD_ASSIGN_EXPRESSION, tok);
   NUMERIC_TYPE (prod) = NUMERIC_TYPE (op1);
   if (!NUMERIC_TYPE (prod))
@@ -667,8 +668,8 @@ INTEGER {
         abort ();
       OP1 (prod) = $1;
       OP2 (prod) = $3;
-      prod->code = tree_code_get_expression (EXP_ASSIGN, 
-                                          type, op1->code, op2->code, NULL);
+      prod->tp.pro.code = tree_code_get_expression (EXP_ASSIGN, 
+                                          type, op1->tp.pro.code, op2->tp.pro.code, NULL);
     }
   $$ = prod;
 }
@@ -679,13 +680,13 @@ INTEGER {
 
 function_invocation:
 NAME LEFT_PARENTHESIS expressions_with_commas RIGHT_PARENTHESIS {
-  struct production *prod;
-  struct token* tok;
-  struct production search_prod;
-  struct production *proto;
-  struct production *exp;
-  struct production *exp_proto;
-  struct production *var;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item search_prod;
+  struct prod_token_parm_item *proto;
+  struct prod_token_parm_item *exp;
+  struct prod_token_parm_item *exp_proto;
+  struct prod_token_parm_item *var;
   int exp_proto_count;
   int exp_count;
   tree parms;
@@ -700,7 +701,7 @@ NAME LEFT_PARENTHESIS expressions_with_commas RIGHT_PARENTHESIS {
   if (!proto)
     {
       fprintf (stderr, "%s:%i:%i: Function prototype not found\n", in_fname, 
-              tok->lineno, tok->charno);
+              tok->tp.tok.lineno, tok->tp.tok.charno);
       print_token (stderr, 0, tok);
       errorcount++;
       YYERROR;
@@ -709,16 +710,16 @@ NAME LEFT_PARENTHESIS expressions_with_commas RIGHT_PARENTHESIS {
   NUMERIC_TYPE (prod) = NUMERIC_TYPE (proto);
   /* Count the expressions and ensure they match the prototype.  */
   for (exp_proto_count = 0, exp_proto = PARAMETERS (proto); 
-       exp_proto; exp_proto = exp_proto->next)
+       exp_proto; exp_proto = exp_proto->tp.pro.next)
     exp_proto_count++;
 
-  for (exp_count = 0, exp = PARAMETERS (prod); exp; exp = exp->next)
+  for (exp_count = 0, exp = PARAMETERS (prod); exp; exp = exp->tp.pro.next)
     exp_count++;
 
   if (exp_count !=  exp_proto_count)
     {
       fprintf (stderr, "%s:%i:%i: expression count mismatch with prototype\n", in_fname, 
-              tok->lineno, tok->charno);
+              tok->tp.tok.lineno, tok->tp.tok.charno);
       print_token (stderr, 0, tok);
       errorcount++;
       YYERROR;
@@ -726,50 +727,50 @@ NAME LEFT_PARENTHESIS expressions_with_commas RIGHT_PARENTHESIS {
   parms = tree_code_init_parameters ();
   for (exp_proto = PARAMETERS (proto), exp = PARAMETERS (prod);
        exp_proto;
-       exp = exp->next, exp_proto = exp_proto->next)
+       exp = exp->tp.pro.next, exp_proto = exp_proto->tp.pro.next)
   {
     if (!exp)
       abort ();
     if (!exp_proto)
       abort ();
-    if (!exp->code)
+    if (!exp->tp.pro.code)
       abort ();
     var = VARIABLE (exp_proto);
     if (!var)
       abort ();
-    if (!var->code)
+    if (!var->tp.pro.code)
       abort ();
-    parms = tree_code_add_parameter (parms, var->code, exp->code);
+    parms = tree_code_add_parameter (parms, var->tp.pro.code, exp->tp.pro.code);
   }
   type = get_type_for_numeric_type (NUMERIC_TYPE (prod));
-  prod->code = tree_code_get_expression
-    (EXP_FUNCTION_INVOCATION, type, proto->code, parms, NULL);
+  prod->tp.pro.code = tree_code_get_expression
+    (EXP_FUNCTION_INVOCATION, type, proto->tp.pro.code, parms, NULL);
   $$ = prod;
 }
 ;
 
 expressions_with_commas:
 expression {
-  struct production *exp;
+  struct prod_token_parm_item *exp;
   exp = $1;
-  ensure_not_void (NUMERIC_TYPE (exp), exp->main_token);
+  ensure_not_void (NUMERIC_TYPE (exp), exp->tp.pro.main_token);
   $$ = $1;
 }
 |expressions_with_commas COMMA expression {
-  struct production *exp;
+  struct prod_token_parm_item *exp;
   exp = $3;
-  ensure_not_void (NUMERIC_TYPE (exp), exp->main_token);
-  exp->next = $1; /* Reverse order.  */
+  ensure_not_void (NUMERIC_TYPE (exp), exp->tp.pro.main_token);
+  exp->tp.pro.next = $1; /* Reverse order.  */
   $$ = exp;
 }
 ;
 
 variable_ref:
 NAME {
-  struct production search_prod;
-  struct production *prod;
-  struct production *symbol_table_entry;
-  struct token* tok;
+  struct prod_token_parm_item search_prod;
+  struct prod_token_parm_item *prod;
+  struct prod_token_parm_item *symbol_table_entry;
+  struct prod_token_parm_item* tok;
   tree type;
 
   tok = $1;
@@ -778,7 +779,7 @@ NAME {
   if (!symbol_table_entry)
     {
       fprintf (stderr, "%s:%i:%i: Variable referred to but not defined\n", in_fname, 
-              tok->lineno, tok->charno);
+              tok->tp.tok.lineno, tok->tp.tok.charno);
       print_token (stderr, 0, tok);
       errorcount++;
       YYERROR;
@@ -791,8 +792,8 @@ NAME {
     YYERROR;
   OP1 (prod) = $1;
   
-  prod->code = tree_code_get_expression (EXP_REFERENCE, type, 
-                                      symbol_table_entry->code, NULL, NULL);
+  prod->tp.pro.code = tree_code_get_expression (EXP_REFERENCE, type, 
+                                      symbol_table_entry->tp.pro.code, NULL, NULL);
   $$ = prod;
 }
 ;
@@ -824,13 +825,13 @@ INTEGER {
 void
 print_token (FILE * file, unsigned int type ATTRIBUTE_UNUSED, YYSTYPE value) 
 {
-  struct token *tok;
+  struct prod_token_parm_item *tok;
   unsigned int  ix;
 
   tok  =  value;
-  fprintf (file, "%d \"", tok->lineno);
-  for (ix  =  0; ix < tok->length; ix++)
-    fprintf (file, "%c", tok->chars[ix]);
+  fprintf (file, "%d \"", tok->tp.tok.lineno);
+  for (ix  =  0; ix < tok->tp.tok.length; ix++)
+    fprintf (file, "%c", tok->tp.tok.chars[ix]);
   fprintf (file, "\"");
 }
 
@@ -838,12 +839,12 @@ print_token (FILE * file, unsigned int type ATTRIBUTE_UNUSED, YYSTYPE value)
 void
 yyerror (const char *error_message)
 {
-  struct token *tok;
+  struct prod_token_parm_item *tok;
   
   tok = yylval;
   if (tok)
     {
-      fprintf (stderr, "%s:%i:%i: %s\n", in_fname, tok->lineno, tok->charno, error_message);
+      fprintf (stderr, "%s:%i:%i: %s\n", in_fname, tok->tp.tok.lineno, tok->tp.tok.charno, error_message);
       print_token (stderr, 0, tok);
     }
   else
@@ -856,12 +857,12 @@ yyerror (const char *error_message)
 /* Reverse the order of a token list, linked by parse_next, old first
    token is OLD_FIRST.  */
 
-static struct production*
-reverse_prod_list (struct production *old_first)
+static struct prod_token_parm_item*
+reverse_prod_list (struct prod_token_parm_item *old_first)
 {
-  struct production *current;
-  struct production *next;
-  struct production *prev = NULL;
+  struct prod_token_parm_item *current;
+  struct prod_token_parm_item *next;
+  struct prod_token_parm_item *prev = NULL;
   
   current = old_first;
   prev = NULL;
@@ -870,8 +871,8 @@ reverse_prod_list (struct production *old_first)
     {
       if (current->category != production_category)
         abort ();
-      next = current->next;
-      current->next = prev;
+      next = current->tp.pro.next;
+      current->tp.pro.next = prev;
       prev = current;
       current = next; 
     }
@@ -881,12 +882,12 @@ reverse_prod_list (struct production *old_first)
 /* Ensure TYPE is not VOID. Use NAME as the token for the error location.  */
 
 static void
-ensure_not_void (unsigned int type, struct token* name)
+ensure_not_void (unsigned int type, struct prod_token_parm_item* name)
 {
   if (type == VOID)
     {
       fprintf (stderr, "%s:%i:%i: Type must not be void in this context\n", in_fname, 
-              name->lineno, name->charno);
+              name->tp.tok.lineno, name->tp.tok.charno);
       print_token (stderr, 0, name);
       errorcount++;
     }
@@ -896,7 +897,7 @@ ensure_not_void (unsigned int type, struct token* name)
    common type (min is signed int).  */
 
 static int 
-get_common_type (struct production *type1, struct production *type2)
+get_common_type (struct prod_token_parm_item *type1, struct prod_token_parm_item *type2)
 {
   if (NUMERIC_TYPE (type1) == UNSIGNED_INT)
     return UNSIGNED_INT;
@@ -911,7 +912,7 @@ get_common_type (struct production *type1, struct production *type2)
    integral type.  */
 
 static int 
-check_type_match (int type_num, struct production *exp)
+check_type_match (int type_num, struct prod_token_parm_item *exp)
 {
   switch (type_num)
     {
@@ -946,27 +947,27 @@ check_type_match (int type_num, struct production *exp)
 
 /* Make a production for an integer constant VALUE.  */
 
-static struct production *
-make_integer_constant (struct token* value)
+static struct prod_token_parm_item *
+make_integer_constant (struct prod_token_parm_item* value)
 {
-  struct token* tok;
-  struct production *prod;
+  struct prod_token_parm_item* tok;
+  struct prod_token_parm_item *prod;
   tok = value;
   prod = make_production (PROD_INTEGER_CONSTANT, tok);
-  if ((tok->chars[0] == (unsigned char)'-')|| (tok->chars[0] == (unsigned char)'+'))
+  if ((tok->tp.tok.chars[0] == (unsigned char)'-')|| (tok->tp.tok.chars[0] == (unsigned char)'+'))
     NUMERIC_TYPE (prod) = SIGNED_INT;
   else
     NUMERIC_TYPE (prod) = UNSIGNED_INT;
-  prod->code = tree_code_get_integer_value (tok->chars, tok->length);
+  prod->tp.pro.code = tree_code_get_integer_value (tok->tp.tok.chars, tok->tp.tok.length);
   return prod;
 }
 
 /* Set STORAGE_CLASS in PROD according to CLASS_TOKEN.  */
 
 static void
-set_storage (struct production *prod)
+set_storage (struct prod_token_parm_item *prod)
 {
-  struct token* stg_class;
+  struct prod_token_parm_item* stg_class;
   stg_class = STORAGE_CLASS_TOKEN (prod);
   switch (stg_class->type)
     {

diff --git a/gcc/treelang/tree1.c b/gcc/treelang/tree1.c
index 5067bea22286c4e17010636c4af8716c5216cd20..bc54710f15a7736b98761c26c450a866faaaa3a7 100644 (file)
--- a/gcc/treelang/tree1.c
+++ b/gcc/treelang/tree1.c
@@ -35,7 +35,6 @@
 #include "system.h"
 #include "ansidecl.h"
 #include "flags.h"
-#include "output.h"
 #include "toplev.h"
 
 #include "ggc.h"
@@ -55,7 +54,7 @@
 extern int yyparse (void);
 /* Linked list of symbols - all must be unique in treelang.  */
 
-struct production *symbol_table = NULL;
+static GTY(()) struct prod_token_parm_item *symbol_table = NULL;
 
 /* Language for usage for messages.  */
 
@@ -65,9 +64,6 @@ const char *const language_string = "TREELANG - sample front end for GCC ";
 
 void version (void);
 
-/* GC routine for symbol table.  */
-static void symbol_table_ggc (void *m);
-
 /* Global variables.  */
 
 extern struct cbl_tree_struct_parse_tree_top* parse_tree_top;
@@ -191,18 +187,6 @@ treelang_decode_option (num_options_left, first_option_left)
 const char*
 treelang_init (const char* filename)
 {
-
-  /* Define my garbage collection routines.  */
-  ggc_add_root (&symbol_table, 1, 
-                /* Unused size.  */ sizeof (void*), symbol_table_ggc);
-  /* Note: only storage that has to be kept across functions needs to
-     be protected from GC.  */
-  /* Define my garbage collection routines.  */
-  ggc_add_root (&symbol_table, 1, 
-                /* Unused size.  */ sizeof (void*), symbol_table_ggc);
-  /* Note: only storage that has to be kept across functions needs to
-     be protected from GC.  */
-
   /* Set up the declarations needed for this front end.  */
 
   input_filename = "";
@@ -250,58 +234,6 @@ treelang_parse_file (int debug_flag ATTRIBUTE_UNUSED)
   yyparse ();
 }
 
-
-/* Scan the symbol table* M, marking storage used.  */
-
-static void
-symbol_table_ggc (void *m)
-{
-  struct production *pp;
-  pp = * (struct production**)m;
-  /* Actually it is a pointer to a pointer, to allow reallocation and
-     relinking.  */
-  mark_production_used (pp);
-}
-
-/* Mark a production PP as used so it wont be garbage collected.  */
-
-void
-mark_production_used (struct production *pp)
-{
-  int sub_ix;
- loop:
-  if (!pp)
-    return;
-  ggc_mark (pp);
-  
-  if (pp->category == token_category)
-    {
-      mark_token_used ((struct token*)pp);
-      return;
-    }
-  if (pp->category != production_category)
-    abort ();
-  mark_token_used (pp->main_token);
-  for (sub_ix = 0; sub_ix < SUB_COUNT; sub_ix++)
-    mark_production_used (pp->sub[sub_ix]);
-  /* The macro tests for NULL so I don't need to.  */
-  ggc_mark_tree (pp->code);
-  pp = pp->next;
-  goto loop;
-}
-
-/* Mark a token TT as used so it wont be garbage collected.  */
-
-void
-mark_token_used (struct token* tt)
-{
-  if (!tt) 
-    return;
-  ggc_mark (tt);
-  if (tt->chars)
-    ggc_mark (tt->chars);
-}
-
 /* Allocate SIZE bytes and clear them.  */
 
 void *
@@ -322,45 +254,46 @@ my_malloc (size_t size)
    return the symbol table entry from the symbol table if found there,
    else 0.  */
 
-struct production*
-lookup_tree_name (struct production *prod)
+struct prod_token_parm_item*
+lookup_tree_name (struct prod_token_parm_item *prod)
 {
-  struct production *this;
-  struct token* this_tok;
-  struct token* tok;
+  struct prod_token_parm_item *this;
+  struct prod_token_parm_item *this_tok;
+  struct prod_token_parm_item *tok;
   tok = SYMBOL_TABLE_NAME (prod);
-  for (this = symbol_table; this; this = this->next)
+  for (this = symbol_table; this; this = this->tp.pro.next)
     {
-      this_tok = this->main_token;
-      if (tok->length != this_tok->length) 
+      this_tok = this->tp.pro.main_token;
+      if (tok->tp.tok.length != this_tok->tp.tok.length) 
         continue;
-      if (memcmp (tok->chars, this_tok->chars, this_tok->length))
+      if (memcmp (tok->tp.tok.chars, this_tok->tp.tok.chars, this_tok->tp.tok.length))
         continue;
       if (option_parser_trace)
-        fprintf (stderr, "Found symbol %s (%i:%i) as %i \n", tok->chars, 
-                tok->lineno, tok->charno, NUMERIC_TYPE (this));
+        fprintf (stderr, "Found symbol %s (%i:%i) as %i \n", tok->tp.tok.chars, 
+                tok->tp.tok.lineno, tok->tp.tok.charno, NUMERIC_TYPE (this));
       return this;
     }
   if (option_parser_trace)
-    fprintf (stderr, "Not found symbol %s (%i:%i) as %i \n", tok->chars, 
-            tok->lineno, tok->charno, tok->type);
+    fprintf (stderr, "Not found symbol %s (%i:%i) as %i \n", tok->tp.tok.chars, 
+            tok->tp.tok.lineno, tok->tp.tok.charno, tok->type);
   return NULL;
 }
 
 /* Insert name PROD into the symbol table.  Return 1 if duplicate, 0 if OK.  */
 
 int
-insert_tree_name (struct production *prod)
+insert_tree_name (struct prod_token_parm_item *prod)
 {
-  struct token* tok;
+  struct prod_token_parm_item *tok;
   tok = SYMBOL_TABLE_NAME (prod);
   if (lookup_tree_name (prod))
     {
-      fprintf (stderr, "%s:%i:%i duplicate name %s\n", in_fname, tok->lineno, tok->charno, tok->chars);
+      fprintf (stderr, "%s:%i:%i duplicate name %s\n", in_fname, tok->tp.tok.lineno, 
+               tok->tp.tok.charno, tok->tp.tok.chars);
       errorcount++;
       return 1;
     }
-  prod->next = symbol_table;
+  prod->tp.pro.next = symbol_table;
   NESTING_LEVEL (prod) = work_nesting_level;
   symbol_table = prod;
   return 0;
@@ -368,15 +301,19 @@ insert_tree_name (struct production *prod)
 
 /* Create a struct productions of type TYPE, main token MAIN_TOK.  */
 
-struct production *
-make_production (int type, struct token* main_tok)
+struct prod_token_parm_item *
+make_production (int type, struct prod_token_parm_item *main_tok)
 {
-  struct production *prod;
-  prod = my_malloc (sizeof (struct production));
+  struct prod_token_parm_item *prod;
+  prod = my_malloc (sizeof (struct prod_token_parm_item));
   prod->category = production_category;
   prod->type = type;
-  prod->main_token = main_tok;
+  prod->tp.pro.main_token = main_tok;
   return prod;
 } 
 
 
+/* New garbage collection regime see gty.texi.  */
+#include "gt-treelang-tree1.h"
+/*#include "gt-treelang-treelang.h"*/
+#include "gtype-treelang.h"

diff --git a/gcc/treelang/treelang.h b/gcc/treelang/treelang.h
index a265738423f31152fff54213dcc1b22a8c13f17c..f42a2e2e2e94a394e4c9feeef401899fe0675fde 100644 (file)
--- a/gcc/treelang/treelang.h
+++ b/gcc/treelang/treelang.h
@@ -35,64 +35,57 @@ enum category_enum
 { /* These values less likely to be there by chance unlike 0/1,
       make checks more meaningful */
   token_category = 111,
-  production_category = 222
+  production_category = 222,
+  parameter_category = 333
 };
 
 /* Input file name and FILE.  */
 extern unsigned char* in_fname;
 extern FILE* yyin;
 
-#if 0
-extern int errorcount; /* In toplev.c.  */
-#endif
+/* Forward references to satisfy mutually recursive definitions.  */
+struct token_part;
+struct production_part;
+struct prod_token_parm_item;
+typedef struct GTY(()) prod_token_parm_item item;
 
-struct token
+/* A token from the input file.  */
+
+struct token_part GTY(())
 {
-  enum category_enum category; /* Token or production. */
-  unsigned int type; /* Token type.  */
-  /* Prior to this point, production must match token.  */
   unsigned int lineno;
   unsigned int charno;
   unsigned int length; /* The value.  */
   unsigned char* chars;
 };
 
-struct production
+/* Definitions for fields in production.  */
+#define NESTING_LEVEL(a) a->tp.pro.info[0]  /* Level used for variable definitions.  */
+#define NUMERIC_TYPE(a)  a->tp.pro.info[1]  /* Numeric type used in type definitions and expressions.  */
+#define SUB_COUNT 5
+#define SYMBOL_TABLE_NAME(a) (a->tp.pro.sub[0]) /* Name token.  */
+#define EXPRESSION_TYPE(a) (a->tp.pro.sub[1]) /* Type identifier.  */
+#define OP1(a) (a->tp.pro.sub[2]) /* Exp operand1.  */
+#define PARAMETERS(a) (a->tp.pro.sub[2]) /* Function parameters.  */
+#define VARIABLE(a) (a->tp.pro.sub[2]) /* Parameter variable ptr.  */
+#define VAR_INIT(a) (a->tp.pro.sub[2]) /* Variable init.  */
+#define OP2(a) (a->tp.pro.sub[3]) /* Exp operand2.  */
+#define FIRST_PARMS(a) (a->tp.pro.sub[3]) /* Function parameters linked via struct tree_parameter_list.  */
+#define OP3(a) (a->tp.pro.sub[4]) /* Exp operand3.  */
+#define STORAGE_CLASS_TOKEN(a) (a->tp.pro.sub[4]) /* Storage class token.  */
+#define STORAGE_CLASS(a) a->tp.pro.flag1 /* Values in treetree.h.  */
+
+struct production_part GTY(())
 {
-  enum category_enum category; /* Token or Production. */
-  unsigned int type; /* Production type - a fake token name.  */
-  /* Prior to this point, production must match token.  */
-  struct token* main_token; /* Main token for error msgs; variable name token.  */
+  struct prod_token_parm_item *main_token; /* Main token for error msgs; variable name token.  */
 
   unsigned int info[2]; /* Extra information.  */
-#define NESTING_LEVEL(a) a->info[0]  /* Level used for variable definitions.  */
-#define NUMERIC_TYPE(a)  a->info[1]  /* Numeric type used in type definitions and expressions.  */
-
-
-#define SUB_COUNT 5
-  void *sub[SUB_COUNT]; /* Sub productions or tokens.  */
-
-#define SYMBOL_TABLE_NAME(a) (a->sub[0]) /* Name token.  */
-
-#define EXPRESSION_TYPE(a) (a->sub[1]) /* Type identifier.  */
-
-#define OP1(a) (a->sub[2]) /* Exp operand1.  */
-#define PARAMETERS(a) (a->sub[2]) /* Function parameters.  */
-#define VARIABLE(a) (a->sub[2]) /* Parameter variable ptr.  */
-#define VAR_INIT(a) (a->sub[2]) /* Variable init.  */
-
-#define OP2(a) (a->sub[3]) /* Exp operand2.  */
-#define FIRST_PARMS(a) (a->sub[3]) /* Function parameters linked via struct tree_parameter_list.  */
 
-#define OP3(a) (a->sub[4]) /* Exp operand3.  */
-#define STORAGE_CLASS_TOKEN(a) (a->sub[4]) /* Storage class token.  */
-
-  void *code; /* Back end hook for this item.  */
-  struct production *next; /* Next in chains of various types.  */
+  struct prod_token_parm_item *sub[SUB_COUNT]; /* Sub productions or tokens.  */
+  tree code; /* Back end hook for this item.  */
+  struct prod_token_parm_item *next; /* Next in chains of various types.  */
 
   unsigned int flag1:2;
-#define STORAGE_CLASS(a) a->flag1 /* Values in treetree.h.  */
-
   unsigned int flag2:1;
   unsigned int flag3:1;
   unsigned int flag4:1;
@@ -102,15 +95,58 @@ struct production
 
 };
 
+/* Storage modes.  */
+#define STATIC_STORAGE 0
+#define AUTOMATIC_STORAGE 1
+#define EXTERNAL_REFERENCE_STORAGE 2
+#define EXTERNAL_DEFINITION_STORAGE 3
+
+/* Numeric types.  */
+#define SIGNED_CHAR 1
+#define UNSIGNED_CHAR 2
+#define SIGNED_INT 3 
+#define UNSIGNED_INT 4
+#define VOID_TYPE 5
+
+/* Expression types.  */
+#define EXP_PLUS 0 /* Addition expression.  */
+#define EXP_REFERENCE 1 /* Variable reference.  */
+#define EXP_ASSIGN 2 /* Assignment.  */
+#define EXP_FUNCTION_INVOCATION 3  /* Call function.  */
+#define EXP_MINUS 4  /* Subtraction.  */
+#define EXP_EQUALS 5  /* Equality test.  */
+
+/* Parameter list passed to back end.  */
+struct parameter_part GTY(())
+{
+  struct prod_token_parm_item *next; /* Next entry.  */
+  unsigned char* variable_name; /* Name. */
+  tree * GTY ((length ("1"))) where_to_put_var_tree; /* Where to save decl.  */
+};
+
+/* A production or a token.  */
+struct prod_token_parm_item GTY(())
+{
+  enum category_enum category; /* Token or production. */
+  unsigned int type; /* Token or production type.  */
+  union t_or_p
+  {
+    struct token_part GTY((tag ("token_category"))) tok;
+    struct production_part GTY((tag ("production_category"))) pro;
+    struct parameter_part GTY((tag ("parameter_category"))) par;
+  } GTY((desc ("((item *)&%1)->category"))) tp;
+};
+
+
 /* For parser. Alternatively you can define it using %union (bison) or
    union. */
 #define YYSTYPE void *
 
 void *my_malloc (size_t size);
-int insert_tree_name (struct production *prod);
-struct production *lookup_tree_name (struct production *prod);
-struct production *make_production (int type, struct token* main_tok);
-void mark_production_used (struct production * pp);
-void mark_token_used (struct token* tt);
+int insert_tree_name (struct prod_token_parm_item *prod);
+struct prod_token_parm_item *lookup_tree_name (struct prod_token_parm_item *prod);
+struct prod_token_parm_item *make_production (int type, struct prod_token_parm_item *main_tok);
+void mark_production_used (struct prod_token_parm_item *pp);
+void mark_token_used (struct prod_token_parm_item *tt);
 void treelang_debug (void);
 

diff --git a/gcc/treelang/treetree.c b/gcc/treelang/treetree.c
index 2cb57ff32376b3990edca57a3ff2c6cee504b1e0..2d05ce1bbf4851885a1befcd96016c5926d4088f 100644 (file)
--- a/gcc/treelang/treetree.c
+++ b/gcc/treelang/treetree.c
@@ -70,21 +70,21 @@
 
 /* GCC headers.  */
 
-#include "ansidecl.h"
 #include "config.h"
+#include "ansidecl.h"
 #include "system.h"
 #include "tree.h"
 #include "flags.h"
 #include "output.h"
 #include "c-tree.h"
 #include "rtl.h"
-#include "tm_p.h"
 #include "ggc.h"
 #include "toplev.h"
 #include "varray.h"
 #include "langhooks-def.h"
 #include "langhooks.h"
 
+#include "treelang.h"
 #include "treetree.h"
 
 extern int option_main;
@@ -163,14 +163,6 @@ const char *const tree_code_name[] = {
 unsigned int tree_code_int_size = 0;
 unsigned int tree_code_char_size = 0;
 
-/* In this case there is very little to keep between functions - we
-   keep the symbol table only and the things that hang off that - see
-   tree1.c.  Garbage collection is only invoked when we call
-   rest_of_compilation at the end of a function. */
-
-#define ADDROOT(where) ggc_add_root (&where, 1, /* Unused size.  */ sizeof (void*), \
- tree_ggc_storage_always_used);
-
 /* Return the tree stuff for this type TYPE_NUM.  */
 
 tree 
@@ -242,13 +234,13 @@ tree
 tree_code_create_function_prototype (unsigned char* chars,
                                     unsigned int storage_class,
                                     unsigned int ret_type,
-                                    struct tree_parameter_list* parms,
+                                    struct prod_token_parm_item* parms,
                                     unsigned char* filename,
                                     int lineno)
 {
 
   tree id;
-  struct tree_parameter_list* parm;
+  struct prod_token_parm_item* parm;
   tree type_list = NULL_TREE;
   tree type_node;
   tree fn_type;
@@ -256,7 +248,7 @@ tree_code_create_function_prototype (unsigned char* chars,
 
   /* Build the type.  */
   id = get_identifier ((const char*)chars);
-  for (parm = parms; parm; parm = parm->next)
+  for (parm = parms; parm; parm = parm->tp.par.next)
     {
       type_node = get_type_for_numeric_type (parm->type);
       type_list = tree_cons (NULL_TREE, type_node, type_list);
@@ -328,7 +320,7 @@ void
 tree_code_create_function_initial (tree prev_saved, 
                                   unsigned char* filename,
                                   int lineno,
-                                  struct tree_parameter_list* parms)
+                                  struct prod_token_parm_item* parms)
 {
   tree fn_decl;
   tree param_decl;
@@ -337,8 +329,8 @@ tree_code_create_function_initial (tree prev_saved,
   tree parm_decl;
   tree parm_list;
   tree resultdecl;
-  struct tree_parameter_list* this_parm; 
-  struct tree_parameter_list* parm;
+  struct prod_token_parm_item* this_parm; 
+  struct prod_token_parm_item* parm;
 
   fn_decl = prev_saved;
   if (!fn_decl)
@@ -368,10 +360,11 @@ tree_code_create_function_initial (tree prev_saved,
 
   /* Make the argument variable decls.  */
   parm_list = NULL_TREE;
-  for (parm = parms; parm; parm = parm->next)
+  for (parm = parms; parm; parm = parm->tp.par.next)
     {
-      parm_decl = build_decl (PARM_DECL, get_identifier ((const char*) (parm->variable_name)), 
-                           get_type_for_numeric_type (parm->type));
+      parm_decl = build_decl (PARM_DECL, get_identifier 
+                              ((const char*) (parm->tp.par.variable_name)), 
+                              get_type_for_numeric_type (parm->type));
       
       /* Some languages have different nominal and real types.  */
       DECL_ARG_TYPE (parm_decl) = TREE_TYPE (parm_decl);
@@ -395,11 +388,11 @@ tree_code_create_function_initial (tree prev_saved,
          this_parm = parms;
        param_decl;
        param_decl = TREE_CHAIN (param_decl),
-         this_parm = this_parm->next)
+         this_parm = this_parm->tp.par.next)
     {
       if (!this_parm)
         abort (); /* Too few.  */
-      *this_parm->where_to_put_var_tree = param_decl;
+      *this_parm->tp.par.where_to_put_var_tree = param_decl;
     }
   if (this_parm)
     abort (); /* Too many.  */
@@ -1032,8 +1025,16 @@ handle_format_arg_attribute (tree *node ATTRIBUTE_UNUSED,
 int
 cpp_handle_option (cpp_reader *pfile ATTRIBUTE_UNUSED,
      int argc ATTRIBUTE_UNUSED,
-     char **argv ATTRIBUTE_UNUSED,
-     int ignore ATTRIBUTE_UNUSED)
+     char **argv ATTRIBUTE_UNUSED)
+{
+  abort ();
+}
+
+/* Should not be called for treelang.   */
+
+void 
+cpp_assert (cpp_reader * cr ATTRIBUTE_UNUSED, 
+            const char *s ATTRIBUTE_UNUSED)
 {
   abort ();
 }

diff --git a/gcc/treelang/treetree.h b/gcc/treelang/treetree.h
index 24b72e385fc77a5a190619d8c229197dc71418b0..e394ebae8e022b4f6373903cfc3c9d829bfc4bb3 100644 (file)
--- a/gcc/treelang/treetree.h
+++ b/gcc/treelang/treetree.h
@@ -31,15 +31,6 @@
 
  */
 
-/* Parameter list passed to back end.  */
-struct tree_parameter_list 
-{
-  struct tree_parameter_list* next; /* Next entry.  */
-  int   type; /* See numeric types below.  */
-  unsigned char* variable_name; /* Name. */
-  tree* where_to_put_var_tree; /* Where to save decl.  */
-};
-
 tree tree_code_init_parameters (void);
 tree tree_code_add_parameter (tree list, tree proto_exp, tree exp);
 tree tree_code_get_integer_value (unsigned char *chars, unsigned int length);
@@ -49,12 +40,12 @@ tree tree_code_get_expression (unsigned int exp_type, tree type, tree op1, tree
 tree tree_code_get_numeric_type (unsigned int size1, unsigned int sign1);
 void tree_code_create_function_initial (tree prev_saved,
                                        unsigned char* filename, int lineno,
-                                       struct tree_parameter_list* parms);
+                                       struct prod_token_parm_item* parms);
 void tree_code_create_function_wrapup (unsigned char* filename, int lineno);
 tree tree_code_create_function_prototype (unsigned char* chars,
                                          unsigned int storage_class,
                                          unsigned int ret_type,
-                                         struct tree_parameter_list* parms,                                 
+                                         struct prod_token_parm_item* parms,                                 
                                          unsigned char* filename,
                                          int lineno);
 tree tree_code_create_variable (unsigned int storage_class,
@@ -78,24 +69,5 @@ void treelang_parse_file (int debug_flag);
 void push_var_level (void);
 void pop_var_level (void);
 
-/* Storage modes.  */
-#define STATIC_STORAGE 0
-#define AUTOMATIC_STORAGE 1
-#define EXTERNAL_REFERENCE_STORAGE 2
-#define EXTERNAL_DEFINITION_STORAGE 3
-
-
-/* Numeric types.  */
-#define SIGNED_CHAR 1
-#define UNSIGNED_CHAR 2
-#define SIGNED_INT 3 
-#define UNSIGNED_INT 4
-#define VOID_TYPE 5
 
 
-#define EXP_PLUS 0 /* Addition expression.  */
-#define EXP_REFERENCE 1 /* Variable reference.  */
-#define EXP_ASSIGN 2 /* Assignment.  */
-#define EXP_FUNCTION_INVOCATION 3  /* Call function.  */
-#define EXP_MINUS 4  /* Subtraction.  */
-#define EXP_EQUALS 5  /* Equality test.  */