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

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

SQL Server

开发平台：

Unix_Linux

trl.c：源码内容
  1. /*
  2.  *  trl.c  - tree library support for GNU SQL precompiler
  3.  *
  4.  *  This file is a part of GNU SQL Server
  5.  *
  6.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  7.  *  Developed at the Institute of System Programming
  8.  *  This file is written by Michael Kimelman
  9.  *
  10.  *  This program is free software; you can redistribute it and/or modify
  11.  *  it under the terms of the GNU General Public License as published by
  12.  *  the Free Software Foundation; either version 2 of the License, or
  13.  *  (at your option) any later version.
  14.  *
  15.  *  This program is distributed in the hope that it will be useful,
  16.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *  GNU General Public License for more details.
  19.  *
  20.  *  You should have received a copy of the GNU General Public License
  21.  *  along with this program; if not, write to the Free Software
  22.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  *
  24.  *  Contacts: gss@ispras.ru
  25.  *
  26.  */
  28. /* $Id: trl.c,v 1.246 1997/03/31 11:01:59 kml Exp $ */
  30. #include "vmemory.h"
  32. #ifdef HAVE_UNISTD_H
  33. #include <unistd.h>
  34. #endif
  36. #include "trl.h"
  37. #include "tassert.h"
  38. #include "trlinter.h"
  39. #include "tree_gen.h"
  40. #include "type_lib.h"
  41. #include "cycler.h"
  42. #include "typeif.h"
  43. #include <assert.h>
  44. #include <fcntl.h>
  46. /*******==================================================*******
  47. *******             tree  node description                 *******
  48. *******==================================================*******/
  49. #define DEF_TOKEN(CODE,NAME,FORMAT,STRUCT,FLAGS)  
  50.       {NAME,FORMAT,STRUCT,FLAGS,0},
  52. struct tkn_info token_info[NUM_TRN_CODE] =
  53. {
  54. #include "treecode.def"
  55.   {"Last_token", "*", ' ', " ", 0}
  56. };
  58. /*******==================================================*******
  59. *******             tree  flags description                *******
  60. *******==================================================*******/
  62. #define DEF_FLAG_BIT(CODE,NAME,CLASS,BIT_NO)  DEF_FLAG(CODE,NAME,CLASS)
  63. #define DEF_FLAG(CODE,NAME,CLASS)             {NAME,CLASS,01L<<bt_##CODE},
  64. struct flag_info flg_info[NUMBER_OF_FLAGS] =
  65. {
  66. #include "treeflag.def"
  67.   {NULL, ' ', 0}
  68. };
  71. /*******==================================================*******
  72. *******           Static functions                         *******
  73. *******==================================================*******/
  74. static VADR tree_vm_segment = (VADR) NULL;
  75. static struct tree_root *trl_forest_descriptor = (struct tree_root *) NULL;
  77. static void
  78. trl_init (void)
  79. {
  80.   static i4_t init_trl = 0;
  81.   register i4_t no;
  82.   register enum token code;
  83.   register enum flags f, fb;
  84.   MASKTYPE msk;
  85.   if (init_trl)
  86.     return;
  87.   for (code = 0; code < LAST_TOKEN; code++)
  88.     {
  89.       no = LENGTH (code) = strlen (FORMAT (code));
  90.       msk = 0;
  91.       if (code == OPERAND)
  92.         continue;
  93.       for (f = 0; f < LAST_FLAG; f++)
  94.         if (compatible_tok_fl (code, f))
  95.           if (TstF (msk, f) == 0L)      /* if flag hasn't already been set */
  96.             SetF (msk, f);              /* set it                          */
  97.           else                          /* in other case                   */
  98.             for (fb = 0; fb < f; fb++)  /* check again all previous flags  */
  99.               if (TstF (FLAG_VALUE (f), fb))    /* to find source of       */
  100.                 /* collision               */
  101.                 fprintf (STDERR,        /* and type report about it        */
  102.                          "Internal error: misplaced flags '%s' and '%s'"
  103.                          " for code '%s'n",
  104.                          NAME_FL (f), NAME_FL (fb), NAME (code)
  105.                   );
  106.     }
  107.   init_trl = 1;
  108. }
  110. void
  111. init_tree (void)
  112. {
  113.   if (!tree_vm_segment)
  114.     install (NULL);
  115. }
  117. /*
  118.  * 'change_tree_segment' set internal  'current' segment pointer to the segment
  119.  * where 'ptr_inside' points into. The function also checks if this segment is 
  120.  * really tree segment. 'Action' is a code of additional activity with this 
  121.  * segment. 0 means just switch to this segment. 1 - means switch to the 
  122.  * segment and add its descriptor to the list of acceptable tree segment. 
  123.  * -1 means delete given segment from tree segment list
  124.  */
  126. static TXTREF 
  127. change_tree_segment(TXTREF ptr_inside,i4_t action)
  128. {
  129.   static struct t_seg { 
  130.     TXTREF         tree_id;
  131.     struct t_seg  *next,
  132.                   *prev;
  133.   }                 *head=NULL;
  134.   register TXTREF    seg;
  135.   register struct t_seg *cur;
  136.   
  137.   trl_init ();
  138.   assert( (-1<=action) && (action <=1));
  139.   seg = ptr_inside ? get_vm_segment_id(ptr_inside) : TNULL;
  140.   for( cur = head; cur && cur->tree_id != seg ; cur = cur->next);
  141.   if ( !cur && action != 1 )/* on attempt to switch to or delete             */
  142.                             /* unregistered segment                          */
  143.     return tree_vm_segment; /* do nothing - even don't become angry          */
  144.   if (cur && action == -1 ) /* delete some segment                           */
  145.     {
  146.       if (cur->prev == NULL)
  147. head=cur->next;
  148.       else 
  149. {
  150.   cur->prev->next=cur->next;
  151.   if (cur->next) 
  152.     cur->next->prev=cur->prev;
  153. }
  154.       xfree(cur);
  155.       cur = head;
  156.     }
  157.   else if ( !cur && action == 1 ) /* add segment which hasn't been found     */
  158.     {
  159.       cur=xmalloc(sizeof(*cur));
  160.       cur->tree_id = seg;
  161.       if (head)
  162. {
  163.   cur->next = head;
  164.   cur->next->prev = cur;
  165. }
  166.       head = cur;
  167.     }
  168.   /* right now 'cur' points to desirable segment so let's switch to it       */
  169.   if(!cur)  /* if there is no available segment                              */
  170.     {
  171.       tree_vm_segment = TNULL;
  172.       trl_forest_descriptor = 0;
  173.     }
  174.   else /* if everything is ok */
  175.     {
  176.       VADR vo = GET_CURRENT_SEGMENT_ID;
  177.       tree_vm_segment=cur->tree_id;
  178.       switch_to_segment (tree_vm_segment);
  179.       seg = resolve_local_reference ("_TRL_descriptor");
  180.       if (!seg) 
  181. {
  182.   seg = tree_vm_segment + vm_ob_alloc (sizeof(struct tree_root), 
  183.        sizeof(TXTREF));
  184.   register_export_address (seg,"_TRL_descriptor");
  185.   assert ( seg == resolve_local_reference ("_TRL_descriptor") );
  186.           {
  187.             /*
  188.              * because 'struct tree_root' is collection of TXTREFs we need
  189.              * to register them as relocate.
  190.              */
  191.             i4_t i = sizeof(struct tree_root)/sizeof(TXTREF);
  192.             while(i--)
  193.               register_relocation_address( seg + i*sizeof(TXTREF));
  194.           }
  195.         }
  196.       switch_to_segment (vo);
  197.       trl_forest_descriptor = (struct tree_root *) vpointer (seg);
  198.     }
  199.   return tree_vm_segment;
  200. }
  202. /*******==================================================*******
  203. *******           GLOBAL functions                         *******
  204. *******==================================================*******/
  206. TXTREF *
  207. Root_ptr (enum kind_of_root sel)
  208. {
  209.   switch(sel)
  210.     {
  211.     case Tree_Root:
  212.       return &(trl_forest_descriptor->root);
  213.     case Vcb_Root:
  214.       return &(trl_forest_descriptor->vcbroot);
  215.     case G_Author:
  216.       return &(trl_forest_descriptor->author);
  217.     case Hash_Tbl:
  218.       return &(trl_forest_descriptor->hash_tbl);
  219.     case Current_Tree_Segment:
  220.       return &(tree_vm_segment);
  221.     }
  222.   return (TXTREF*)NULL;
  223. }
  225. TXTREF  
  226. set_current_tree_segment(TXTREF ptr_inside)
  227. {
  228.   return change_tree_segment(ptr_inside,0);
  229. }
  231. TXTREF 
  232. get_current_tree_segment(void)
  233. {
  234.   return tree_vm_segment;
  235. }
  237. /*
  238.  * create new tree segment, mark them as a current one and return identifier 
  239.  * of it.
  240.  */
  241.  
  242. TXTREF 
  243. create_tree_segment(void)
  244. {
  245.   register TXTREF tr; 
  246.   if ( (tr = create_segment () ) == TNULL)
  247.     return TNULL;
  248.   assert( tr == change_tree_segment(tr,1));
  249.   GL_AUTHOR = ltr_rec (get_user_name ());
  250.   return tree_vm_segment;
  251. }
  253. /* do the same but load tree from buffer. */
  255. TXTREF 
  256. load_tree_segment(void *tree_buffer,i4_t len)
  257. {
  258.   register TXTREF tr; 
  259.   if ( (tr = link_segment (tree_buffer, len)) == TNULL)
  260.     return TNULL;
  261.   assert( tr == change_tree_segment(tr,1));
  262.   return tree_vm_segment; 
  263. }
  265. #define CHECK_TREE_DISPOSE_INTEGRITY
  267. void   
  268. dispose_tree_segment(TXTREF ptr_inside)
  269. {
  270.   VADR   sid;
  271.   TXTREF cs=tree_vm_segment,ds;
  272.   if (ptr_inside == TNULL)
  273.     return;
  274.   sid = get_vm_segment_id(ptr_inside);
  275.   if (cs == sid) cs = 0;
  276.   if (sid != change_tree_segment(ptr_inside,0))
  277.     return;
  278. #ifdef CHECK_TREE_DISPOSE_INTEGRITY
  279.   /* free space */
  280.   while (get_statement (1))
  281.     del_statement (1);
  282.   free_line (VCB_ROOT);
  283.   free_hash ();
  284.   ds = tree_vm_segment;
  285.   {
  286.     VADR seg = resolve_local_reference ("_TRL_descriptor");
  287.     if (seg && ds == get_vm_segment_id(seg)) 
  288.       vmfree(seg);
  289.   }
  290. #endif
  291.   change_tree_segment(ptr_inside,-1);
  292.   if (cs && cs != tree_vm_segment)
  293.     change_tree_segment(cs,0);
  294. #ifdef CHECK_TREE_DISPOSE_INTEGRITY
  295. /*
  296.  * The code below isn't really need but should work if all logic  is 
  297.  * correct. Now it isn't so. Therefore we have to avoid this testing 
  298.  * now to be able to check other parts of system.
  299.  */
  300.   if (!unlink_segment (ds, 0))
  301.     {
  302.       yyerror ("Note! freing memory isn't clean");
  303.       errors--;               /* !!!!!!! */
  304.       unlink_segment (ds, 1);
  305.     }
  306. #else
  307.   unlink_segment (ds, 1);
  308. #endif 
  309. }
  311. void *
  312. extract_tree_segment(TXTREF ptr_inside,i4_t *len)
  313. {
  314.   change_tree_segment(ptr_inside,-1);
  315.   return export_segment (ptr_inside, len, 1);
  316. }
  318. #define ERR(cond,msg) if (cond) { yyerror(msg); rc = SQL_ERROR; goto ERR_proc; }
  320. CODERT
  321. install (char *s)
  322. {
  323.   void *dump = NULL;
  324.   i4_t   len = 0;
  325.   FILE *fd; 
  326.   CODERT rc = SQL_SUCCESS; 
  327.   if (s)
  328.     {                           /* loading tree binary image from file */
  329.       fd= fopen (s, "r");
  330.       ERR(fd == NULL,"Can't open tree binary file");
  331.       fseek (fd, 0, SEEK_END);
  332.       len = ftell (fd);
  333.       fseek (fd, 0, SEEK_SET);
  334.       dump = xmalloc (len);
  335.       fread (dump, len, 1, fd);
  336.       fclose (fd);
  337.       if(!load_tree_segment(dump,len))
  338. {
  339.   fprintf (STDERR,
  340.    "Error occured during loading tree from module '%s'",
  341.    s);
  342.   return SQL_ERROR;
  343. }
  344.     }
  345.   else if(!create_tree_segment())
  346.     return SQL_ERROR;
  347. ERR_proc:
  348.   return rc;
  349. }
  351. CODERT
  352. finish (char *s)
  353. {
  354.   void  *dump = NULL;
  355.   i4_t    len = 0;
  356.   FILE  *fd;
  357.   CODERT rc = SQL_SUCCESS; 
  358.   if (s)
  359.     {
  360.       dump = extract_tree_segment (tree_vm_segment, &len);
  361.       ERR(!dump,"Error occured during packing tree to binary array");
  362.       fd = fopen (s, "w");
  363.       ERR(!fd,"Can't open output binary file");
  364.       fwrite (dump, len, 1, fd);
  365.       fclose (fd);
  366.     }
  367.   /* changed by dkv */
  368.   /*
  369.   else
  370.   dispose_tree_segment(tree_vm_segment);
  371.   */
  372. ERR_proc:
  373.   if (dump)
  374.     xfree(dump);
  375.   return rc;
  376. }
  378. #undef ERR
  380. /*******==================================================*******
  381. *******      Constructors and destructors                  *******
  382. *******==================================================*******/
  384. i4_t 
  385. trn_size(enum token code, MASKTYPE msk)
  386. {
  387.   register i4_t size;
  388.   
  389.   size = SIZE_TRN (code);
  390.   if (TstF (msk, PATTERN_F))
  391.     size += ADD_TRN_SIZE(code);
  392.   if (TstF(msk,ACTION_F))
  393.     size += ADD_TRN_SIZE(code);
  394.   return size;
  395.  }
  397. TXTREF
  398. gen_node1 (enum token code, MASKTYPE msk)
  399. {
  400.   static   i4_t scan_no = 0;
  401.   register i4_t size;
  402.   register TXTREF node = TNULL;
  403.   VADR     old ;
  404.   init_tree ();
  405.   if (code == UNKNOWN || code == NIL_CODE)
  406.     return TNULL;
  407.   
  408.   size = trn_size(code,msk);
  409.   /*-----------------------------*/
  410.   old = GET_CURRENT_SEGMENT_ID;
  411.   switch_to_segment (tree_vm_segment);
  412.   node = GET_CURRENT_SEGMENT_ID + vm_ob_alloc (size, sizeof (tr_union));
  413.   switch_to_segment (old);
  414.   /*-----------------------------*/
  415.   Ptree (node)->code = code;
  416.   MASK_TRN (node) = msk;
  417.   switch (code)
  418.     {
  419.     case NOOP:
  420.       XLNG_TRN(node,0) = 1;
  421.       break;
  422.     case USERNAME:
  423.       USR_TYPE(node) = pack_type(SQLType_Char,MAX_USER_NAME_LNG,0);
  424.       break;
  425.     case SCAN:
  426.       {
  427.         char str[100];
  428.         sprintf(str,"scan%d",scan_no++);
  429.         COR_NAME(node) = ltr_rec(str);
  430.       }
  431.       COR_NO(node) = -1;
  432.     case INDEX:
  433.     case UNIQUE:
  434.     case PRIMARY:
  435.     case CURSOR:
  436.     case PARAMETER:
  437.       SetF_TRN (node, VCB_F);
  438.       break;
  439.     default:
  440.       if (Is_Table (node) || Is_Column (node))
  441.         SetF_TRN (node, VCB_F);
  442.       if (Is_Column (node))
  443.         COL_NO(node) = -1;
  444.     }
  445.   {
  446.     register char  *p;
  447.     register i4_t   i;
  449.     for ( p=FORMAT(code),i=-1; *p; p++,i++) 
  450.       switch(*p){
  451.       case 't':case 'v':case 'V':case 'L':case 'T':case 's':
  452.       case 'r':case 'd':case 'P':case 'N':
  453. register_relocation_address( node + sizeof(tree_t) + i * sizeof(tr_union) );
  454.       }
  455.   }
  456.   return node;
  457. }
  459. TXTREF
  460. gen_node (enum token code)
  461. {
  462.   return gen_node1 (code, 0);
  463. }
  465. void
  466. free_node (TXTREF node)
  467. {
  468.   if (!node)
  469.     return;
  470.   if ( tree_memory_mode_state )
  471.     {
  472.       fprintf (STDERR, ">>>>>>>Freeing node at %X ...", (u4_t) node);
  473.       debug_trn (node);
  474.       fprintf (STDERR, "<<<<<<<======================n");
  475.     }
  476.   if (!Ptree(node))
  477.     {
  478.       fprintf (STDERR, "warning (internal problem): "
  479.                "attemp to free unused memoryn");
  480.       return;
  481.     }
  482.   vmfree (node);
  483. }
  485. TXTREF
  486. gen_vect (i4_t len)              /* generate vector     */
  487. {
  488.   register i4_t s;
  489.   register TXTREF vec;
  491.   init_tree ();
  492.   s = sizeof (struct trvec_def) + (len - 1) * sizeof (tr_union);
  493.     {
  494.       VADR old = GET_CURRENT_SEGMENT_ID;
  495.       switch_to_segment (tree_vm_segment);
  496.       vec = GET_CURRENT_SEGMENT_ID + vm_ob_alloc (s, sizeof (tr_union));
  497.       switch_to_segment (old);
  498.     }
  499.   VLEN (vec) = len;
  500.   return vec;
  501. }
  503. TXTREF
  504. realloc_vect (TXTREF n, i4_t newlen)
  505. {
  506.   register TXTREF v;
  507.   register i4_t l;
  508.   v = gen_vect (newlen);
  509.   for ( l = gmin(VLEN(n),newlen)  ; l--;)
  510.     VOP (v, l) = VOP (n, l);
  511.   free_vect (n);
  512.   return v;
  513. }
  515. void
  516. free_vect (TXTREF vec)
  517. {
  518.   vmfree (vec);
  519. }
  521. PNODE
  522. Pnode (register TXTREF n)
  523. {
  524.   return (PNODE) vpointer (n);
  525. }
  527. TXTREF
  528. gen_const_node (SQLType code, char *info)
  529. {
  530.   TXTREF n;
  531.   n = gen_node1 (CONST, 0);
  532.   if (info)
  533.     CNST_NAME (n) = ltr_rec (info);
  534.   switch (code)
  535.     {
  536.     case SQLType_Char:
  537.       CNST_STYPE (n) = pack_type (code, info ? strlen (info) : 0 , 0);
  538.       break;
  539.     case SQLType_Int:
  540.     case SQLType_Long:
  541.     case SQLType_Short:
  542.       if ( strlen(info) > 5 )
  543.         CNST_STYPE (n) = pack_type (SQLType_Int, 0, 0);
  544.       else
  545.         CNST_STYPE (n) = pack_type (SQLType_Short, 0, 0);
  546.       break;
  547.     case SQLType_Num:
  548. #if 1
  549.       {
  550.         register i4_t l, i = strlen (info);
  551.         register char *p = info + i;
  552.         for (l = i; i >= 0; p--, i--)
  553.           if (*p == '.')
  554.             break;
  555.         CNST_STYPE (n) = pack_type (code, l - 1, l - i - 1);
  556.       }
  557.       break;
  558. #else
  559.       code = SQLType_Real;
  560. #endif
  561.     default:
  562.       CNST_STYPE (n) = pack_type (code, 0, 0);
  563.     }
  564.   return n;
  565. }
  567. /*******==================================================*******
  568. *******   Common tree and vocabulary structure support     *******
  569. *******==================================================*******/
  571. CODERT
  572. add_statement (TXTREF p)
  573. {
  574.   TXTREF cp;
  575.   if (CODE_TRN(p) != CUR_AREA)
  576.     SetF_TRN(p,HAS_VCB_F);
  577.   if (!ROOT)
  578.     {
  579.       ROOT = p;
  580.       STMT_UID (p) = 0;
  581.     }
  582.   else
  583.     {
  584.       cp = ROOT;
  585.       while (RIGHT_TRN (cp) != (TNULL))
  586.         cp = RIGHT_TRN (cp);
  587.       RIGHT_TRN (cp) = p;
  588.       STMT_UID (p) = STMT_UID (cp) + 1;
  589.     }
  590.   RIGHT_TRN (p) = TNULL;
  591.   return 0;
  592. }
  594. CODERT
  595. del_statement (i4_t number)
  596. {
  597.   register TXTREF pt = TNULL, t = ROOT;
  598.   if (number <= 0)
  599.     yyfatal ("Internal error: attempt to delete statement with ID < 0");
  600.   while (--number && t)
  601.     {
  602.       /* if(STMT_UID(t)==number) return t; */
  603.       pt = t;
  604.       t = RIGHT_TRN (t);
  605.     }
  606.   if (!t)
  607.     return 0;
  608.   if (!pt)
  609.     ROOT = RIGHT_TRN (t);
  610.   else
  611.     RIGHT_TRN (pt) = RIGHT_TRN (t);
  612.   free_tree (t);
  613.   return 0;
  614. }
  616. TXTREF
  617. get_statement (i4_t number)
  618. {
  619.   register TXTREF t = ROOT;
  620.   while (--number && t)
  621.     {
  622.       /* if(STMT_UID(t)==number) return t; */
  623.       t = RIGHT_TRN (t);
  624.     }
  625.   return t;
  626. }
  628. void
  629. free_line (TXTREF c)
  630. {
  631.   register TXTREF t;
  632.   if ( ! c )
  633.     return;
  634.   if (!Ptree(c))
  635.     {
  636.       fprintf (STDERR, 
  637.        "warning (internal problem): attemp to free unused memoryn");
  638.       return;
  639.     }
  640.   if ( TstF_TRN (c, VCB_F))
  641.     {
  642.       enum token code = CODE_TRN(c);
  643.       if (Is_Table (c))
  644. {
  645.   if (((code == VIEW) ||
  646.        (code == TMPTABLE)) &&
  647.       (VIEW_QUERY (c)))
  648.     {
  649.       t = VIEW_QUERY (c);
  650.       VIEW_QUERY (c) = TNULL;
  651.       free_tree (t);
  652.     }
  653.   else if (( code == TABLE) &&
  654.    (TBL_CONSTR (c) ))
  655.     {
  656.       t = TBL_CONSTR (c); 
  657.       TBL_CONSTR (c) = TNULL;
  658.       free_line (t);
  659.     }
  660. }
  661.       else if (code == COLUMN)
  662. {
  663.           t = COL_DEFAULT(c); 
  664.   COL_DEFAULT (c) = TNULL;
  665.   free_node (t);
  666. }
  667.       else if ( code == UNIQUE || code == PRIMARY || code == INDEX)
  668. {
  669.   t=DOWN_TRN(c);
  670.   DOWN_TRN(c) = TNULL;
  671.   free_line(t);
  672. }
  673.     }
  674.   t = RIGHT_TRN(c);
  675.   RIGHT_TRN(c) = TNULL;
  676.   free_line(t);
  677.   if (Is_Scan (c))
  678.     {
  679.       COR_TBL(c) = TNULL;
  680.       t = COR_COLUMNS(c);
  681.       COR_COLUMNS(c) = TNULL;
  682.       free_line (t);
  683.     }
  684.   else if (Is_Table (c))
  685.     {
  686.       free_line (IND_INFO(c));
  687.       IND_INFO(c) = TNULL;
  688.       t = TBL_COLS (c);
  689.       TBL_COLS(c) = TNULL;
  690.       free_line (t);
  691.     }
  692.   if (TstF_TRN (c, VCB_F))
  693.     free_node (c);
  694.   else
  695.     free_tree (c);
  696. }
  698. void
  699. free_tree (TXTREF root)
  700. {
  701.   register TXTREF t;
  702.   if (!root)
  703.     {
  704.       fprintf (STDERR, "warning (internal problem): "
  705.                "null pointer is tried to freen");
  706.       return;
  707.     }
  708.   if (!Ptree(root))
  709.     {
  710.       fprintf (STDERR, "warning (internal problem): "
  711.                "attemp to free unused memoryn");
  712.       return;
  713.     }
  714.   
  715.   if (TstF_TRN (root, VCB_F))
  716.     return;
  717.   if (HAS_DOWN (root))
  718.     {
  719.       t = DOWN_TRN (root);
  720.       DOWN_TRN(root) = TNULL;
  721.       ARITY_TRN(root) = 0;
  722.       free_line(t);
  723.     }
  724.   
  725.   {
  726.     register char *fmt = FORMAT (CODE_TRN (root));
  727.     register i4_t   i, l;
  728.     for (i = 0; *fmt; fmt++, i++)
  729.       {
  730. #define TST_PAT_BIT(n) TST_BIT(XLNG_TRN(root,PTRN_OP(CODE_TRN(root),n)),PTRN_BIT(n))
  731.         if ( TstF_TRN(root,ACTION_F) && TST_PAT_BIT(i) )
  732.           continue;
  733.         switch (*fmt)
  734.           {
  735.           case 'N':
  736.             if (XTXT_TRN (root, i))
  737.       {
  738. free_line (XTXT_TRN (root, i));
  739. XTXT_TRN(root,i) = TNULL;
  740.       }
  741.             break;
  742.           case 't':
  743.   case 'P':
  744.             if (XTXT_TRN (root, i))
  745.       {
  746. free_tree (XTXT_TRN (root, i));
  747. XTXT_TRN(root,i) = TNULL;
  748.       }
  749.             break;
  750.           case 'T':
  751.             if (XVEC_TRN (root, i))
  752.               for (l = 0; l < XLEN_VEC (root, i); l++)
  753. {
  754.   free_tree (XVECEXP (root, i, l));
  755.   XVECEXP (root, i, l) = TNULL;
  756. }
  757.           case 'L':
  758.             if (XVEC_TRN (root, i))
  759.       {
  760. free_vect (XVEC_TRN (root, i));
  761. XVEC_TRN (root, i) = TNULL;
  762.       }
  763.             break;
  764.           default:
  765.             break;
  766.           }
  767.       }
  768.   }
  769.   if (Is_Statement (root))
  770.     {
  771.       if (CODE_TRN (root) == CUR_AREA)
  772. del_info (STMT_VCB (root));
  773.       else
  774. free_line (STMT_VCB (root));
  775.       STMT_VCB(root) = TNULL;
  776.     }
  777.   if ( CODE_TRN(root) == NOOP)
  778.     {
  779.       XLNG_TRN(root,0)--;
  780.       if (XLNG_TRN(root,0)>0)
  781. return;
  782.     }
  783.   free_node (root);
  784. }
  786. /*******==================================================*******
  787. *******            Other functions                         *******
  788. *******==================================================*******/
  790. int
  791. compatible_tok_fl (enum token code, enum flags fcode)
  792. {
  793.   register char *p;
  794.   if (code == OPERAND)
  795.     return 1;
  796.   for (p = FLAGS (code); *p; p++)
  797.     if (*p == CLASS (fcode))
  798.       return 1;
  799.   return 0;
  800. }
  802. TXTREF
  803. copy_tree (TXTREF src)
  804. {
  805.   TXTREF dest, last_oper, src_oper;
  807.   if(!src)
  808.     return TNULL;
  809.   
  810.   last_oper = TNULL;
  811.   dest = copy_trn (src);
  812.   
  813.   if (dest && HAS_DOWN (dest))
  814.     {
  815.       ARITY_TRN (dest) = ARITY_TRN (src);
  816.       
  817.       for (src_oper = DOWN_TRN (src);
  818.            src_oper;
  819.            src_oper = RIGHT_TRN (src_oper)
  820.            )
  821.         if (last_oper)
  822.           last_oper = RIGHT_TRN (last_oper) = copy_tree (src_oper);
  823.         else
  824.           last_oper = DOWN_TRN (dest)       = copy_tree (src_oper);
  825.       
  826.       RIGHT_TRN (last_oper) = TNULL;
  827.     }
  828.   return dest;
  829. }
  831. #define CHECK_VCB {copy = add_info_l(copy);TASSERT(copy == tmp_trn,copy);}
  833. TXTREF
  834. copy_trn(register TXTREF orig)
  835. {
  836.   register TXTREF copy;
  837.   register enum token code;
  838.     
  839.   DECL_STACK (copy_trn_st, TXTREF);
  840.   
  841.   if (!orig)
  842.     return orig;
  843.   /* Vocabulary check */
  844.   code = CODE_TRN (orig);
  845.   copy = TNULL;
  847.  
  848.   if (TstF_TRN (orig, VCB_F))
  849.     {
  850.       TXTREF c;
  851.       copy = find_entry(orig);
  852.       if (copy)      /* local copy */
  853.         return copy;
  854.       COPY_NODE (code, orig, copy);
  855.       switch(code)
  856.         {
  857.         case TABLE:
  858.         case VIEW:
  859.         case TMPTABLE:
  860.         case ANY_TBL:
  861.           TBL_FNAME(copy) = ltr_rec(STRING(TBL_FNAME(orig)));
  862.           TBL_NAME(copy) = ltr_rec(STRING(TBL_NAME(orig)));
  863.           break;
  864.         case SCAN:
  865.           COR_NAME(copy) = (COR_NAME(orig)?ltr_rec(STRING(COR_NAME(orig))):TNULL);
  866.           COR_TBL(copy)  = copy_trn(COR_TBL(orig));
  867.           break;
  868.         case PRIMARY:
  869.         case UNIQUE:
  870.         case INDEX:
  871.           break;
  872.         case COLUMN:
  873.         case SCOLUMN:
  874.           COL_TBL(copy) = copy_trn(COL_TBL(copy));
  875.         case PARAMETER:
  876.         case CURSOR:
  877.           /* col_name is equivalent here to par_name, CUR_name */
  878.           COL_NAME(copy) = ltr_rec(STRING(COL_NAME(orig)));
  879.           break;
  880.         default:
  881.           lperror("unexpected vcb node: '%s' ",NAME(code));
  882.           return copy;
  883.         }
  884.       c = find_entry(copy);
  885.       if(!c && code==SCOLUMN)
  886.         c = add_info_l(copy);
  887.       if (c)      /* has already copyed to new segment */
  888.         {
  889.           if(c!=copy)
  890.             free_node(copy);
  891.           return c;
  892.         }
  893.     }
  894.   if (TstF_TRN (orig, MARK_F))
  895.     {
  896.       yyerror("attempt to copy cycled tree");
  897.       ClrF_TRN (orig, MARK_F);
  898.       debug_trn (orig);
  899.       SetF_TRN (orig, MARK_F);
  900.       return TNULL;
  901.     }
  902.   if (Is_Statement (orig))
  903.     {
  904.       PUSHS (copy_trn_st, LOCAL_VCB_ROOT);
  905.       LOCAL_VCB_ROOT = TNULL;
  906.     }
  907.   if (!copy)
  908.     COPY_NODE (code, orig, copy);
  909.   if (TstF_TRN (orig, VCB_F) && Is_Table(copy))
  910.     {
  911.       TXTREF tmp_trn = copy;
  912.       if(TstF_TRN(orig,CHECKED_F))
  913.         ClrF_TRN(copy,CHECKED_F);
  914.       CHECK_VCB;
  915.     }
  916.   SetF_TRN (orig, MARK_F);
  917.   {
  918.     register char *fmt;
  919.     register i4_t i;
  920.     fmt = FORMAT (code);
  921.     for (i = 0; *fmt; fmt++, i++)
  922.       switch (*fmt)
  923.         {
  924.         case 's':
  925.         case 'S':
  926.   XLTR_TRN(copy,i) = ((XLTR_TRN(orig,i)  != 0) ?
  927.       ltr_rec(STRING(XLTR_TRN(orig,i))) : 
  928.       TNULL);
  929.           break;
  930.         case 'N':
  931.           {
  932.             TXTREF v,v1;
  933.             
  934.             v=XTXT_TRN (orig, i);
  935.             v1 = XTXT_TRN (copy, i) = copy_trn (v);
  936.             while(v && RIGHT_TRN(v))
  937.               {
  938.                 v = RIGHT_TRN(v);
  939.                 RIGHT_TRN(v1) = copy_trn(v);
  940.                 v1 = RIGHT_TRN(v1);
  941.               }
  942.           }
  943.           break;
  944.         case 't':
  945.         case 'v':
  946.         case 'P':
  947.           XTXT_TRN (copy, i) = copy_trn (XTXT_TRN (orig, i));
  948.           break;
  949.         case 'V':
  950.           XTXT_TRN (copy, i) = TNULL;
  951.           break;
  952.         case 'r':
  953.           RIGHT_TRN (copy) = TNULL;
  954.           break;
  955.         case 'd':
  956.           DOWN_TRN (copy) = TNULL;
  957.           break;
  958.         case 'a':
  959.           ARITY_TRN (copy) = 0;
  960.           break;
  961.         case 'L':
  962.         case 'T':
  963.           {
  964.             register TXTREF vec, vec1;
  965.             register i4_t j;
  966.             vec = XTXT_TRN (orig, i);
  967.             j = VLEN (vec);
  968.             XTXT_TRN (copy, i) = vec1 = gen_vect (j);
  969.             while (j--)
  970.               if (*fmt == 'T')
  971.                 VOP (vec1, j).txtp = copy_trn (VOP (vec, j).txtp);
  972.               else
  973.                 VOP (vec1, j) = VOP (vec, j);
  974.             break;
  975.           }
  976.         default:
  977.           break;
  978.         }
  979.   }
  980.   /* Vocabulary check */
  981.   if (TstF_TRN (copy, VCB_F))
  982.     {
  983.       TXTREF tmp_trn = copy;
  984.       switch (code)
  985.         {
  986.         case COLUMN:
  987.           break;
  988.         case SCOLUMN:           /* link all backward reference */
  989.         case PARAMETER:
  990.         case CURSOR:
  991.         case SCAN:
  992.           CHECK_VCB;
  993.           break;
  994.         default:
  995.           if (Is_Table (copy))
  996.             {
  997.       if(TstF_TRN(orig,CHECKED_F))
  998. SetF_TRN(copy,CHECKED_F);
  999.             }                   /* Is_Table */
  1000.         }
  1001.     }
  1002. #undef CHECK_VCB
  1003.   ClrF_TRN (orig, MARK_F);
  1004.   if (!copy)
  1005.     {
  1006.       debug_trn (orig);
  1007.       yyfatal("Panic: null copy of subtree (see above) produced");
  1008.     }
  1009.   if (Is_Statement (copy))
  1010.     {
  1011.       STMT_VCB (copy) = LOCAL_VCB_ROOT;
  1012.       POPS (copy_trn_st, LOCAL_VCB_ROOT);
  1013.     }
  1014.   return copy;
  1015. }
  1017. /* 
  1018.  * Return 1 if X and Y are identical-looking trn's. This is the Lisp function
  1019.  * EQUAL for TXTREF arguments.  
  1020.  */
  1022. int
  1023. trn_equal_p (TXTREF x, TXTREF y)
  1024. {
  1025.   register i4_t i;
  1026.   register enum token code;
  1027.   register char *fmt;
  1028.   register TXTREF parmx, parmy;
  1030.   if (x == y)
  1031.     return 1;
  1032.   if (x == 0 || y == 0)
  1033.     return 0;
  1035.   code = CODE_TRN (x);
  1036.  /* call itself and swap parameters to avoid NOOPs */
  1037.   if (code == NOOP)
  1038.     return trn_equal_p (y,DOWN_TRN(x));
  1040.   /* Trn's of different codes cannot be equal.  */
  1041.   if (code != CODE_TRN (y))
  1042.     return 0;
  1044.   {
  1045.     MASKTYPE msk, msk1, msk2;
  1046.     msk1 = 0;
  1047.     SetF (msk1, PATTERN_F);
  1048.     msk1 = 2 * msk1 - 1;
  1050.     msk = MASK_TRN (x);
  1051.     msk CLRVL msk1;             /* clear all bits less than PATTERN_F */
  1052.     ClrF (msk, MARK_F);
  1054.     msk2 = MASK_TRN (y);
  1055.     msk2 CLRVL msk1;            /* clear all bits less than PATTERN_F */
  1056.     ClrF (msk2, MARK_F);
  1057.     if (msk != msk2)
  1058.       return 0;
  1059.   }
  1061.   /* Compare the elements.  If any pair of corresponding elements fail to
  1062.      match, return 0 for the whole things.  */
  1064.   fmt = FORMAT (code);
  1065.   for (i = LENGTH (code) - 1; i >= 0; i--)
  1066.     {
  1067.       switch (fmt[i])
  1068.         {
  1069.         case 'i':
  1070.         case 'f':
  1071.         case 'l':
  1072.         case 'a':               /* because they must has equal number of params*/
  1073.           if (XLNG_TRN (x, i) != XLNG_TRN (y, i))
  1074.             return 0;
  1075.           break;
  1076.   
  1077.         case 's':               /* because identical literals save just once   */
  1078.           if (XLNG_TRN (x, i) == XLNG_TRN (y, i))
  1079.     break;
  1080.           if (strcmp(STRING(XLTR_TRN (x, i)),STRING(XLTR_TRN (y, i))))
  1081.             return 0;
  1082.   break;
  1084.         case 't':
  1085.         case 'v':
  1086.         case 'P':
  1087.           if (trn_equal_p (XTXT_TRN (x, i), XTXT_TRN (y, i)) == 0)
  1088.             return 0;
  1089.           break;
  1091.         case 'V':
  1092.         case 'p':
  1093.         case '0':
  1094.         case 'd':
  1095.         case 'r':
  1096. case 'x':
  1097.         case 'R':
  1098.   break;
  1099.   
  1100.         case 'y':
  1101.   if (XLNG_TRN (x, i) != XLNG_TRN(y, i))
  1102.     return 0;
  1103.   break;
  1104.       
  1105.         case 'L':
  1106.   {
  1107.     TXTREF patvect=XVEC_TRN(x,i);
  1108.     TXTREF invect=XVEC_TRN(y,i);
  1109.     i4_t j=VLEN(patvect);
  1110.     if(j!=VLEN(invect))
  1111.       return 0;
  1112.     for(;j;j--)
  1113.       if(VOP(patvect,j).l != VOP(invect,j).l)
  1114. return 0;
  1115.   }
  1116.     break;
  1117.         case 'T':               /* array of longs and TXTREF's */
  1118.    { 
  1119.     TXTREF patvect=XVEC_TRN(x,i);
  1120.     TXTREF invect=XVEC_TRN(y,i);
  1121.     i4_t j=VLEN(patvect);
  1122.     if(j!=VLEN(invect))
  1123.       return 0;
  1124.     for(;j;j--)
  1125.       if(VOP(patvect,j).txtp != VOP(invect,j).txtp)
  1126. return 0;
  1127.   }
  1128.           break;
  1130.         default:
  1131.           yyfatal ("TRL.trn_equal_p: unexpected format character");
  1132.         }
  1133.     }
  1134.   /* param's check */
  1135.   if (HAS_DOWN (x))
  1136.     for (
  1137.       i = ARITY_TRN (x),
  1138. parmx = DOWN_TRN (x),
  1139. parmy = DOWN_TRN (y);
  1140.       i && parmx && parmy;
  1141.       i--,
  1142. parmx = RIGHT_TRN (parmx),
  1143. parmy = RIGHT_TRN (parmy)
  1144.       )
  1145.       if (trn_equal_p (parmx, parmy) == 0)
  1146.         return 0;
  1147.   return 1;
  1148. }
  1151. /*******==================================================*******
  1152. *******            Compiler limit functions                *******
  1153. *******==================================================*******/
  1155. int
  1156. trl_wrn (char *msg, char *file, i4_t line, trn ptr)
  1157. {
  1158.   fprintf (STDERR, "nn%s:%d: %s nn", file, line, msg);
  1159.   debug_trn_d (ptr);
  1160.   return 0;
  1161. }
  1163. int
  1164. trl_err (char *msg, char *file, i4_t line, trn ptr)
  1165. {
  1166.   trl_wrn (msg, file, line, ptr);
  1167.   yyfatal ("Abort");            /* ==> Exit */
  1168.   /* Unreachable */
  1169.   assert(0);
  1170.   return 0;
  1171. }
  1173. int
  1174. fmt_eq (char *fmt, char *tst)
  1175. {
  1176.   register char *f = fmt, *t = tst;
  1177.   while (*t)
  1178.     if (*(f++) != *(t++))
  1179.       return 0;
  1180.   return 1;
  1181. }
  1184. #ifdef CHECK_TRL
  1186. trn
  1187. test_exist (trn node, i4_t n, char *_FILE__, i4_t _LINE__)
  1188. {
  1189.   register i4_t l;
  1190.   enum token code = CODe_TRN1 (node);
  1191.   l = LENGTH (code);
  1192.   if (Tstf_TRN (node, PATTERN_F))
  1193.     l += PTRN_ELEM (code);
  1194.   if (Tstf_TRN (node, ACTION_F))
  1195.     l += PTRN_ELEM (code);
  1196.   if (n < l)
  1197.     return node;
  1198.   trl_err ("TRL: number of operand is too much in ", _FILE__, _LINE__, node);
  1199.   /* unreachable code */
  1200.   return 0;
  1201. }
  1203. trn
  1204. test_node (trn node, char *f, i4_t l)
  1205. {
  1206.   register enum token code;
  1207.   if (node == NULL)
  1208.     trl_err ("TRL: null tree reference ", f, l, NULL);
  1209.   code = node->code;
  1210.   if (code <= UNKNOWN || code >= LAST_TOKEN)
  1211.     trl_err ("TRL: unexpected tree code ", f, l, NULL);
  1212.   return node;
  1213. }
  1215. int
  1216. tstv_exist (trvec vec, i4_t n, char *_FILE__, i4_t _LINE__)
  1217. {
  1218.   if (n < VLEn1 (vec))
  1219.     return n;
  1220.   fprintf (STDERR,
  1221.         "nnInternal error: %s:%d: number of vector element is too muchn",
  1222.            _FILE__, _LINE__);
  1223.   yyfatal ("Abort");            /* ==> Exit */
  1224.   /* Unreached */
  1225.   return 0;
  1226. }
  1228. trvec
  1229. tstv_vec (trvec vec, char *f, i4_t l)
  1230. {
  1231.   if (vec)
  1232.     return vec;
  1233.   trl_err ("TRL: null vector reference ", f, l, NULL);
  1234.   /* unreachable code */
  1235.   return NULL;
  1236. }
  1238. tr_union *
  1239. xOp_parm (trn node, i4_t n, char c, char *_FILE__, i4_t _LINE__)
  1240. {
  1241.   register char *fmt = FORMAT (CODe_TRN1 (node));
  1242.   register i4_t nn = n;
  1243.   if (fmt[nn] != c)
  1244.     {
  1245.       for (nn = 0; fmt[nn]; nn++)
  1246.         if (fmt[nn] == c)
  1247.           break;
  1248.       if (fmt[nn] == 0)
  1249.         trl_err ("TRL: incorrect format request in ", _FILE__, _LINE__, node); /* ==>exit */
  1250.     }
  1251.   return &(node->operands[nn]);
  1252. }
  1254. tr_union *
  1255. xOp_parms (trn node, i4_t n, char *s, char *_FILE__, i4_t _LINE__)
  1256. {
  1257.   if (fmt_eq (FORMAT (CODe_TRN1 (node)) + n, s))
  1258.     return &(node->operands[n]);
  1259.   trl_err ("TRL: incorrect struct format request in ", _FILE__, _LINE__, node);
  1260.   return NULL;
  1261. }
  1263. #endif