Infrastructure for storing line number information

outside of the code, in hash tables.

* filter.c (make_trie, trie_add): Update to three-argument
make_hash.

* hash.c (struct hash): New members, hash_fun, assoc_fun
acons_new_l_fun.
(ll_hash): Renamed to equal_hash.
(eql_hash): New static function.
(cobj_hash_op): Follows ll_hash rename.
(hash_grow): Use new function indirection to call hashing function.
(make_hash): New argument to specify type of hashing. Initialize new
members of struct hash.
(gethash_l, gethash, remhash): Use function indirection for hashing and
chain search and update.
(pushhash): New function.

* hash.h (make_hash): Declaration updated with new parameter.
(pushhash): Declared.

* lib.c (eql_f): New global variable.
(eql, assq, aconsq_new, aconsq_new_l): New functions.
(make_package): Updated to new three-argument make_hash.
(obj_init): gc-protect and initialize new variable eql_f.

* lib.h (eql, assq, aconsq_new, aconsq_new_l): Declared.

* match.c (dir_tables_init): Updated to there-argument make_hash.

* parser.h (form_to_ln_hash, ln_to_forms_hash): Global variables
declared.

* parser.l (form_to_ln_hash, ln_to_forms_hash): New global variables.
(grammar): Set yylval.lineno for tokens that are classified to
that type in parser.y.
(parse_init): Initialize and gc-protect new global variables.

* parser.y (rl): New static helper function.
(%union): New member, lineno.
(ALL, SOME, NONE, MAYBE, CASES, CHOOSE, GATHER,
AND, OR, END, COLLECT, UNTIL, COLL, OUTPUT, REPEAT,
REP, SINGLE, FIRST, LAST, EMPTY, DEFINE,
TRY, CATCH, FINALLY, ERRTOK, '('): Reclassified as lineno type.
In the grammar, these keywords can thus provide a stable line number
from the lexer.
(grammar): Numerous rules updated to add constructs to the
line number hash tables via the rl helper.

* dep.mk: Updated.

* Makefile (depend): Use the installed, stable txr in the
system path to update dependencies rather than locally built ./txr, to
prevent the problem that txr is broken because out out-of-date
dependencies, and thus cannot regenerate dependencies.

1 files changed, 34 insertions, 1 deletions

diff --git a/parser.l b/parser.l
index 897c6532..4fe0e521 100644
--- a/parser.l
+++ b/parser.l
@@ -43,6 +43,7 @@
 #include "stream.h"
 #include "utf8.h"
 #include "unwind.h"
+#include "hash.h"
 #include "parser.h"
 
 #define YY_INPUT(buf, result, max_size)           \
@@ -66,6 +67,9 @@ int opt_loglevel = 1;   /* 0 - quiet; 1 - normal; 2 - verbose */
 
 int errors;
 
+val form_to_ln_hash;
+val ln_to_forms_hash;
+
 static val prepared_error_message;
 
 void yyerror(const char *s)
@@ -210,122 +214,146 @@ UONLY   {U2}{U}|{U3}{U}{U}|{U4}{U}{U}{U}
 
 <SPECIAL>\({WS}all{WS}\)        {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return ALL;
                                 }
 
 <SPECIAL>\({WS}some{WS}\)       {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return SOME;
                                 }
 
 <SPECIAL>\({WS}none{WS}\)       {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return NONE;
                                 }
 
 <SPECIAL>\({WS}maybe{WS}\)      {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return MAYBE;
                                 }
 
 <SPECIAL>\({WS}cases{WS}\)      {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return CASES;
                                 }
 
 <SPECIAL>\({WS}choose/{ID_END}  {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return CHOOSE;
                                 }
 
 <SPECIAL>\({WS}gather/{ID_END}  {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return GATHER;
                                 }
 
 <SPECIAL>\({WS}and{WS}\)        {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return AND;
                                 }
 
 <SPECIAL>\({WS}or{WS}\)         {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return OR;
                                 }
 
 <SPECIAL>\({WS}end{WS}\)        {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return END;
                                 }
 
 <SPECIAL>\({WS}collect/{ID_END} {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return COLLECT;
                                 }
 
 <SPECIAL>\({WS}coll/{ID_END}    {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return COLL;
                                 }
 
 <SPECIAL>\({WS}until{WS}\)      {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return UNTIL;
                                 }
 
 <SPECIAL>\({WS}output/{ID_END}  {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return OUTPUT;
                                 }
 
 <SPECIAL>\({WS}repeat{WS}\)     {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return REPEAT;
                                 }
 
 
 <SPECIAL>\({WS}rep{WS}\)        {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return REP;
                                 }
 
 <SPECIAL>\({WS}single{WS}\)     {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return SINGLE;
                                 }
 
 <SPECIAL>\({WS}first{WS}\)      {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return FIRST;
                                 }
 
 <SPECIAL>\({WS}last{WS}\)       {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return LAST;
                                 }
 
 <SPECIAL>\({WS}empty{WS}\)      {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return EMPTY;
                                 }
 
 <SPECIAL>\({WS}define/{ID_END}  {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return DEFINE;
                                 }
 
 <SPECIAL>\({WS}try{WS}\)        {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return TRY;
                                 }
 
 <SPECIAL>\({WS}catch/{ID_END}   {
                                   yy_push_state(NESTED);
+                                  yylval.lineno = lineno;
                                   return CATCH;
                                 }
 
 <SPECIAL>\({WS}finally{WS}\)    {
                                   yy_pop_state();
+                                  yylval.lineno = lineno;
                                   return FINALLY;
                                 }
 
@@ -339,6 +367,7 @@ UONLY   {U2}{U}|{U3}{U}{U}|{U4}{U}{U}{U}
                             yylval.chr = '(';
                             return METAPAR;
                           }
+                          yylval.lineno = lineno;
                           return yytext[0];
                         }
 
@@ -594,5 +623,9 @@ void end_of_regex(void)
 
 void parse_init(void)
 {
-  protect(&yyin_stream, &prepared_error_message, (val *) 0);
+  protect(&yyin_stream, &prepared_error_message,
+          &form_to_ln_hash, &ln_to_forms_hash, (val *) 0);
+
+  form_to_ln_hash = make_hash(t, nil, nil);
+  ln_to_forms_hash = make_hash(nil, t, nil);
 }