开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > SQL Server > 查看源码
trl_dump.c
资源名称：gnusql-0.7b5.1.tar.gz　[点击查看]
上传用户：dgyhgb
上传日期：2007-01-07
资源大小：676k
文件大小：31k
源码类别：

SQL Server

开发平台：

Unix_Linux

trl_dump.c：源码内容
  1. /*
  2.  *  trl_dump.c  - support library for dumping and reading tree of 
  3.  *                GNU SQL compiler
  4.  *
  5.  *  This file is a part of GNU SQL Server
  6.  *
  7.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  8.  *  Developed at the Institute of System Programming
  9.  *  This file is written by Michael Kimelman
  10.  *
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License
  22.  *  along with this program; if not, write to the Free Software
  23.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24.  *
  25.  *  Contacts: gss@ispras.ru
  26.  *
  27.  */
  29. /* $Id: trl_dump.c,v 1.246 1997/03/31 11:01:48 kml Exp $ */
  31. #include <assert.h>
  32. #include "trl.h"
  33. #include "trlinter.h"
  34. #include "tree_gen.h"
  35. #include "type_lib.h"
  37. /*******==================================================*******
  38. *******      Printing trn for debugging dumps.             *******
  39. *******==================================================*******/
  40. static i4_t vcb_dump_in_progress = 0;
  41. static FILE *outfl = NULL;
  42. char spaces[]=
  43. "                                                                            "
  44. "                                                                            "
  45. "                                                                            "
  46. "                                                                            "
  47.  ;
  49. static i4_t sawclose = 0;
  50. static i4_t backlay = 0;
  51. static i4_t just_for_info = 0;
  53. #define PRINT_INDENT fprintf (outfl, "n%s%s", (just_for_info?";;":""),
  54.                               spaces + sizeof spaces - indent*2)
  55. #define INC_INDENT indent+=1
  56. #define DEC_INDENT indent-=1
  58. /* Print IN_TRN onto OUTFL.  This is the recursive part of printing.  */
  59. static void
  60. print_trn (trn in_trn, char type_mode,i4_t go_right)
  61. {
  63.   static i4_t indent = 1;
  64.   static i4_t clr_pattern = 0;
  65.   static i4_t check_integrity = 1;
  66.   register enum token code;
  67.   register i4_t i, j, sc, type_vcb_subtree = 1;
  68.   register char *format_ptr;
  69.   TXTREF   lvr = TNULL;
  70.   TXTREF parm;
  71.   i4_t printback, jfi = 0;
  72.   trn in_trn1 = in_trn;
  73.   printback = 0;
  74.   if (type_mode == 'P')
  75.     type_mode = 't';
  76.   if (indent < 0)
  77.     indent = 0;
  79.   sc = 0;
  80.   if (in_trn)
  81.     code = in_trn->code;
  82.   else
  83.     code = NIL_CODE;
  84.   if (code <= UNKNOWN || code >= LAST_TOKEN)
  85.     {
  86.       sc = code;
  87.       code = UNKNOWN;
  88.     }
  89.   if (code == SKIP_CODE)
  90.     {
  91.       fputs (" - ", outfl);
  92.       goto GO_RIGHT;
  93.     }
  94.   else if (code == SKIP_CODES)
  95.     {
  96.       fputs (" -- ", outfl);
  97.       goto GO_RIGHT;
  98.     }
  99.   /* print name of expression code */
  101.   if (code <= NIL_CODE)
  102.     {
  103.       fprintf (outfl, " (%s)", NAME (code));
  104.       if (sc)
  105.         {
  106.           fprintf (outfl, "  ;; !!!!! code value ==%d", sc);
  107.           sawclose = 1;
  108.         }
  109.       return;
  110.     }
  111.   else if (Tstf_TRN (in_trn, MARK_F))
  112.     {
  113.       fprintf (outfl, " (%s:mark_f)", NAME (code));
  114.       return; 
  115.       /* goto GO_RIGHT; */
  116.     }
  117.   
  118.   if (sawclose)
  119.     {
  120.       PRINT_INDENT;
  121.       sawclose = 0;
  122.     }
  123.   else
  124.     PRINT_INDENT;
  126.   if (Is_statement(in_trn))
  127.     {
  128.       PRINT_INDENT;
  129.       fprintf (outfl, ";;-------------------------------");
  130.       PRINT_INDENT;
  131.     }
  132. #if 0
  133.   fprintf (outfl, "(/*%p*/%s",in_trn, NAME (code));
  134. #else
  135.   fprintf (outfl, "(%s",NAME (code));
  136. #endif
  138.   /* print flags */
  139.   i = MASk_TRN (in_trn) & (FLAG_VALUE (VCB_F) - 1);
  140.   if (i)
  141.     fprintf (outfl, ":%d", i - 1);
  142.   for (i = VCB_F; i < LAST_FLAG; i++)
  143.     if (compatible_tok_fl (code, (enum flags) i))
  144.       if (Tstf_TRN (in_trn, (enum flags) i))
  145. if ((i != PATTERN_F) || (clr_pattern == 0))
  146.   fprintf (outfl, ":%s", NAME_FL ((enum flags) i));
  147.   fputs ("  ", outfl);
  149.   if (Is_statement(in_trn) || (code==VIEW))
  150.     {
  151.       register TXTREF v;
  152.       lvr = LOCAL_VCB_ROOT;
  153. #if 0
  154.       v = XVCb_TRN (in_trn, 7);
  155.       if ( v || go_right)
  156.         LOCAL_VCB_ROOT = v;
  157. #else
  158.       LOCAL_VCB_ROOT = (code==VIEW?VIEw_VCB(in_trn):XVCb_TRN (in_trn, 7));
  159. #endif
  160.       for (v = LOCAL_VCB_ROOT; v; v = RIGHT_TRN (v))
  161. {
  162.   if (TstF_TRN(v,MARK1_F))
  163.             {
  164.               ClrF_TRN (v, MARK1_F);
  165.               yyerror("? ?");
  166.               errors--;
  167.             }
  168. }
  169.     }
  170.   
  171.   if (Is_table (in_trn) || (code==SCAN))
  172.     {
  173.       if (!Tstf_TRN (in_trn, MARK1_F))
  174.         Setf_TRN (in_trn, MARK1_F);
  175.       else /* if (code!=SCAN) */
  176.         type_vcb_subtree = 0;
  177.     }
  178.   if (Tstf_TRN(in_trn,VCB_F) && check_integrity && (Is_table (in_trn) || (code==SCAN)))
  179.     {
  180.       TXTREF v;
  181.       if ((code == SCAN) || (code==TMPTABLE))
  182.         v = LOCAL_VCB_ROOT;
  183.       else
  184.         v = VCB_ROOT;
  185.       for (; v; v = RIGHT_TRN(v))
  186.         if ( Ptree(v) == in_trn )
  187.           break;
  188.       if (!v) /* IF node not found in vocabulary */
  189.         {
  190.           check_integrity = 0;
  191.           trl_wrn("vcb node not in vcb list",__FILE__,__LINE__,in_trn);
  192.         }
  193.     }
  194.   Setf_TRN (in_trn, MARK_F);
  196.   format_ptr = FORMAT (code);
  198.   for (i = 0; i < LENGTH (code); i++, format_ptr++)
  199.     {
  200.       
  201. #define TST_PAT_BIT(n) TST_BIT(XLNg_TRN(in_trn,PTRN_OP(code,n)),PTRN_BIT(n))
  202.       
  203.       if ( Tstf_TRN(in_trn,ACTION_F) && TST_PAT_BIT(i) )
  204.         {
  205.           fprintf(outfl," <%s> ",STRING(XLTr_TRN(in_trn,i)));
  206.           continue;
  207.         }
  209.       if ((!type_vcb_subtree) && (*format_ptr != 's') &&
  210.           ((code!=SCAN) || (*format_ptr!='t') ))
  211.         continue;
  212.       
  213.       if ((type_vcb_subtree) && (*format_ptr == 'V') &&
  214.           (code==SCAN) && XTXt_TRN(in_trn,i))
  215.         {
  216.           just_for_info++; jfi = 1; /* type scolumn list */
  217.           goto case_n;
  218.         }
  219.       
  220.       switch (*format_ptr)
  221.         {
  222.         case 's':
  223.         case 'S':
  224.           sawclose = 0;
  225.           if (XLTr_TRN (in_trn, i) == 0)
  226.             fprintf (outfl, " """);
  227.           else
  228.             {
  229.               fprintf (outfl, " "%s"", STRING (XLTr_TRN (in_trn, i)));
  230.               sawclose = 1;
  231.             }
  232.           break;
  234.           /* 0 indicates a field for internal use that should not be printed.  */
  235.         case '0':
  236.         case 'r':
  237.         case 'a':
  238.         case 'd':
  239.           break;
  241.         case 'V': /* special vocabulary reference (backward link) */
  242.           if (backlay == 0)
  243.             break;
  244.           printback++;
  245.           backlay--;
  246.         case 't':
  247.         case 'P': /* pattern tree */
  248.         case 'v':
  249.           if ((type_mode == 't') || (*format_ptr == 't') || (*format_ptr == 'P'))
  250.             {
  251.               i4_t old_clr_pat = clr_pattern;
  252.               INC_INDENT;
  253.               if (!sawclose)
  254.                 fprintf (outfl, " ");
  255.               if (*format_ptr == 'P')
  256.                 clr_pattern = 1;
  257.               if (type_vcb_subtree)
  258.                 print_trn (Ptree (XTXt_TRN (in_trn, i)), *format_ptr,0);
  259.               else
  260.                 fprintf (outfl, " (nil /**/)");
  261.               DEC_INDENT;
  262.               clr_pattern = old_clr_pat;
  263.             }
  264.           if (printback)
  265.             {
  266.               backlay++;
  267.               printback--;
  268.             }
  269.           break;
  271.         case 'p':
  272.           if (!Tstf_TRN (in_trn, PATTERN_F))
  273.             {
  274.               fprintf (outfl, " line:%d", (i4_t) LOCATIOn_TRN (in_trn));
  275.               sawclose = 0;
  276.             }
  277.           break;
  279.         case 'y':
  280.           {
  281.             char s[20];
  282.             conv_type (s, &XOp_TRN (in_trn, i).type, 0);
  283.             fprintf (outfl, " %s", s);
  284.             sawclose = 0;
  285.           }
  286.           break;
  288.         case 'i':
  289.           fprintf (outfl, " %d", (i4_t) XLNg_TRN (in_trn, i));
  290.           sawclose = 0;
  291.           break;
  293.         case 'x':
  294.           fprintf (outfl, " %x", XLNg_TRN (in_trn, i));
  295.           sawclose = 0;
  296.           break;
  298.         case 'l':
  299.           fprintf (outfl, " %d", XLNg_TRN (in_trn, i));
  300.           sawclose = 0;
  301.           break;
  303.         case 'R':
  304.           fprintf (outfl, " R:%d", XLNg_TRN (in_trn, i));
  305.           sawclose = 0;
  306.           break;
  308.         case 'f':
  309.           fprintf (outfl, " %f", XFLt_TRN (in_trn, i));
  310.           sawclose = 0;
  311.           break;
  313.         case 'T':
  314.         case 'L':
  315.           INC_INDENT;
  316.           if (TNULL != XVEc_TRN (in_trn, i) && type_vcb_subtree)
  317.             {
  318.               TXTREF vec = XVEc_TRN (in_trn, i);
  319.               sc = 0;
  320.               if (*format_ptr == 'T')
  321.                 if (VLEN (vec))
  322.                   sc = 1;
  323.               if (sawclose || sc)
  324.                 {
  325.                   PRINT_INDENT;
  326.                   sawclose = sc;
  327.                 }
  328.               fprintf (outfl, " [");
  329.               INC_INDENT;
  330.               if (VLEN (vec) == 0)
  331.                 {
  332.                   fprintf (outfl, "n;; vector lenght =%d ", VLEN (vec));
  333.                   PRINT_INDENT;
  334.                 }
  335.               for (j = 0; j < VLEN (vec); j++)
  336.                 {
  337.                   switch (*format_ptr)
  338.                     {
  339.                     case 'T':
  340.                       print_trn (Ptree ((VOP (vec, j).txtp)), 't',0);
  341.                       break;
  342.                     case 'L':
  343.                       fprintf (outfl, " %d", VOP (vec, j).l);
  344.                       if (j % 5 == 4)
  345.                         {
  346.                           PRINT_INDENT;
  347.                           sawclose = 1;
  348.                         }
  349.                       break;
  350.                     default:
  351.                       fprintf (outfl, "n;; unexpected format");
  352.                       PRINT_INDENT;
  353.                       /**/ ;
  354.                     }
  355.                 }
  356.               DEC_INDENT;
  357.               sawclose += sc;
  358.               if (sawclose)
  359.                 PRINT_INDENT;
  360.               if (sawclose)
  361.                 fprintf (outfl, "]");
  362.               else
  363.                 fprintf (outfl, " ]");
  364.             }
  365.           else
  366.             fprintf (outfl, " [] ");
  367.           sawclose = 1;
  368.           DEC_INDENT;
  369.           break;
  370.         case 'N':
  371.           if (XTXt_TRN(in_trn,i)==TNULL || !type_vcb_subtree)
  372.             fprintf (outfl," >><< ");
  373.           else
  374.             {
  375.             case_n:
  376.               PRINT_INDENT;
  377.               INC_INDENT;
  378.               sawclose = 1;
  379.               fprintf (outfl," >> ");
  380.               print_trn (Ptree (XTXt_TRN(in_trn, i)), 't',1);
  381.               DEC_INDENT;
  382.               if (sawclose)
  383.                 PRINT_INDENT;
  384.               if (sawclose)
  385.                 fprintf (outfl, "<<");
  386.               else
  387.                 fprintf (outfl, " <<");
  388.               PRINT_INDENT;
  389.               sawclose = 0;
  390.             }
  391.           break;
  392.         default:
  393.           fprintf (STDERR,
  394.                    "Internal error %s:%d:(print_trn) format '%c' wrongn",
  395.                    __FILE__, __LINE__, *format_ptr);
  396.           yyfatal (" Abort");
  397.         }
  398.       if(jfi)
  399.         {
  400.           just_for_info-=jfi;
  401.           jfi = 0;
  402.           PRINT_INDENT;
  403.         }
  404.     }
  405.   /* print comparision pattern */
  406.   if (Tstf_TRN (in_trn, PATTERN_F))
  407.     {
  408.       i4_t k;
  409.       k = PTRN_ELEM (code);
  410.       i = LENGTH (code) + k - 1;
  411.       while (k--)
  412. fprintf (outfl, " %X", (u4_t) XLNg_TRN (in_trn, i - k));
  413.     }
  414.   /* print parameters */
  415.   fputs (" ", outfl);
  416.   if (HAS_DOWn (in_trn))
  417.     {
  418.       INC_INDENT;
  419.       PRINT_INDENT; sawclose = 0; 
  420.       fprintf (outfl, "{ ");
  421.       INC_INDENT;
  422.       if (ARITy_TRN (in_trn))
  423. sawclose = 1;
  425.       for (i = ARITy_TRN (in_trn), parm = DOWn_TRN (in_trn);
  426.    i && parm;
  427.    parm = RIGHT_TRN (parm), i--);
  428.       if (i || parm)
  429. {
  430.   fprintf (outfl, "n;; node parameters number mismath ");
  431.   sawclose = 1;
  433.           /* ARITY correcting */
  434.           for (; parm; parm = RIGHT_TRN (parm))
  435.             (ARITy_TRN (in_trn))++;
  436.           ARITy_TRN (in_trn) -= i;
  437. }
  438.       print_trn (Ptree (DOWn_TRN(in_trn)), 't',1);
  440.       DEC_INDENT;
  441.       if (sawclose)
  442. PRINT_INDENT;
  444.       fprintf (outfl, "} ");
  445.       sawclose = 1;
  446.       DEC_INDENT;
  447.     }
  449.   fprintf (outfl, ")");
  450.   sawclose = 1;
  451.   if ( Is_statement(in_trn) || (code==VIEW))
  452.     {
  453.       register TXTREF v;
  454.       vcb_dump_in_progress = 1;
  455.       /* backlay=1; */
  456.       if (dump_vocabulary)
  457. fprintf (outfl, "n;; ==========<< Local Vocabulary >>===============");
  458.       for (v = LOCAL_VCB_ROOT; v; v = RIGHT_TRN (v))
  459. {
  460.   if (TstF_TRN(v,MARK1_F))
  461.     ClrF_TRN (v, MARK1_F);
  462. }
  463.       if (dump_vocabulary)
  464. {
  465.   fprintf (outfl, "n");
  466.   print_trn (Ptree (XVCb_TRN (in_trn, 7)), 't',1);
  467. }
  468.       /* backlay=0; */
  469.       vcb_dump_in_progress = 0;
  470.       if(code==VIEW)
  471.         { assert(VIEw_VCB(in_trn) == LOCAL_VCB_ROOT); }
  472.       else
  473.         { assert(XVCb_TRN (in_trn, 7) == LOCAL_VCB_ROOT); }
  474.       LOCAL_VCB_ROOT = lvr;
  475.     }
  476.   assert (in_trn == in_trn1);
  477. GO_RIGHT:
  478.   if (go_right && RIGHt_TRN(in_trn))
  479.     print_trn (Ptree(RIGHt_TRN(in_trn)),type_mode,go_right);
  480.   Clrf_TRN (in_trn, MARK_F);
  481. #undef PRINT_INDENT
  482. #undef INC_INDENT
  483. #undef DEC_INDENT
  484. }
  486. /* Call this function from the debugger to see what X looks like.  */
  488. void
  489. toggle_mark1f(i4_t i)
  490. {
  491.   TXTREF v;
  492.   for (v = VCB_ROOT; v; v = RIGHT_TRN (v))
  493.     if (i)
  494.       SetF_TRN (v, MARK1_F);
  495.     else
  496.       ClrF_TRN (v, MARK1_F);
  497.   for (v = LOCAL_VCB_ROOT; v; v = RIGHT_TRN (v))
  498.     if (i)
  499.       SetF_TRN (v, MARK1_F);
  500.     else
  501.       ClrF_TRN (v, MARK1_F);
  502. }
  504. void
  505. debug_trn_d (trn x)
  506. {
  507.   FILE *of;
  508.   static i4_t prevent_loop = 0;
  509.   if (prevent_loop)
  510.     {
  511.       fprintf (STDERR, ";; debug loop encountered --> BREAK n");
  512.       return; 
  513.     }
  514.   prevent_loop++;    
  515.   vcb_dump_in_progress = 1;
  516.   of = outfl;
  517.   outfl = STDERR;
  518.   /* backlay=1; */
  519.   sawclose = 1;
  520.   if (x)
  521.     {
  522.       MASKTYPE m = MASk_TRN (x);
  523.       if (Tstf_TRN (x, MARK_F))
  524. {
  525.   Clrf_TRN (x, MARK_F);
  526.   fprintf (STDERR, ";; node below is marked n");
  527. }
  528.       print_trn (x, 't',0);
  529.       MASk_TRN (x) = m;
  530.     }
  531.   else
  532.     fprintf (STDERR, "(nil_code)n");
  533.   fprintf (STDERR, "n");
  534.   vcb_dump_in_progress = 0;
  535.   backlay = 0;
  536.   toggle_mark1f(0);
  537.   outfl = of;
  538.   prevent_loop--;
  539. }
  541. void
  542. debug_trn (TXTREF x)
  543. {
  544.   debug_trn_d (Ptree (x));
  545. #if 0
  546.   if (!x)
  547.     return;
  548.   if ( Is_Statement(x))
  549.     {
  550.       TXTREF v,v1;
  551.       fprintf(STDERR,"Local vocabulary ...n");
  552.       for (v1 = STMT_VCB(x); v1; v1 = RIGHT_TRN (v1))
  553.         {
  554.           debug_trn_d (Ptree (v1));
  555.           for (v = STMT_VCB(x); v; v = RIGHT_TRN (v))
  556.             if (TstF_TRN(v,MARK1_F))
  557.               ClrF_TRN (v, MARK1_F);
  558.         }
  559.       fprintf(STDERR,"======================n");
  560.     }
  561. #endif
  562. }
  564. /* External entry point for printing a chain of statements
  565.  * starting with ROOT onto file OUTF.                    
  566.  * A blank line separates insns.                         
  567.  */
  569. void
  570. print_trl (TXTREF trn_first, FILE * outf)
  571. {
  572.   register TXTREF cur_stmt;
  574.   outfl = outf;
  576.   if (outfl == NULL)
  577.     outfl = STDOUT;
  578.   sawclose = 1;
  579.   if (trn_first)
  580.     print_trn (Ptree (trn_first), 't',0);
  581.   else
  582.     {
  583.       print_trn (Ptree (ROOT), 't',1);
  584.       fprintf (outfl, "nn;;--------------------------------------------nn");
  585.       
  586.       if (dump_vocabulary)
  587.         {
  588.           vcb_dump_in_progress = 1;
  589.           /* backlay=1; */
  590.           fprintf (outfl, ";; ==========<< Global Vocabulary >>===============");
  591.           print_trn (Ptree (VCB_ROOT), 't',1);
  592.           backlay = 0;
  593.           vcb_dump_in_progress = 0;
  594.         }
  595.     }
  596.   for (cur_stmt = VCB_ROOT; cur_stmt; cur_stmt = RIGHT_TRN (cur_stmt))
  597.     if (TstF_TRN(cur_stmt,MARK1_F))
  598.       ClrF_TRN (cur_stmt, MARK1_F);
  599.   outfl = NULL;
  600. }
  602. /*******==================================================*******
  603. *******             Reading trn from file                  *******
  604. *******==================================================*******/
  606. /* Subroutines of read_trn.  */
  607. /* Dump code after printing a message.  Used when read_trn finds invalid
  608.    data.  */
  610. static FILE *infile = NULL;
  611. static i4_t line_num = 0;
  613. static void
  614. ftail (void)
  615. {
  616.   i4_t c, i;
  618.   fprintf (STDERR, "nFollowing characters are:nt");
  619.   for (i = 0; i < 200; i++)
  620.     {
  621.       c = getc (infile);
  622.       if (EOF == c)
  623. break;
  624.       putc (c, STDERR);
  625.     }
  626.   fprintf (STDERR, "Aborting.n");
  627.   abort ();
  628. }
  630. static void
  631. dump_and_abort (i4_t expected_c, i4_t actual_c)
  632. #define CHECK_CHAR(SYMBOL)  if(c!=SYMBOL) dump_and_abort(SYMBOL,c)
  633. {
  634.   fprintf (STDERR,
  635.    "Expected :'%c'. Read: '%c'. At file position:%ld",
  636.    expected_c, actual_c, ftell (infile));
  637.   if (line_num)
  638.     {
  639.       fprintf (STDERR, " %s:%d:", progname ? progname : "", line_num);
  640.       line_num = 0;
  641.     }
  642.   ftail ();
  643. }
  645. /* Read chars from INFILE until a non-whitespace char and return that.
  646.    Comments, both Lisp style and C style, are treated as whitespace. Tools
  647.    such as gen* use this function.  */
  649. int
  650. read_skip_spaces (void)
  651. {
  652.   register i4_t c;
  653.   while ((c = getc (infile)) != EOF)
  654.     {
  655.       if (c == ' ' || c == 't' || c == 'f')
  656. continue;
  657.       else if (c == 'n')
  658. line_num++;
  659.       else if (c == ';')
  660. {
  661.   while ((c = getc (infile)) != EOF && c != 'n');
  662.   if (c == 'n')
  663.     line_num++;
  664. }
  665.       else if (c == '/')
  666. {
  667.   register i4_t prevc;
  668.   c = getc (infile);
  669.   CHECK_CHAR ('*');
  671.   prevc = 0;
  672.   while ((c = getc (infile)) != EOF)
  673.     {
  674.       if (prevc == '*' && c == '/')
  675. break;
  676.       prevc = c;
  677.     }
  678. }
  679.       else
  680. break;
  681.     }
  682.   return c;
  683. }
  687. /* Read an trn code name into the buffer STR[]. It is terminated by any of
  688.    the punctuation chars of trn printed syntax.  */
  690. static void
  691. read_name (char *str)
  692. {
  693.   register char *p;
  694.   register i4_t c;
  696.   c = read_skip_spaces ();
  698.   p = str;
  699.   while (1)
  700.     {
  701.       if (c == ' ' || c == 'n' || c == 't' || c == 'f')
  702. break;
  703.       if (c == ':' || c == '"' || c == '/' || c == '[' || c == ']'
  704.   || c == '(' || c == ')' || c == '{' || c == '}'
  705. )
  706. {
  707.   ungetc (c, infile);
  708.   break;
  709. }
  710.       *p++ = c;
  711.       c = getc (infile);
  712.     }
  713.   if (c == 'n')
  714.     line_num++;
  715.   *p = 0;
  716. }
  718. static LTRLREF
  719. get_literal(char *terminators,i4_t *cp)
  720. {
  721.   i4_t saw_paren = 0;
  722.   register i4_t j,c; 
  723.   register char *buf;
  724.   i4_t            bufsize;
  725.   
  726. #define EXIT(val)  { LTRLREF v=val; *cp = c; if(buf) xfree(buf); return v;}
  727.   
  728.   bufsize = 10;
  729.   buf = (char *) xmalloc (bufsize + 1);
  730.   c = getc (infile);
  731.   if (c == '(' ) 
  732.     {
  733.       saw_paren = 1;
  734.       c = read_skip_spaces ();
  735.     }
  736.   else if (c == '-')
  737.     EXIT(TNULL);
  738.   CHECK_CHAR (terminators[0]);
  739.   j = 0;
  740.   while (1)
  741.     {
  742.       if (j >= bufsize - 4)
  743. {
  744.   bufsize *= 2;
  745.   buf = (char *) xrealloc (buf, bufsize + 1);
  746. }
  747.       buf[j] = getc (infile); /* Read the string  */
  748.       if (buf[j] == '\')
  749. {
  750.   buf[j] = getc (infile); /* Read the string  */
  751.   switch(buf[j])
  752.     {
  753.     case 'n': buf[j] = 'n'; break;
  754.     case 't': buf[j] = 't'; break;
  755.     case 'b': buf[j] = 'b'; break;
  756.     case 'f': buf[j] = 'f'; break;
  757.     case 'r': buf[j] = 'r'; break;
  758.     default:               ; break;
  759.     }
  760. }
  761.       else if (buf[j] == terminators[1])
  762. break;
  763.       j++;
  764.     }
  765.   buf[j] = 0; /* NUL terminate the string  */
  766.   if (saw_paren)
  767.     {
  768.       c = read_skip_spaces ();
  769.       CHECK_CHAR (')');
  770.     }
  771.   
  772.   if (*buf)
  773.     EXIT(ltr_rec (buf));
  774.   EXIT(TNULL);
  775. #undef EXIT
  776. }
  778. /*
  779.  * Read an trn in printed representation from INFILE and return an actual trn
  780.  * in core constructed accordingly. read_trn is not used in the compiler
  781.  * proper, but rather in tools (kitty) and for debugging purpose
  782.  */
  784. static MASKTYPE default_mask = 0;
  786. static TXTREF
  787. read_trn_l (void)
  788. {
  789.   register i4_t i, j, list_counter;
  790.   enum token tmp_code;
  791.   register char *format_ptr;
  792.   /* tmp_char is a buffer used for reading decimal integers and names of trn
  793.      types and machine modes. Therefore, 256 must be enough.  */
  794.   char tmp_char[256];
  795.   TXTREF return_trn;
  796.   MASKTYPE msk;
  797.   i4_t c;
  798.   i4_t minus = 0;
  800.   c = read_skip_spaces (); /* Should be open paren.  */
  801.   if (c == EOF)
  802.     return TNULL;
  803.   return_trn = TNULL;
  804.   if (c == '-') /* special construction for omitted nodes '-'
  805.    and '--' */
  806.     {
  807.       while (1)
  808. {
  809.   c = getc (infile);
  810.   switch (c)
  811.     {
  812.     case '}':
  813.       ungetc (c, infile);
  814.     case ' ':
  815.     case 'n':
  816.     case 't':
  817.     case 'f':
  818.     case 'r':
  819.       if (return_trn == TNULL)
  820. return gen_node1 (SKIP_CODE, default_mask);
  821.       return return_trn;
  822.     case '-':
  823.       if (return_trn)
  824. dump_and_abort (' ', '-');
  825.       else
  826. return_trn = gen_node1 (SKIP_CODES, default_mask);
  827.       break;
  828.     default:
  829.       dump_and_abort (' ', c);
  830.     }
  831. }
  832.       /* unreachable code */
  833.     }
  834.   if (c == 'O') /* looks like Op:n construction */
  835.     {
  836.       minus = 1;
  837.       ungetc (c, infile);
  838.     }
  839.   else
  840.     CHECK_CHAR ('(');
  842.   read_name (tmp_char);
  844.   /* fprintf(STDERR,"Name '%s' is readn",tmp_char); */
  846.   tmp_code = UNKNOWN;
  848.   for (i = UNKNOWN; i < NUM_TRN_CODE; i++) /* @@ might speed this search
  849.    up */
  850.     {
  851.       if (!strcmp (tmp_char, NAME (i)))
  852. {
  853.   tmp_code = (enum token) i; /* get value for name */
  854.   break;
  855. }
  856.     }
  857.   if (tmp_char[0] == '-')
  858.     tmp_code = NIL_CODE;
  860.   if (tmp_code == UNKNOWN)
  861.     {
  862.       fprintf (STDERR,
  863.        "Unknown trn read in trl.read_trn_l(). Code name was '%s' .n",
  864.        tmp_char);
  865.       ftail ();
  866.     }
  867.   /* (NIL_CODE) stands for an expression that isn't there.  */
  868.   if (tmp_code == NIL_CODE)
  869.     {
  870.       /* Discard the closeparen.  */
  871.       while ((c = getc (infile)) != EOF && c != ')');
  872.       return TNULL;
  873.     }
  875.   /* If what follows is `: flag ', read it and store the flags in the trn.  */
  877.   c = read_skip_spaces ();
  878.   msk = 0;
  879.   while (c == ':')
  880.     {
  881.       read_name (tmp_char);
  882.       for (i = LAST_FLAG - 1; i >= VCB_F; i--)
  883. if (compatible_tok_fl (tmp_code, (enum flags) i))
  884.   if (!strcmp (tmp_char, NAME_FL (i)))
  885.     {
  886.       SetF (msk, (enum flags) i);
  887.       break;
  888.     }
  889.       if (i < VCB_F)
  890. if ((*tmp_char >= '0') && (*tmp_char <= '9'))
  891.   {
  892.     i4_t v;
  893.     if (1 == sscanf (tmp_char, "%d", &v))
  894.       msk |= (v > 14 ? 0 : v + 1);
  895.     else
  896.       yyerror ("Unexpected 'op' flagn");
  897.   }
  898. else
  899.   {
  900.     fprintf (STDERR, "trl_read: unrecognized flag '%s' in line %dn",
  901.      tmp_char, line_num);
  902.     errors++;
  903.   }
  904.       c = read_skip_spaces ();
  905.     }
  906.   ungetc (c, infile);
  908.   msk |= default_mask;
  909.   return_trn = gen_node1 (tmp_code, msk);
  911.   if ((tmp_code == OPERAND) && minus)
  912.     return return_trn;
  914. #define SET_PAT_BIT(n) 
  915.   SET_BIT(XLNG_TRN(return_trn,PTRN_OP(tmp_code,n)),PTRN_BIT(n))
  916. #define ATR_IS_READ if(msk) SET_PAT_BIT(i);
  917.   
  918.   msk = TstF (msk, PATTERN_F);
  919.   format_ptr = FORMAT (tmp_code);
  920.   for (i = 0, format_ptr = FORMAT (tmp_code);
  921.        i < (LENGTH (tmp_code) + (msk ? PTRN_ELEM (tmp_code) : 0));
  922.        i++, format_ptr++)
  923.     {
  924.       c = read_skip_spaces ();
  925.       ungetc (c, infile);
  926.       if (c == ')' || c == '{')
  927. break;
  928.       if (c=='<')
  929. {
  930.   if(!TstF_TRN(return_trn,ACTION_F))
  931.     yyfatal("Unexpected external reference in dump");
  932.   switch(*format_ptr)
  933.     {
  934.     case '0': case 'r': case 'd': case 'a': case 'V':  case 'p':
  935.       break;
  936.     default:
  937.       SET_PAT_BIT (i);
  938.       if (msk)
  939. SET_PAT_BIT (i+LENGTH(tmp_code));
  940.       XLTR_TRN(return_trn,i) = get_literal("<>",&c);
  941.     }
  942.   continue;
  943. }
  944.       if (i >= LENGTH (tmp_code))
  945. format_ptr = "x";
  946.       switch (*format_ptr)
  947. {
  948.   /* 0 means a field For internal use only. Don't expect it to be
  949.      present in the input.  */
  950. case '0':
  951. case 'r': /* right, down and arity field must be filled */
  952. /* later */
  953. case 'a':
  954. case 'd':
  955.   break;
  957. case 'V': /* special vocabulary reference (backward */
  958. /* link) */
  959.   break;
  960. case 't':
  961. case 'v':
  962.   {
  963.     register TXTREF x = read_trn_l ();
  964.     if (msk)
  965.       if (CODE_TRN (x) == SKIP_CODE)
  966. {
  967.   free_node (x);
  968.   x = TNULL;
  969. }
  970.       else
  971. SET_PAT_BIT (i);
  972.     XTXT_TRN (return_trn, i) = x;
  973.   }
  974.   break;
  975. case 'P': /* pattern tree */
  976.   {
  977.     MASKTYPE x = default_mask;
  978.     SetF (default_mask, PATTERN_F);
  979.     XTXT_TRN (return_trn, i) = read_trn_l ();
  980.     ATR_IS_READ;
  981.     default_mask = x;
  982.     break;
  983.   }
  984. case 'N':  /* '>> () ... () <<' as a simple reference */
  985.   {
  986.     register TXTREF cn = TNULL;
  987.     CHECK_CHAR('>');
  988.     c = getc(infile);
  989.     CHECK_CHAR('>');
  990.     c = getc(infile);
  991.     CHECK_CHAR('>');
  992.     for(;;)
  993.       {
  994. c = read_skip_spaces ();
  995. if (c == '<')
  996.   break;
  997. ungetc (c, infile);
  998. if (cn)
  999.   cn = RIGHT_TRN(cn) = read_trn_l();
  1000. else
  1001.   cn = XTXT_TRN(return_trn,i) = read_trn_l();
  1002.       }
  1003.     CHECK_CHAR('<');
  1004.     c = getc(infile);
  1005.     CHECK_CHAR('<');
  1006.     break;
  1007.   }    
  1008. case 'S':
  1009.   /* 'S' is an optional string: If a closeparen follows, just store
  1010.      NULL For this element.  */
  1011.   if ((c != '"') && (c != '(') && (c != '-')) /* " */
  1012.     {
  1013.       XLTR_TRN (return_trn, i) = 0;
  1014.       break;
  1015.     }
  1017. case 's': 
  1018.   {
  1019.     XLTR_TRN(return_trn,i) = get_literal("""",&c) ;
  1020.     if (c == '-')
  1021.       break;
  1022.     ATR_IS_READ;
  1023.     break;
  1024.   }
  1025. case 'p':
  1026.   {
  1027.     if (c == 'l')
  1028.       {
  1029. i4_t p = 0;
  1030. CHECK_CHAR ('l');
  1031. fscanf (infile, "line:%d", &p);
  1032. LOCATION_TRN (return_trn) = p;
  1033.       }
  1034.     else
  1035.       LOCATION_TRN (return_trn) = line_num;
  1036.     break;
  1037.   }    
  1038. case 'y':
  1039.   {
  1040.     if (c == '-')
  1041.       {
  1042. if (msk)
  1043.   c = getc (infile);
  1044. else
  1045.   yyerror ("Warning: unexpected - in dump");
  1046.       }
  1047.     else
  1048.       {
  1049. sql_type_t t;
  1050. char       s[50];
  1051. fscanf (infile, "%[^ tnfr]", s);
  1052. conv_type (s, &t, 1);
  1053. XOP_TRN (return_trn, i).type = t;
  1054. ATR_IS_READ;
  1055.     }
  1056.     break;
  1057.   }
  1058. case 'i':
  1059.   {
  1060.     if (msk && (c == '-'))
  1061.       {
  1062. c = getc (infile);
  1063. break;
  1064.       }
  1065.     read_name (tmp_char);
  1066.     XLNG_TRN (return_trn, i) = atoi (tmp_char);
  1067.     ATR_IS_READ;
  1068.     break;
  1069.   }
  1070. case 'x':
  1071.   {
  1072.     if (msk && (c == '-'))
  1073.       {
  1074. c = getc (infile);
  1075. break;
  1076.       }
  1077.     fscanf (infile, "%X", (u4_t *) &(XLNG_TRN (return_trn, i)));
  1078.     if (i < LENGTH (tmp_code))
  1079.       ATR_IS_READ;
  1080.     break;
  1081.   }
  1082. case 'l':
  1083.   {
  1084.     if (msk && (c == '-'))
  1085.       {
  1086. c = getc (infile);
  1087. break;
  1088.       }
  1089.     read_name (tmp_char);
  1090.     XLNG_TRN (return_trn, i) = atol (tmp_char);
  1091.     ATR_IS_READ;
  1092.     break;
  1093.   }
  1094. case 'R':
  1095.   {
  1096.     i4_t l;
  1097.     if (msk && (c == '-'))
  1098.       {
  1099. c = getc (infile);
  1100. break;
  1101.       }
  1102.     fscanf (infile, "R:%d", &l);
  1103.     XLNG_TRN (return_trn, i) = l;
  1104.     ATR_IS_READ;
  1105.     break;
  1106.   }
  1107. case 'f':
  1108.   {
  1109.     if (msk && (c == '-'))
  1110.       {
  1111. c = getc (infile);
  1112. break;
  1113.       }
  1114.     read_name (tmp_char);
  1115.     XFLT_TRN (return_trn, i) = atof (tmp_char);;
  1116.     ATR_IS_READ;
  1117.     break;
  1118.   }
  1119. case 'T':
  1120. case 'L':
  1121.   {
  1122.     struct trn_list
  1123.     {
  1124.       struct trn_list *next;
  1125.       tr_union value;
  1126.     };
  1127.     register struct trn_list *next_trn, *trn_list_link;
  1128.     struct trn_list *list_trn = NULL;
  1130.     if (msk && (c == '-'))
  1131.       {
  1132. c = getc (infile);
  1133. break;
  1134.       }
  1136.     c = read_skip_spaces ();
  1137.     CHECK_CHAR ('[');
  1139.     /* add expressions to a list, while keeping a count */
  1140.     next_trn = NULL;
  1141.     list_counter = 0;
  1142.     while ((c = read_skip_spaces ())!= EOF && c != ']')
  1143.       {
  1144. ungetc (c, infile);
  1145. list_counter++;
  1146. trn_list_link = 
  1147.   (struct trn_list *)xmalloc (sizeof (struct trn_list));
  1148. switch (*format_ptr)
  1149.   {
  1150.   case 'T':
  1151.     trn_list_link->value.txtp = read_trn_l ();
  1152.     break;
  1153.   case 'L':
  1154.     read_name (tmp_char);
  1155.     trn_list_link->value.l = atol (tmp_char);
  1156.     break;
  1157.   }
  1158. if (next_trn == 0)
  1159.   list_trn = trn_list_link;
  1160. else
  1161.   next_trn->next = trn_list_link;
  1162. next_trn = trn_list_link;
  1163. trn_list_link->next = 0;
  1164.       }
  1165.     /* get vector length and allocate it */
  1166.     if (list_counter > 0)
  1167.       {
  1168. XVEC_TRN (return_trn, i) = gen_vect (list_counter);
  1169. next_trn = list_trn;
  1170. for (j = 0; j < list_counter; j++, next_trn = next_trn->next)
  1171.   XOP_VEC (return_trn, i, j) = next_trn->value;
  1172. while (list_trn)
  1173.   {
  1174.     next_trn = list_trn;
  1175.     list_trn = list_trn->next;
  1176.     xfree (next_trn);
  1177.   }
  1178.       }
  1179.     /* close bracket gotten */
  1180.     ATR_IS_READ;
  1181.     break;
  1182.   }
  1184. default:
  1185.   {
  1186.     fprintf (STDERR,
  1187.      "%ld: Internal error:(trn_read) format '%c' wrongn",
  1188.      ftell (infile), format_ptr[-1]);
  1189.     yyfatal ("Abort");
  1190.   }
  1191. }
  1192.     }
  1193.   c = read_skip_spaces ();
  1194.   ungetc (c, infile);
  1195.   if (HAS_DOWN (return_trn) && ((c == '{') /* || (msk==0) */ ))
  1196.     {
  1197.       register TXTREF next_trn;
  1198.       TXTREF list_trn = TNULL;
  1199.       
  1200.       c = read_skip_spaces ();
  1201.       CHECK_CHAR ('{');
  1202.       
  1203.       /* add expressions to a list, while keeping a count */
  1204.       next_trn = TNULL;
  1205.       list_counter = 0;
  1206.       while ((c = read_skip_spaces ())!= EOF && c != '}')
  1207. {
  1208.   ungetc (c, infile);
  1209.   list_counter++;
  1210.   
  1211.   list_trn = read_trn_l ();
  1212.   if (next_trn == 0)
  1213.     DOWN_TRN (return_trn) = list_trn;
  1214.   else
  1215.     RIGHT_TRN (next_trn) = list_trn;
  1216.   next_trn = list_trn;
  1217. }
  1218.       ARITY_TRN (return_trn) = list_counter;
  1219.       /* close bracket gotten */
  1220.     }
  1221.   
  1222.   c = read_skip_spaces ();
  1223.   CHECK_CHAR (')');
  1224.   /* add vocabulary information */
  1225.   if (TstF_TRN (return_trn, VCB_F) && !TstF_TRN(return_trn,ACTION_F) )
  1226.     {
  1227.       TXTREF tmp_trn = return_trn;
  1228.       switch (tmp_code)
  1229. {
  1230. case PARAMETER:
  1231. case CURSOR:
  1232.   return_trn = add_info_l (return_trn);
  1233.   if (return_trn != tmp_trn)
  1234.     free_tree (tmp_trn);
  1235.   break;
  1236. case SCAN:
  1237.   return_trn = find_entry (return_trn);
  1238.   if (return_trn)
  1239.     free_tree (tmp_trn);
  1240.   else
  1241.     {
  1242.       return_trn = tmp_trn;
  1243.       RIGHT_TRN (tmp_trn) = LOCAL_VCB_ROOT;
  1244.       LOCAL_VCB_ROOT = tmp_trn;
  1245.     }
  1246.   break;
  1247. case SCOLUMN: /* link all backward reference */
  1248. case COLUMN:
  1249.   return_trn = add_info_l (return_trn);
  1250.   if (return_trn != tmp_trn)
  1251.     free_node (tmp_trn);
  1252.   break;
  1253. default:
  1254.   if (Is_Table (return_trn))
  1255.     {
  1256.       return_trn = add_info_l (return_trn);
  1257.       if (return_trn != tmp_trn)
  1258. free_tree (tmp_trn);
  1259.       else
  1260. {
  1261.   TXTREF clmn;
  1262.   for (clmn = TBL_COLS (return_trn); clmn; clmn = RIGHT_TRN (clmn))
  1263.     COL_TBL (clmn) = return_trn;
  1264. }
  1265.     } /* Is_Table */
  1266. }
  1267.     }
  1268.   if (Is_Statement (return_trn))
  1269.     {
  1270.       STMT_VCB (return_trn) = LOCAL_VCB_ROOT;
  1271.       LOCAL_VCB_ROOT = TNULL;
  1272.     }
  1273.   /*----------------------------*/
  1274.   if (TstF_TRN (return_trn, MARK_F))
  1275.     {
  1276.       free_node (return_trn);
  1277.       return_trn = TNULL;
  1278.     }
  1279.   return return_trn;
  1280. #undef ATR_IS_READ
  1281. #undef SET_PAT_BIT
  1282. }
  1284. #undef CHECK_CHAR
  1286. TXTREF
  1287. read_trn(FILE * infl,i4_t *line,MASKTYPE def_msk)
  1288. {
  1289.   MASKTYPE x;
  1290.   TXTREF   t;
  1291.   infile = infl;
  1292.   line_num = line ? *line: 0;
  1293.   x = default_mask;
  1294.   default_mask = def_msk;
  1295.   t = read_trn_l ();
  1296.   default_mask = x;
  1297.   if (line)
  1298.     *line = line_num;
  1299.   return t;
  1300. }
  1302. void
  1303. load_trl (FILE * infl)
  1304. {
  1305.   MASKTYPE x;
  1306.   install (NULL);
  1307.   infile = infl;
  1308.   line_num = 0;
  1309.   x = default_mask;
  1310.   default_mask = 0;
  1311.   LOCAL_VCB_ROOT = TNULL;
  1312.   for(;;)
  1313.     {
  1314.       register TXTREF st = read_trn_l ();
  1315.       if (!st)
  1316. break;
  1317.       add_statement (st);
  1318.     }
  1319.   default_mask = x;
  1320.   return;
  1321. }
  1323. void
  1324. load_trlfile (char *flname)
  1325. {
  1326.   FILE *fl = fopen (flname, "r");
  1327.   char *oldpn;
  1328.   if (!fl)
  1329.     {
  1330.       fprintf (STDERR, "Can't open '%s'n", flname);
  1331.       exit (FATAL_EXIT_CODE);
  1332.     }
  1333.   oldpn = progname;
  1334.   progname = flname;
  1335.   load_trl (fl);
  1336.   progname = oldpn;
  1337.   fclose (fl);
  1338. }