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

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

SQL Server

开发平台：

Unix_Linux

parse.y：源码内容
  1. %{
  2. /* 
  3.  *  parse.y   -   SQL grammar (ANSI SQL'89 + some extention) 
  4.  *                of GNU SQL compiler
  5.  *
  6.  *  This file is a part of GNU SQL Server
  7.  *
  8.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  9.  *  Developed at the Institute of System Programming
  10.  *  This file is written by Michael Kimelman.
  11.  * 
  12.  *  This program is free software; you can redistribute it and/or modify
  13.  *  it under the terms of the GNU General Public License as published by
  14.  *  the Free Software Foundation; either version 2 of the License, or
  15.  *  (at your option) any later version.
  16.  *
  17.  *  This program is distributed in the hope that it will be useful,
  18.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  *  GNU General Public License for more details.
  21.  *
  22.  *  You should have received a copy of the GNU General Public License
  23.  *  along with this program; if not, write to the Free Software
  24.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25.  *
  26.  *  Contact:  gss@ispras.ru
  27.  *
  28.  */
  30. /* $Id: parse.y,v 1.245 1997/03/31 03:46:38 kml Exp $ */
  32. #include "trl.h"
  33. #include "tree_gen.h"
  34. #include "cycler.h"
  35. #include "sql_decl.h"
  36. #include "xmem.h"
  37. #include "type_lib.h"
  38. #include "svr_lib.h"
  39. #include <assert.h>
  40. #include "tassert.h"
  42. char *dyn_sql_stmt_name  = NULL;
  43. i4_t   dyn_sql_section_id = 0;
  45. static TN      tblnm;
  46. static i4_t     del_local_vcb    = 0;
  47. static char   *label_nf         = NULL;
  48. static char   *label_er         = NULL;
  49. static i4_t     subquery         = 0;
  50. static TXTREF  new_table        = TNULL;
  51. static i4_t     new_table_col_no = 0;
  52. static call_t  call;
  54. static enum 
  55. {
  56.   Esql,
  57.   Module,
  58.   Schema,
  59.   Dynamic
  60. } parse_mode=Esql;
  62. #ifdef stderr
  63. #  undef stderr
  64. #endif
  65. #ifdef stdout
  66. #  undef stdout
  67. #endif
  69. #define stderr STDERR
  70. #define stdout STDOUT
  72. #define FICTIVE_NODE  (TXTREF)(-1L)
  74. #define FREE_VCB   free_line(LOCAL_VCB_ROOT)
  75. #define YYERROR_VERBOSE
  76. #define YYERROK { new_table = TNULL; yyerrok; }
  77. i4_t yylex (void);
  79. static void   check_not_null __P((TXTREF ind));
  80. static void   free_tail __P((void));
  81. static TXTREF replace_column_holes __P((TXTREF rb,VCBREF tbl));
  82. static void   add_table_column(enum token tbl_code, LTRLREF ltrp,
  83.                                sql_type_t type, TXTREF def,TXTREF constr);
  84. static void   emit_module_proc __P((VCBREF parmlist,LTRLREF procname));
  85. static void   emit_call __P((TXTREF vcb,i4_t object_id, i4_t method_id));
  87. #define add_base_column(ltrp,type,def,constr) 
  88.      add_table_column(TABLE,ltrp,type,def,constr)
  89. #define add_view_column(ltrp,type) 
  90.      add_table_column(VIEW,ltrp,type,TNULL,TNULL)
  92. %}
  94. %union {
  95.   LTRLREF  ltrp;
  96.   TXTREF   node;
  97.   i4_t      code;
  98.   sql_type_t     type;
  99.   void     *ptr;
  100. }
  102. /*
  103.   token declarations
  104. */
  105. %token TOK_ALL
  106. %token TOK_ALTER
  107. %token TOK_ANY
  108. %token TOK_AS
  109. %token TOK_ASC
  110. %token TOK_AUTHORIZATION
  111. %token TOK_BEGIN  
  112. %token TOK_BETWEEN
  113. %token TOK_BY
  114. %token TOK_CHECK
  115. %token TOK_CLOSE
  116. %token TOK_COBOL_LANG
  117. %token TOK_C_LANG
  118. %token TOK_COMMIT
  119. %token TOK_CONTINUE
  120. %token TOK_CREATE
  121. %token TOK_CURRENT
  122. %token TOK_CURSOR
  123. %token TOK_DECLARE
  124. %token TOK_DEFAULT       
  125. %token TOK_DELETE
  126. %token TOK_DESC
  127. %token TOK_DISTINCT
  128. %token TOK_DROP
  129. %token TOK_END          
  130. %token TOK_ESCAPE
  131. %token TOK_EXISTS
  132. %token TOK_FETCH
  133. %token TOK_FOR
  134. %token TOK_FOREIGN       
  135. %token TOK_FORTRAN_LANG
  136. %token TOK_FOUND      
  137. %token TOK_FROM
  138. %token TOK_GOTO 
  139. %token TOK_GRANT
  140. %token TOK_GROUP
  141. %token TOK_HAVING
  142. %token TOK_IN
  143. %token TOK_INDICATOR
  144. %token TOK_INSERT
  145. %token TOK_INTO
  146. %token TOK_IS
  147. %token TOK_KEY     
  148. %token TOK_LANGUAGE
  149. %token TOK_LIKE
  150. %token TOK_MODULE
  151. %token TOK_NULL
  152. %token TOK_OF
  153. %token TOK_ON
  154. %token TOK_OPEN
  155. %token TOK_OPTION
  156. %token TOK_ORDER
  157. %token TOK_PASCAL_LANG
  158. %token TOK_PL1_LANG
  159. %token TOK_PRIMARY       
  160. %token TOK_INDEX         
  161. %token TOK_PRIVILEGES
  162. %token TOK_PROCEDURE
  163. %token TOK_PUBLIC
  164. %token TOK_REFERENCES    
  165. %token TOK_REVOKE
  166. %token TOK_ROLLBACK
  167. %token TOK_SCHEMA
  168. %token TOK_SECTION       
  169. %token TOK_SELECT
  170. %token TOK_SET
  171. %token TOK_SOME
  172. %token TOK_SQLCODE
  173. %token TOK_SQLERROR      
  174. %token TOK_TABLE
  175. %token TOK_TO
  176. %token TOK_UNION
  177. %token TOK_UNIQUE
  178. %token TOK_UPDATE
  179. %token TOK_USER
  180. %token TOK_VALUES
  181. %token TOK_VIEW
  182. %token TOK_WHENEVER      
  183. %token TOK_WHERE
  184. %token TOK_WITH
  185. %token TOK_WORK
  187. %token TOK_AND
  188. %token TOK_OR
  189. %token TOK_NOT
  191. %token TOK_NE
  192. %token TOK_GE
  193. %token TOK_LE
  195. %token TOK_AVG
  196. %token TOK_MAX
  197. %token TOK_MIN
  198. %token TOK_SUM
  199. %token TOK_COUNT
  201. %token <ltrp> TOK_IDENTIFIER
  202. %token <ltrp> TOK_PARAM
  203. %token <node> TOK_INTEGER_CONST
  204. %token <node> TOK_NUM_CONST
  205. %token <node> TOK_REAL_CONST
  206. %token <node> TOK_STRING_CONST
  208. %token TOK_T_CHAR
  209. %token TOK_T_NUM
  210. %token TOK_T_INT
  211. %token TOK_T_SINT
  212. %token TOK_T_FLT
  213. %token TOK_T_DOUBLE
  214. %token TOK_T_PRECISION
  215. %token TOK_T_REAL
  217. %token UNARY BRACETS 
  219. %left ','
  222. %left TOK_ALL
  223. %left TOK_UNION
  225. %left TOK_OR
  226. %left TOK_AND
  227. %left TOK_NOT
  229. %left '+' '-'
  230. %left '*' '/'
  232. %left UNARY
  233. %nonassoc BRACETS
  235. %left '.'
  237. %start sql_compiled
  239. %%
  241. sql_compiled
  242.   : schema_title
  243.     { 
  244.       if (progname && *progname)
  245.         yyerror ("Unexpected schema operation in static mode compilation ");
  246.       else if (parse_mode==Module)
  247.         yyerror ("Unexpected schema operation inside module");
  248.       if($<code>1)
  249.         parse_mode=Schema;
  250.     }
  251.   | schema_element /* MUST be in dynamic compilation mode */
  252.     { 
  253.       if (progname && *progname)
  254.         yyerror ("Unexpected schema operation in static mode compilation ");
  255.       else if (parse_mode==Module)
  256.         yyerror ("Unexpected schema operation inside module");
  257.     }
  258.   | module_header
  259.     { if ($<code>1) parse_mode=Module; }
  260.   | cursor
  261.     { ; }
  262.   | procedure
  263.     { 
  264.       if(parse_mode!=Module)
  265.         yyerror("Unexpected module operation outside module");
  266.     }
  267.   | embedded_spec
  268.     { ; }
  269.   | statement
  270.     {
  271.       if(parse_mode==Esql)
  272.         {
  273.           free_tail();
  274.           $<code>$=0;
  275.         }
  276.     }
  277.   | dynamic {}
  278.   | error 
  279.     {
  280.       yyerror("Error: unrecognizable SQL construction in input file");
  281.       free_tail();
  282.       YYERROK; yyclearin;
  283.       YYACCEPT;
  284.     }
  285.   ;
  287. /*
  288.  *  dynamic additions
  289.  */
  291. tbl_or_view
  292.   : TOK_TABLE { $<code>$ = TABLE; }
  293.   | TOK_VIEW  { $<code>$ = VIEW;  }
  294.   ;
  296. dynamic 
  297.   : queryexpr
  298.     {
  299.       TXTREF c,d = gen_parent(DECL_CURS,$<node>1);
  300.       STMT_VCB(d) = LOCAL_VCB_ROOT;
  301.       SetF_TRN(d,HAS_VCB_F);
  302.       LOCAL_VCB_ROOT = TNULL;
  303.       c = gen_parent(CUR_AREA,d);
  304.       add_statement(c);
  305.       d = gen_node(CURSOR);
  306.       if (dyn_sql_stmt_name)
  307.         CUR_NAME(d) = ltr_rec(dyn_sql_stmt_name);
  308.       else
  309.         yyfatal("Attemp to compile unnamed statement");
  310.       CUR_DECL(d) = c;
  311.       STMT_VCB(c) = d;
  312.       $<code>$ = 0;
  313.     }
  314.   | TOK_DROP tbl_or_view table_desc
  315.      {
  316.        TXTREF d = gen_object(DROP,@1);
  317.        CREATE_OBJ(d) = $<node>3;
  318.        CODE_TRN($<node>3) = $<code>2;
  319.        add_statement(d);
  320.      }
  321.   ; 
  323. /*
  324.   schema definition
  325. */
  327. schema_title
  328.   : schema_action TOK_SCHEMA autoriz_clause
  329.    { {
  330.      add_statement(gen_object($<code>1,@2));
  331.      $<code>$ = 0;
  332.    } }
  333.   ;
  336. schema_element
  337.   : basetable
  338.   | view
  339.   | privilege
  340.   ;
  342. schema_action
  343.   : TOK_CREATE
  344.     { $<code>$=CREATE; }
  345.   | TOK_ALTER
  346.     { $<code>$=ALTER; }
  347.   ;
  348.   
  349. basetable
  350.   : schema_action basetable_def
  351.      {
  352.        register TXTREF e=gen_object($<code>1,@1);
  353.        CREATE_OBJ(e)=$<node>2;
  354.        add_statement(e);
  355.        $<code>$=STMT_UID(e);
  356.      }
  357.   ;
  359. basetable_def
  360.   :TOK_TABLE table_def '(' basetableelement_list ')'
  361.     {
  362.       register TXTREF t=$<node>2,e=$<node>4;
  363.       if (!t)
  364.         free_line (e);
  365.       else if (new_table != t)
  366.         yyfatal ("Internal error: unexpected 'new_table'");
  367.       else
  368.         {
  369.           CODE_TRN (t) = TABLE;
  370.   TBL_NCOLS(t) = new_table_col_no;
  371.           SetF_TRN (t, CHECKED_F);
  372.           new_table = TNULL;
  373.         }
  374.       $<node>$=t;
  375.     }
  376.   ;
  379. basetableelement_list
  380.   : basetableelement
  381.     { $<node>$=$<node>1;}
  382.   | basetableelement_list ',' basetableelement
  383.     { $<node>$=join_list($<node>1,$<node>3);}
  384.   ;
  386. basetableelement
  387.   : column_descr   { $<node>$=$<node>1; }
  388.   | table_constr   { $<node>$=$<node>1; }
  389.   ;
  391. column_descr                                     /*==*/
  392.   : TOK_IDENTIFIER type default_clause column_constrts
  393.     {
  394.       if(new_table)
  395.         add_base_column($<ltrp>1,$<type>2,$<node>3,$<node>4);
  396.       $<node>$ = TNULL;
  397.     }
  398.   ;
  400. default_clause
  401.   :  { $<node>$ = TNULL;     }
  402.   | TOK_DEFAULT def_clause  
  403.      { $<node>$ = $<node>2; }
  404.   ;
  406. def_clause
  407.   : TOK_USER
  408.     {
  409.       $<node>$ = gen_object (USERNAME, @1);
  410.       USR_NAME ($<node>$) = $<ltrp>1;
  411.     }
  412.   | TOK_NULL
  413.     { $<node>$ = gen_object (NULL_VL, @1); }
  414.   | constant
  415.     { $<node>$ = $<node>1; }
  416.   ;
  418. column_constrts
  419.   :
  420.     { $<node>$ = TNULL;        }
  421.   | constr_list 
  422.     { $<node>$ = $<node>1; }
  423.   ;
  425. constr_list
  426.   : column_constr
  427.     { $<node>$ = $<node>1; }
  428.   | constr_list column_constr
  429.     { $<node>$ = join_list($<node>1,$<node>2); }
  430.   ;
  432. column_constr
  433.   : TOK_NOT TOK_NULL
  434.     { $<node>$ = gen_object (NULL_VL, @2); }
  435.   | TOK_NOT TOK_NULL unique_spec
  436.     { $<node>$ = gen_object ($<code>3, @3); } 
  437.   | refer_spec
  438.     { $<node>$ = $<node>1; }
  439.   | TOK_CHECK cond
  440.     {
  441.       $<node>$ = gen_up_node (CHECK, $<node>2, @1);
  442.     }
  443.   ;
  445. table_constr
  446.   : table_constr1
  447.     {{
  448.       if(!new_table)
  449.         yyerror("Unexpected constraints");
  450.       else
  451. switch(CODE_TRN($<node>1))
  452.   {
  453.           case NULL_VL:
  454.             yyfatal("Unexpected NULL_VL node");
  455.             break;
  456.   case PRIMARY:
  457.   case UNIQUE:
  458.             check_not_null($<node>1);
  459.   case INDEX:
  460.     IND_INFO(new_table)=
  461.       join_list(IND_INFO(new_table),$<node>1);
  462.     break;
  463.   default:
  464.             RIGHT_TRN($<node>1) = TNULL;
  465.     TBL_CONSTR(new_table)=
  466.       join_list(TBL_CONSTR(new_table),$<node>1);
  467.   }
  468.       $<node>$ = TNULL;
  469.     }}
  470.   ;
  472. table_constr1
  473.   : unique_spec  '(' column_name_list ')'
  474.     {
  475.       $<node>$=gen_up_node($<code>1,
  476.                            replace_column_holes($<node>3,new_table),
  477.                            @1);
  478.     }
  479.   | TOK_FOREIGN TOK_KEY '(' column_name_list ')' refer_spec
  480.     {
  481.       $<node>$=
  482.         gen_up_node(FOREIGN,
  483.                     join_list(gen_parent(LOCALLIST,
  484.                                          replace_column_holes($<node>4,
  485.                                                               new_table)),
  486.                               $<node>6),
  487.                     @1);
  488.     }
  489.   | TOK_CHECK cond
  490.     {
  491.       $<node>$=gen_up_node(CHECK,
  492.                            replace_column_holes($<node>2,
  493.                                                 new_table),
  494.                            @1);
  495.     }
  496.   ;
  498. unique_spec
  499.   : TOK_UNIQUE           { $<code>$=UNIQUE; }
  500.   | TOK_PRIMARY TOK_KEY  { $<code>$=PRIMARY; }
  501.   | TOK_INDEX            { $<code>$=INDEX; }
  502.   ;
  504. refer_spec 
  505.   : TOK_REFERENCES table_desc opt_column_name_list
  506.     { {
  507.       TXTREF t = gen_object(OPTR,@1);
  508.       OBJ_DESC(t)  = $<node>2;
  509.       $<node>$ = gen_up_node(REFERENCE,
  510.                              join_list(t,gen_parent(NOOP,$<node>3)),
  511.                              @1);
  512.     } }
  513.   ;
  515. opt_column_name_list
  516.   : { $<node>$=0; }
  517.   |'(' column_name_list ')'
  518.     { $<node>$=$<node>2;}
  519.   ;
  521. column_name_list
  522.   : TOK_IDENTIFIER
  523.     {
  524.       $<node>$=gen_column(NULL,$<ltrp>1,@1);
  525.     }
  526.   | column_name_list ',' TOK_IDENTIFIER
  527.     {
  528.       $<node>$=join_list($<node>1,gen_column(NULL,$<ltrp>3,@3));
  529.     }
  530.   ;
  532. view
  533.   : TOK_CREATE view_definition
  534.     {
  535.       register TXTREF e;
  536.       e=gen_object(CREATE,@1);
  537.       CREATE_OBJ(e)=$<node>2;
  538.       add_statement(e);
  539.       $<code>$=STMT_UID(e);
  540.     }
  541.   ;
  543. view_definition
  544.   : TOK_VIEW table_def opt_column_name_list
  545.     TOK_AS queryspec opt_check_option
  546.     {
  547.       register TXTREF t = $<node>2, e= $<node>3;
  548.       if(!t)
  549.         free_line (e);
  550.       else
  551.         {
  552.           TXTREF     c;
  553.           sql_type_t type  = pack_type(SQLType_0,0,0);
  554.           i4_t        e_cnt = count_list (e);
  555.           
  556.           TXTREF sel_node = RIGHT_TRN (DOWN_TRN ($<node>5));
  557.           
  558.           CODE_TRN (t) = VIEW;
  560.           if (e)
  561.             if (e_cnt != ARITY_TRN (sel_node))
  562.               {
  563.                 yyerror("Incorrect number of columns in VIEW defenition");
  564.                 free_line(e);
  565.                 e = TNULL;
  566.               }
  567.           if (e)
  568.             {
  569.               for ( c = e ; c ; c = RIGHT_TRN(c))
  570.                 add_view_column(CHOLE_CNAME(OBJ_DESC(c)),type);
  571.               free_line (e);
  572.             }
  573.           else
  574.             {
  575.               for ( c = DOWN_TRN(sel_node) ; c ; c = RIGHT_TRN(c))
  576.                 {
  577.                   if (CODE_TRN(c) == COLPTR)
  578.                     add_view_column(CHOLE_CNAME(OBJ_DESC(c)),type);
  579.                   else
  580.                     yyerror("Expressions aren't allowed in selection list"
  581.                             " of anonimous view");
  582.                 }
  583.             }
  584.           /* TASSERT(new_table_col_no == ARITY_TRN(sel_node),sel_node); */
  585.   TBL_NCOLS(t) = ARITY_TRN(sel_node);
  586.             
  587.           VIEW_QUERY (t) = $<node>5;
  588.           if($<code>6) SetF_TRN (t, CHECK_OPT_F);
  589.           SetF_TRN (t, CHECKED_F);
  590.           VIEW_VCB (t) = LOCAL_VCB_ROOT;
  591.           LOCAL_VCB_ROOT = TNULL;
  592.           new_table = TNULL;
  593.         }
  594.       $<node>$=t;
  595.     }
  596.   ;
  598. opt_check_option
  599.   :                                { $<code>$=0; }
  600.   |TOK_WITH TOK_CHECK TOK_OPTION   { $<code>$=1; }
  601.   ;
  603. privilege_action
  604.   : TOK_GRANT
  605.     { $<code>$=GRANT; }
  606.   | TOK_REVOKE
  607.     { $<code>$=REVOKE; }
  608.   ;
  610. privilege
  611.   : privilege_action privileges TOK_ON table_desc TOK_TO grantees
  612.     opt_grant
  613.     {
  614.       register TXTREF p,g;
  615.       register i4_t    err = errors;
  616.       
  617.       p=replace_column_holes($<node>2,$<node>4);
  618.       p = gen_parent(PRIVILEGIES, p);
  620.       if (errors != err) /* if there was some error in the tree */
  621.         {
  622.           g =  gen_parent(GRANTEES, $<node>6);
  623.           debug_trn(p);
  624.           free_tree(p);
  625.           debug_trn(g);
  626.           free_tree(g);
  627.         }
  628.       else
  629.         {
  630.           g=gen_node(TBLPTR);
  631.           TABL_DESC(g) = $<node>4;
  632.           g=gen_up_node($<code>1,
  633.                         join_list(g,       
  634.                                   join_list(p,
  635.                                             gen_parent(GRANTEES,
  636.                                                        $<node>6))),
  637.                         @1);
  638.           if($<code>7)
  639.             SetF_TRN(g,GRANT_OPT_F);
  640.           add_statement(g);
  641.           $<code>$=STMT_UID(g);
  642.         }
  643.     }
  644.   ;
  646. opt_grant
  647.   :                               { $<code>$=0; }
  648.   | TOK_WITH TOK_GRANT TOK_OPTION { $<code>$=1; }
  649.   ;
  651. privileges
  652.   : TOK_ALL TOK_PRIVILEGES    { $<node>$=0; }
  653.   | operation_list            { $<node>$=$<node>1; }
  654.   ;
  656. operation_list
  657.   : operation                     { $<node>$=$<node>1;}
  658.   | operation_list ',' operation  { $<node>$=join_list($<node>1,$<node>3);}
  659.   ;
  661. operation
  662.   : TOK_SELECT    
  663.     { $<node>$ = gen_object(SELECT,@1); }   
  664.   | TOK_INSERT
  665.     { $<node>$ = gen_object(INSERT,@1); }   
  666.   | TOK_DELETE
  667.     { $<node>$ = gen_object(DELETE,@1); }   
  668.   | TOK_UPDATE     opt_column_name_list
  669.     { $<node>$ = gen_up_node(UPDATE,$<node>2,@1); }   
  670.   | TOK_REFERENCES opt_column_name_list
  671.     { $<node>$ = gen_up_node(REFERENCE,$<node>2,@1); }
  672.   ;
  674. grantees
  675.   : grantee_list              { $<node>$ = $<node>1;                  }
  676.   | TOK_PUBLIC                
  677.     {
  678.       register TXTREF u=gen_object(USERNAME,@1);
  679.       USR_NAME(u)=ltr_rec("PUBLIC");
  680.       $<node>$=u;
  681.     }
  682.   ;
  684. grantee_list
  685.   : grantee                   { $<node>$=$<node>1;}
  686.   | grantee_list ',' grantee  { $<node>$=join_list($<node>1,$<node>3);}
  687.   ;
  689. grantee
  690.   : TOK_IDENTIFIER  /* user */
  691.     {
  692.       register TXTREF u=gen_object(USERNAME,@1);
  693.       USR_NAME(u)=$<ltrp>1;
  694.       $<node>$=u;
  695.     }
  696.   ;
  698. /*=======================================================================
  699. |                       embedded statements                              |
  700. =======================================================================*/
  702. embedded_spec
  703.   : declare_section  { ; }
  704.   | exception        { ; }
  705.   ;
  707. declare_section
  708.   : TOK_BEGIN TOK_DECLARE TOK_SECTION  { $<code>$=1; }
  709.   | TOK_END TOK_DECLARE TOK_SECTION    { $<code>$=0; }
  710.   ;
  712. exception
  713.   : TOK_WHENEVER exc_cond exc_do
  714.    {
  715.      *( $<code>2 ? &label_nf : &label_er ) =
  716.        ( $<ltrp>3 ? (STRING($<ltrp>3)) : NULL );
  717.    }
  718.   ;
  720. exc_cond
  721.   : TOK_NOT TOK_FOUND                  { $<code>$=1; }
  722.   | TOK_SQLERROR                       { $<code>$=0; }
  723.   ;
  725. exc_do
  726.   : TOK_CONTINUE                       { $<ltrp>$=0; }
  727.   | TOK_GOTO TOK_IDENTIFIER            { $<ltrp>$=$<ltrp>2; }
  728.   ;
  731. /*=======================================================================
  732. |                       modules                                          |
  733. =======================================================================*/
  735. module_header
  736.   : module_titl lang_clause autoriz_clause
  737.     { $<code>$=1; }
  738.   | module_titl error
  739.     {
  740.       YYERROK;
  741.       yyerror("Error in module title");
  742.       $<code>$=0;
  743.     }
  744.     ;
  746. module_titl
  747.   : TOK_MODULE TOK_IDENTIFIER  
  748.     { $<code>$=0; }
  749.   | TOK_MODULE
  750.     { $<code>$=0; }
  751.   ;
  753. lang_clause
  754.   : TOK_LANGUAGE TOK_IDENTIFIER
  755.     {
  756.       if (strncmp("C",STRING($<ltrp>2),1)==0)
  757.         $<code>$=0;
  758.       else
  759.         {
  760.           lperror("SQL module for %s program can't be processed yet",
  761.                   STRING($<ltrp>2));
  762.           YYABORT;
  763.         }
  764.     }
  765.   ;
  767. autoriz_clause
  768.   : TOK_AUTHORIZATION TOK_IDENTIFIER
  769.    { {
  770.      extern char *current_user_login_name;
  771.      char *s, *s1;
  773.      s1 = current_user_login_name;
  774.      current_user_login_name = NULL;
  775.      s = get_user_name ();
  776.      current_user_login_name = s1;
  777.      
  779.      if(GL_AUTHOR && (GL_AUTHOR!=$<ltrp>2) && s &&
  780.         (strcmp(STRING(GL_AUTHOR),s)))
  781.        yyerror("Incorrect user identifier");
  782.      else
  783.        GL_AUTHOR=$<ltrp>2;
  784.    } }
  785.   ;
  787. cursor
  788.   : TOK_DECLARE TOK_IDENTIFIER TOK_CURSOR TOK_FOR /* cursor - IDENTIFIER */
  789.     queryexpr
  790.     orderby
  791.     {
  792.       register TXTREF c,d;
  793.       d=gen_up_node(DECL_CURS,join_list($<node>5,$<node>6),@1);
  794.       STMT_VCB(d)=LOCAL_VCB_ROOT;
  795.       SetF_TRN(d,HAS_VCB_F);
  796.       LOCAL_VCB_ROOT = TNULL;
  797.       d=gen_up_node(CUR_AREA,d,@1);
  798.       add_statement(d);
  800.       c=gen_node(CURSOR);
  801.       CUR_DECL(c)=d;
  802.       CUR_NAME(c)=$<ltrp>2;
  803.       STMT_VCB(d)=c;
  805.       if(find_info(CURSOR,CUR_NAME(c)))
  806.         {
  807.           char cn[512];
  808.           lperror("Static cursor name '%s' redeclaration",STRING(CUR_NAME(c)));
  809.           sprintf(cn,"%s_1",STRING(CUR_NAME(c)));
  810.           CUR_NAME(c) = ltr_rec(cn);
  811.         }
  812.       add_info(c);
  813.       $<code>$=0;
  814.     }
  815.     ;
  817. procedure
  818.   : TOK_PROCEDURE TOK_IDENTIFIER parameter_list ';' statement ';'
  819.     {
  820.       emit_module_proc($<node>3,$<ltrp>2);
  821.       free_line($<node>3);
  822.       $<code>$=0;
  823.     }
  824.   | TOK_PROCEDURE TOK_IDENTIFIER ';' statement ';'
  825.     {
  826.       emit_module_proc(LOCAL_VCB_ROOT,$<ltrp>2);
  827.       $<code>$=0;
  828.     }
  829.   | TOK_PROCEDURE TOK_IDENTIFIER ';' error ';'
  830.     {
  831.       YYERROK;
  832.       yyerror("Error in procedure's body");
  833.     }
  834.   | TOK_PROCEDURE TOK_IDENTIFIER parameter_list ';' error ';'
  835.     {
  836.       YYERROK;
  837.       yyerror("Error in procedure's body");
  838.     }
  839.   | TOK_PROCEDURE error ';'
  840.     {
  841.       YYERROK;
  842.       yyerror("Error in procedure's title");
  843.     }
  844.   | error ';'
  845.     {
  846.       YYERROK;
  847.       yyerror("Error: unexpected ';' found before procedure title");
  848.     }
  849.   ;
  851. orderby
  852.   : { $<node>$ = TNULL;}
  853.   | TOK_ORDER TOK_BY orderspec_list
  854.     { $<node>$ = gen_up_node (ORDER, $<node>3, @1); }
  855.   ;
  857. orderspec_list
  858.   : orderspec                     { $<node>$=$<node>1;}
  859.   | orderspec_list ',' orderspec  { $<node>$=join_list($<node>1,$<node>3);}
  860.   ;
  862. orderspec
  863.   : sort_obj sort_order
  864.     {
  865.       if($<code>2)SetF_TRN($<node>1,DESC_F);
  866.       $<node>$=$<node>1;
  867.     }
  868.   ;
  870. sort_obj
  871.   : TOK_INTEGER_CONST
  872.     { register TXTREF n=gen_object(SORT_POS,@1);
  873.       SORT_IND(n)= atol(STRING(CNST_NAME($<node>1))) - 1;
  874.       free_node($<node>1);
  875.       $<node>$=n;
  876.     }
  877.   | column
  878.     {
  879.       register TXTREF s=gen_node(SORT_COL);
  880.       SORT_CLM(s)=$<node>1;
  881.       $<node>$=s;
  882.     }
  883.   ;
  885. sort_order
  886.   :          { $<code>$=0; }
  887.   | TOK_ASC  { $<code>$=0; }
  888.   | TOK_DESC { $<code>$=1; }
  889.   ;
  892. parameter_list
  893.   : parameter                    { $<node>$=$<node>1;              }
  894.   | parameter_list ',' parameter { $<node>$=join_list($<node>1,$<node>3);}
  895.   ;
  897. parameter
  898.   : TOK_IDENTIFIER type
  899.    {
  900.      register TXTREF n;
  901.      n=get_param($<ltrp>1,0,@1);
  902.      if(!n)
  903.        yyfatal("can`t add parameter");
  904.      if(TstF_TRN(n,CHECKED_F))
  905.        $<node>$ = TNULL;
  906.      else
  907.        {
  908.          PAR_STYPE(n)=$<type>2;
  909.          SetF_TRN(n,CHECKED_F);
  910.          n=copy_trn(n);
  911.          RIGHT_TRN(n)=0;
  912.          ClrF_TRN(n,VCB_F);
  913.          $<node>$=n;
  914.        }
  915.    }
  916.   | TOK_SQLCODE
  917.    {
  918.      register TXTREF n;
  919.      n=get_param(ltr_rec("SQLCODEP"),0,@1);
  920.      if(!n)
  921.        yyfatal("can`t add parameter");
  922.      if(TstF_TRN(n,CHECKED_F))
  923.        $<node>$ = TNULL;
  924.      else
  925.        {
  926.          PAR_STYPE(n)=pack_type(SQLType_Int,0,0);
  927.          SetF_TRN(n,CHECKED_F);
  928.          SetF_TRN(n,OUT_F);
  929.          n=copy_trn(n);
  930.          RIGHT_TRN(n)=0;
  931.          ClrF_TRN(n,VCB_F);
  932.          $<node>$=n;
  933.        }
  934.    }
  935.   ;
  938. /*
  939.   statements
  940. */
  942. statement
  943.   : statement_body
  944.     {
  945.       register TXTREF u=$<node>1;
  946.       if(subquery)
  947.         fprintf(stderr,
  948.                 "Internal warning parse.y: Subquery flag not processedn");
  949.       subquery=0;
  950.       if (u != FICTIVE_NODE)
  951.         {
  952.           if (u)
  953.             {
  954.               STMT_VCB(u)=LOCAL_VCB_ROOT;
  955.               add_statement(u);
  956.               emit_call(LOCAL_VCB_ROOT,STMT_UID(u),0);
  957.               del_local_vcb=0;
  958.             }
  959.           else
  960.             {
  961.               $<node>$ = TNULL;
  962.               /* dummy operator */
  963.             }
  964.         }
  965.       $<node>$=$<node>1;
  966.     }
  967.   ;
  969. statement_body
  970.   : close_stmt
  971.   | commit_stmt
  972.   | delete_stmt
  973.   | fetch_stmt
  974.   | insert_stmt
  975.   | open_stmt
  976.   | roll_stmt
  977.   | select_stmt
  978.   | update_stmt
  979.   ;
  981. close_stmt
  982.   : TOK_CLOSE cursor_name
  983.     {
  984.       if(!$<node>2)
  985.         $<node>$ = TNULL;
  986.       else
  987.         {
  988.           emit_call (TNULL, STMT_UID(CUR_DECL($<node>2)), 2);
  989.           $<node>$=FICTIVE_NODE;
  990.           del_local_vcb=1;
  991.         }
  992.     }
  993.   ;
  995. commit_stmt
  996.   : TOK_COMMIT TOK_WORK
  997.     {
  998.       dyn_sql_section_id = -2; /* !! */
  999.       del_local_vcb=1;
  1000.       emit_call (TNULL,dyn_sql_section_id,2);
  1001.       $<node>$=FICTIVE_NODE;
  1002.     }
  1003.   ;
  1005. delete_stmt
  1006.   : TOK_DELETE TOK_FROM host_scan where_d
  1007.     {
  1008.       register TXTREF u=$<node>3;
  1009.       u=gen_up_node(DELETE,u,@1);
  1010.       add_child(u,$<node>4);
  1011.       $<node>$=u;
  1012.     }
  1013.   | TOK_DELETE                    where_cur
  1014.     {
  1015.       $<node>$ = TNULL;
  1016.       if($<node>2)
  1017.         {
  1018.           register TXTREF c,d;
  1019.           c = $<node>2;
  1020.           emit_call(LOCAL_VCB_ROOT,STMT_UID(CUR_DECL(c)),3);
  1021.           d = gen_up_node (DELETE, TNULL, @1);
  1022.           UPD_CURS(d) = c;
  1023.           STMT_VCB(d) = LOCAL_VCB_ROOT;
  1024.           LOCAL_VCB_ROOT = TNULL;
  1025.           add_statement(d);
  1026.           $<node>$ = FICTIVE_NODE;
  1027.         }
  1028.       else
  1029.         {
  1030.           free_tree($<node>2);
  1031.           FREE_VCB;
  1032.         }
  1033.     }
  1034.   | TOK_DELETE TOK_FROM host_scan where_cur
  1035.     {
  1036.       $<node>$ = TNULL;
  1037.       if($<node>4)
  1038.         {
  1039.           register TXTREF c,d;
  1040.           c = $<node>4;
  1041.           emit_call(LOCAL_VCB_ROOT,STMT_UID(CUR_DECL(c)),3);
  1042.           d = gen_up_node (DELETE, $<node>3, @1);
  1043.           UPD_CURS(d) = c;
  1044.           STMT_VCB(d) = LOCAL_VCB_ROOT;
  1045.           LOCAL_VCB_ROOT = TNULL;
  1046.           add_statement(d);
  1047.           $<node>$ = FICTIVE_NODE;
  1048.         }
  1049.       else
  1050.         {
  1051.           free_tree($<node>3);
  1052.           FREE_VCB;
  1053.         }
  1054.     }
  1055.   ;
  1057. fetch_stmt
  1058.   : TOK_FETCH cursor_name TOK_INTO target_list /* cursor */
  1059.     {
  1060.       $<node>$ = TNULL;
  1061.       if($<node>2)
  1062.         {
  1063.           register TXTREF u;
  1064.           $<node>$=FICTIVE_NODE;
  1065.           u=gen_object(FETCH,@1);
  1066.           STMT_VCB(u)=LOCAL_VCB_ROOT;
  1067.           SetF_TRN(u,HAS_VCB_F);
  1068.           STMT_UID(u) = ARITY_TRN(CUR_DECL($<node>2));
  1069.           add_child(CUR_DECL($<node>2),u);
  1070.           emit_call(LOCAL_VCB_ROOT,STMT_UID(CUR_DECL($<node>2)),1);
  1071.           LOCAL_VCB_ROOT = TNULL;
  1072.         }
  1073.       free_line($<node>4);
  1074.       if ($<node>$ == TNULL)
  1075.         {
  1076.           FREE_VCB;
  1077.         }
  1078.     }
  1079.    ;
  1081. insert_stmt
  1082.   : TOK_INSERT TOK_INTO host_scan opt_column_name_list insrt_tail
  1083.      {
  1084.        register TXTREF i;
  1085.        i=gen_object(INSERT,@1);
  1086.        add_child(i,$<node>3);
  1087.        if($<node>4)
  1088.          {
  1089.            add_child(i,gen_parent(INTO,$<node>4));
  1090.            SetF_TRN(i,COLUMNS_F);
  1091.          }
  1092.        add_child(i,$<node>5);
  1093.        if(CODE_TRN($<node>5)==QUERY)SetF_TRN(i,QUERY_F);
  1094.        $<node>$=i;
  1095.      }
  1096.   ;
  1098. insrt_tail
  1099.   : TOK_VALUES '(' insertvalue_list ')'
  1100.     { $<node>$=gen_up_node(IVALUES,$<node>3,@1); }
  1101.   | queryspec
  1102.     { $<node>$=$<node>1;}
  1103.   ;
  1105. insertvalue_list
  1106.   : ins_value                       { $<node>$=$<node>1;}
  1107.   | insertvalue_list ',' ins_value  { $<node>$=join_list($<node>1,$<node>3);}
  1108.   ;
  1110. ins_value
  1111.   : expr_or_null   { $<node>$=$<node>1;  }
  1112.   ;
  1114. open_stmt
  1115.   : TOK_OPEN cursor_name
  1116.     {
  1117.      if(!$<node>2)
  1118.        $<node>$ = TNULL;
  1119.      else
  1120.        {
  1121.          register TXTREF u=$<node>2,v;
  1122.          register TXTREF vcb=LOCAL_VCB_ROOT;
  1123.          u=STMT_VCB (DOWN_TRN (CUR_DECL(u)));
  1124.          LOCAL_VCB_ROOT=u;
  1125.          for(v=vcb;v;v=RIGHT_TRN(v))
  1126.            if(CODE_TRN(v)==PARAMETER)
  1127.              {
  1128.                u=find_info(PARAMETER,PAR_NAME(v));
  1129.                if(!u)
  1130.                  continue;
  1131.                if(PAR_STYPE(u).code==0)
  1132.                  PAR_STYPE(u)=PAR_STYPE(v);
  1133.                else if (PAR_STYPE(u).code!=PAR_STYPE(v).code)
  1134.                  yyerror("Error: Mismath operand types");
  1135.              }
  1136.          emit_call(LOCAL_VCB_ROOT,STMT_UID(CUR_DECL($<node>2)),0);
  1137.          LOCAL_VCB_ROOT=vcb;
  1138.          $<node>$=FICTIVE_NODE;
  1139.          del_local_vcb=1;
  1140.        }
  1141.    }
  1142.   ;
  1144. roll_stmt
  1145.   : TOK_ROLLBACK TOK_WORK
  1146.     {
  1147.      $<node>$=FICTIVE_NODE;
  1148.      dyn_sql_section_id = -1; /* !! */
  1149.      emit_call (TNULL,dyn_sql_section_id,0);
  1150.      del_local_vcb=1;
  1151.     }
  1152.   ;
  1154. select_stmt
  1155.   : TOK_SELECT select_spec selection TOK_INTO target_list tableexpr
  1156.     {
  1157.       register TXTREF S=gen_object(SELECT,@1),s=$<node>3,t;
  1158.       t=gen_up_node(INTO,$<node>5,@4);
  1159.       MASK_TRN(S)  = MASK_TRN($<node>6);
  1160.       DOWN_TRN(S)  = DOWN_TRN($<node>6);
  1161.       ARITY_TRN(S) = ARITY_TRN($<node>6);
  1162.       free_node($<node>6);
  1163.       if($<code>2)SetF_TRN(S,DISTINCT_F);
  1164.       RIGHT_TRN(t)=RIGHT_TRN(DOWN_TRN(S));      /* insert after from */
  1165.       RIGHT_TRN(s)=t;
  1166.       RIGHT_TRN(DOWN_TRN(S))=s;
  1167.       ARITY_TRN(S)+=2;
  1168.       $<node>$=S;
  1169.     }
  1170.   ;
  1172. select_spec
  1173.   : all              { $<code>$=0;}
  1174.   | TOK_DISTINCT     { $<code>$=1;}
  1175.   ;
  1177. update_stmt
  1178.   : TOK_UPDATE host_scan TOK_SET assignment_list where_d
  1179.     {
  1180.       register TXTREF u=
  1181.        join_list(join_list($<node>2,gen_parent(ASSLIST,$<node>4)),$<node>5);
  1182.       $<node>$=gen_up_node(UPDATE,u,@1);
  1183.     }
  1184.   | TOK_UPDATE host_scan TOK_SET assignment_list where_cur
  1185.     {
  1186.       register TXTREF u = TNULL;
  1187.       if ($<node>5)
  1188.         {
  1189.           u=gen_up_node(UPDATE,join_list($<node>2,
  1190.                                          gen_parent(ASSLIST,$<node>4)),@1);
  1191.           UPD_CURS(u)=$<node>5;
  1192.           SetF_TRN($<node>5,CURS_UPD_F);
  1193.         }
  1194.       $<node>$=u;
  1195.     }
  1196.   ;
  1198. assignment_list
  1199.   : assignment                      { $<node>$=$<node>1;}
  1200.   | assignment_list ',' assignment  { $<node>$=join_list($<node>1,$<node>3);}
  1201.   ;
  1203. assignment
  1204.   : TOK_IDENTIFIER '=' assign_tail /* column - IDENTIFIER */
  1205.     {
  1206.       $<node>$=gen_up_node(ASSIGN,
  1207.                   join_list(gen_column(NULL,$<ltrp>1,@1),$<node>3),
  1208.                            @2);
  1209.     }
  1210.   ;
  1212. assign_tail
  1213.   : expr_or_null   { $<node>$=$<node>1;  }
  1214.   ;
  1216. expr_or_null
  1217.   : expr       { $<node>$=$<node>1;  }
  1218.   | TOK_NULL   { $<node>$=gen_object(NULL_VL,@1);  }
  1219.   ;
  1221. /*
  1222.   query expression
  1223. */
  1225. queryexpr
  1226.   : queryterm
  1227.     { $<node>$=$<node>1; }
  1228.   | queryexpr TOK_UNION all queryterm
  1229.     {
  1230.       register TXTREF n=$<node>1;
  1231.       if ( (CODE_TRN(n)==UNION) && (($<code>3==0) || TstF_TRN(n,ALL_F) ))
  1232.         {
  1233.           add_child(n,$<node>4);
  1234.           if($<code>3==0)
  1235.             ClrF_TRN(n,ALL_F);
  1236.         }
  1237.       else
  1238.         {
  1239.           n=gen_up_node(UNION,join_list($<node>1,$<node>4),@2);
  1240.           if($<code>3 > 0)
  1241.             SetF_TRN(n,ALL_F);
  1242.         }
  1243.       $<node>$=n;
  1244.     }
  1245.   ;
  1247. queryterm
  1248.   : queryspec           { $<node>$=$<node>1; }
  1249.   | '(' queryexpr ')'   { $<node>$=$<node>2; }
  1250.   ;
  1252. queryspec
  1253.   : '(' queryspec1 ')'  { $<node>$=$<node>2; }
  1254.   ;
  1256. queryspec1
  1257.   : TOK_SELECT select_spec selection tableexpr 
  1258.     {
  1259.       register TXTREF q=$<node>4,s=$<node>3;
  1260.       set_location(q,@1);
  1261.       CODE_TRN(q)=QUERY;
  1262.       if($<code>2)SetF_TRN(q,DISTINCT_F);
  1263.       RIGHT_TRN(s)=RIGHT_TRN(DOWN_TRN(q));     /* insert after from */
  1264.       RIGHT_TRN(DOWN_TRN(q))=s;
  1265.       ARITY_TRN(q)++;
  1266.       $<node>$=q;
  1267.     }
  1268.   ;
  1270. selection
  1271.   : expr_list
  1272.     {
  1273.       $<node>$=gen_parent(SELECTION,$<node>1);
  1274.     }
  1275.   | '*'
  1276.     {
  1277.       $<node>$=gen_parent(SELECTION,gen_object(STAR,@1));
  1278.     }
  1279.   ;
  1281. expr_list
  1282.   : expr                      { $<node>$=$<node>1;}
  1283.   | expr_list ',' expr        { $<node>$=join_list($<node>1,$<node>3);}
  1284.   ;
  1286. tableexpr
  1287.   : from where_d groupby having
  1288.     {
  1289.       register TXTREF tbl;
  1290.       tbl=gen_parent(TBLEXP,join_list(
  1291.                               join_list(
  1292.                                 join_list($<node>1,$<node>2),
  1293.                                 $<node>3),
  1294.                               $<node>4));
  1295.       if($<node>2)SetF_TRN(tbl,WHERE_F);
  1296.       if($<node>3)SetF_TRN(tbl,GROUP_F);
  1297.       if($<node>4)SetF_TRN(tbl,HAVING_F);
  1298.       if(subquery)SetF_TRN(tbl,SUBQUERY_F);
  1299.       subquery=0;
  1300.       $<node>$=tbl;
  1301.     }
  1302.   ;
  1304. from
  1305.   : TOK_FROM scan_list
  1306.     {
  1307.       $<node>$=gen_up_node(FROM,$<node>2,@1);
  1308.     }
  1309.   ;
  1311. scan_list
  1312.   : scan_desc                 { $<node>$=$<node>1;}
  1313.   | scan_list ',' scan_desc   { $<node>$=join_list($<node>1,$<node>3);}
  1314.   ;
  1316. scan_desc
  1317.   : table_desc TOK_IDENTIFIER /* IDENTIFIER -- scan name */
  1318.     {
  1319.       $<node>$ = gen_scanptr ($<node>1, $<ltrp>2, @2);
  1320.     }
  1321.   | table_desc
  1322.     {
  1323.       $<node>$ = gen_scanptr ($<node>1, (LTRLREF) NULL, tblnm.p);
  1324.     }
  1325.   ;
  1327. where_d
  1328.   :        { $<node>$ = TNULL;    }
  1329.   | where  { $<node>$ = $<node>1;}
  1330.   ;
  1332. where
  1333.   : TOK_WHERE cond
  1334.     {
  1335.       $<node>$=gen_up_node(WHERE,$<node>2,@1);
  1336.     }
  1337.   ;
  1339. where_cur        /* return pointer to cursor */
  1340.   : TOK_WHERE TOK_CURRENT TOK_OF cursor_name   { $<node>$=$<node>4; }
  1341.   ;
  1343. cursor_name
  1344.   : TOK_IDENTIFIER
  1345.     {
  1346.       register TXTREF cursor=find_info(CURSOR,$<ltrp>1);
  1347.       if(!cursor)
  1348.         lperror("Cursor name '%s' not  found ",STRING($<ltrp>1));
  1349.       $<node>$=cursor;
  1350.     }
  1351.   ;
  1353. groupby
  1354.   : { $<node>$ = TNULL;    }
  1355.   | TOK_GROUP TOK_BY column_list
  1356.     {
  1357.       $<node>$ = gen_up_node (GROUP, $<node>3, @1);
  1358.     }
  1359.   ;
  1361. having
  1362.   : { $<node>$ = TNULL;    }
  1363.   | TOK_HAVING cond
  1364.     {
  1365.       $<node>$ = gen_up_node (HAVING, $<node>2, @1);
  1366.     }
  1367.   ;
  1369. /*
  1370.   search condition
  1371. */
  1373. cond
  1374.   : pred
  1375.     { $<node>$=$<node>1; }
  1376.   | '(' cond ')'  %prec BRACETS
  1377.     { $<node>$=$<node>2; }
  1378.   | cond TOK_OR cond  %prec TOK_OR
  1379.     { $<node>$=gen_oper(OR,$<node>1,$<node>3,@2); }
  1380.   | cond TOK_AND cond %prec TOK_AND
  1381.     { $<node>$=gen_oper(AND,$<node>1,$<node>3,@2); }
  1382.   | TOK_NOT cond  %prec TOK_NOT
  1383.     {
  1384.       TXTREF n=gen_node(NOT);
  1385.       set_location(n,@1);
  1386.       FUNC_OBJ(n)=$<node>2;
  1387.       ARITY_TRN(n)=1;
  1388.       $<node>$=n;
  1389.     }
  1390.   | error TOK_OR
  1391.     {
  1392.       $<node>$=TNULL;
  1393.       YYERROK;
  1394.       yyerror("error in condition");
  1395.     }
  1396.   | error TOK_AND
  1397.     {
  1398.       $<node>$=TNULL;
  1399.       YYERROK;
  1400.       yyerror("error in condition");
  1401.     }
  1402.   | '(' error ')' 
  1403.     {
  1404.       $<node>$=TNULL;
  1405.       YYERROK;
  1406.       yyerror("error in condition");
  1407.     }
  1408.   ;
  1410. pred
  1411.   : TOK_EXISTS subquery                             /* existence */ 
  1412.     {
  1413.       $<node>$=gen_up_node(EXISTS,$<node>2,@1);
  1414.     }
  1415.   | column TOK_IS not TOK_NULL   /* column !!!*/   /* null       */ 
  1416.     {
  1417.       $<node>$=gen_up_node(($<code>3?ISNOTNULL:ISNULL),
  1418.                            coltar_column($<node>1),@2);
  1419.     }
  1420.   | expr not TOK_BETWEEN expr TOK_AND expr         /* between */ 
  1421.     {
  1422.       register TXTREF b;
  1423.       b=gen_up_node(BETWEEN,join_list(join_list($<node>1,$<node>4),
  1424.                                       $<node>6),@3);
  1425.       if ($<code>2)
  1426.         b=gen_parent(NOT,b);
  1427.       $<node>$=b;
  1428.     }
  1429.   | expr not TOK_LIKE atom esc                   /* like */ 
  1430.     {
  1431.       register TXTREF l;
  1432.       l=gen_up_node(LIKE,join_list(join_list(coltar_column($<node>1),
  1433.                                              $<node>4),$<node>5),@3);
  1434.       if ( $<code>2)
  1435.         l = gen_parent(NOT,l);
  1436.       $<node>$=l;
  1437.     }
  1438.   | expr not TOK_IN inin                           /* in  */ 
  1439.     {
  1440.       register TXTREF i;
  1441.       i = gen_up_node(IN,join_list($<node>1,$<node>4),@3);
  1442.       if ( $<code>2)
  1443.         i = gen_parent(NOT,i);
  1444.       $<node>$=i;
  1445.     }
  1446.   | expr comp_op compare_to                        /* compare   */
  1447.     {
  1448.       TXTREF c = $<node>3;
  1449.       if (CODE_TRN(c) == NE)  /* quantified subquery */
  1450.         {
  1451.           CODE_TRN(c) = $<code>2;
  1452.           DOWN_TRN(c) = join_list($<node>1,DOWN_TRN(c));
  1453.           $<node>$ = c;
  1454.         }
  1455.       else
  1456.         $<node>$=gen_up_node($<code>2,join_list($<node>1,c),@2);
  1457.     }
  1458.   ;
  1460. compare_to
  1461.   : expr      { $<node>$=$<node>1; }
  1462.   | subquery  { $<node>$=$<node>1; }
  1463.   | allany subquery
  1464.     {
  1465.       register TXTREF c = $<node>2;
  1466.       c=gen_parent(NE,c);
  1467.       SetF_TRN(c,QUANTIF_F);
  1468.       if($<code>1==2) SetF_TRN(c,SOME_F);
  1469.       $<node>$=c;
  1470.     }
  1471.   ;
  1473. comp_op
  1474.   : '='         { $<code>$=EQU; }
  1475.   | TOK_NE      { $<code>$=NE;  }
  1476.   | '<'         { $<code>$=LT;  }
  1477.   | '>'         { $<code>$=GT;  }
  1478.   | TOK_LE      { $<code>$=LE;  }
  1479.   | TOK_GE      { $<code>$=GE;  }
  1480.   ;
  1482. allany
  1483.   : TOK_ALL       { $<code>$=1; }
  1484.   | TOK_ANY       { $<code>$=2; }
  1485.   | TOK_SOME      { $<code>$=2; }
  1486.   ;
  1488. not
  1489.   :             { $<code>$=0; }
  1490.   | TOK_NOT     { $<code>$=1; }
  1491.   ;
  1493. esc
  1494.   :                 { $<node>$ = TNULL; }
  1495.   | TOK_ESCAPE atom { $<node>$ = $<node>2; }
  1496.   ;
  1498. inin
  1499.   : subquery
  1500.     { $<node>$=$<node>1;}
  1501.   | '(' atom_list ')'
  1502.     { $<node>$=gen_parent(VALUES,$<node>2); }
  1503.   | '(' error ')'
  1504.     {
  1505.       $<node>$=TNULL;
  1506.       YYERROK;
  1507.       yyerror("error in IN predicate list" );
  1508.     }
  1509.   ;
  1511. atom_list
  1512.   : atom                      { $<node>$=$<node>1;}
  1513.   | atom_list ',' atom        { $<node>$=join_list($<node>1,$<node>3);}
  1514.   ;
  1516. subquery
  1517.   : '(' TOK_SELECT select_spec result_spec tableexpr ')'
  1518.     {
  1519.       register TXTREF sq=$<node>5,s=$<node>4;
  1520.       set_location(sq,@1);
  1521.       CODE_TRN(sq)=SUBQUERY;
  1522.       if($<code>3)SetF_TRN(sq,DISTINCT_F);
  1523.       RIGHT_TRN(s)=RIGHT_TRN(DOWN_TRN(sq));     /* insert after from */
  1524.       RIGHT_TRN(DOWN_TRN(sq))=s;
  1525.       ARITY_TRN(sq)++;
  1526.       subquery=1;
  1527.       $<node>$=sq;
  1528.     }
  1529.   | '(' TOK_SELECT error ')'
  1530.    { 
  1531.      yyerror("Error in subquery: skipped to ')'");
  1532.      $<node>$ = TNULL; 
  1533.    }  
  1534.   ;
  1536. result_spec
  1537.   : expr
  1538.     {
  1539.       $<node>$=gen_parent(RESULT,$<node>1);
  1540.     }
  1541.   | '*'
  1542.     {
  1543.       $<node>$=gen_parent(RESULT,gen_object(STAR,@1));
  1544.     }
  1545.   ;
  1547. all
  1548.   :            { $<code>$=0; }
  1549.   |TOK_ALL     { $<code>$=1; }
  1550.   ;
  1552. /*
  1553.   expression
  1554. */
  1556. expr
  1557.   : prim          { $<node>$=$<node>1; }
  1558.   | '(' expr ')'  { $<node>$=$<node>2; }
  1559.   | expr '+' expr { $<node>$=gen_oper(ADD,$<node>1,$<node>3,@2); }
  1560.   | expr '-' expr { $<node>$=gen_oper(SUB,$<node>1,$<node>3,@2); }
  1561.   | expr '*' expr { $<node>$=gen_oper(MULT,$<node>1,$<node>3,@2); }
  1562.   | expr '/' expr { $<node>$=gen_oper(DIV,$<node>1,$<node>3,@2); }
  1563.   | sign expr    %prec UNARY
  1564.     {
  1565.       TXTREF n=$<node>1;
  1566.       if(!n)
  1567.         $<node>$=$<node>2;
  1568.       else
  1569.         if(CODE_TRN($<node>2)==UMINUS)
  1570.           {
  1571.             $<node>$=FUNC_OBJ($<node>2);
  1572.             free_node($<node>2);     /* double minus elimination */
  1573.             free_node($<node>1);
  1574.           }
  1575.         else
  1576.           {
  1577.             FUNC_OBJ(n)=$<node>2;
  1578.             ARITY_TRN(n)=1;
  1579.             $<node>$=n;
  1580.           }
  1581.     }
  1582.   ;
  1584. sign
  1585.   : '+' {   $<node>$ = TNULL;           }
  1586.   | '-' {   $<node>$ = gen_object (UMINUS, @1); }
  1587.   ;
  1589. prim
  1590.   : coltar         { $<node>$=$<node>1; }
  1591.   | constant       { $<node>$=$<node>1; }
  1592.   | funcref        { $<node>$=$<node>1; }
  1593.   | TOK_USER
  1594.     {  $<node>$=gen_object(USERNAME,@1); }
  1595.   ;
  1597. atom
  1598.   : target1        { $<node>$=$<node>1; }
  1599.   | constant       { $<node>$=$<node>1; }
  1600.   | sign constant  %prec UNARY
  1601.     {
  1602.       TXTREF n = $<node>1;
  1603.       if ( ! n )
  1604.         $<node>$ = $<node>2;
  1605.       else
  1606.         {
  1607.           char *s;
  1608.           i4_t  l;
  1609.           free_node (n);
  1610.           $<node>$ = n = $<node>2;
  1611.           l = strlen (STRING (CNST_NAME (n))) + 2;
  1612.           s = xmalloc (l);
  1613.           strcpy (s, "-");
  1614.           strcat (s, STRING(CNST_NAME(n)));
  1615.           CNST_NAME (n) = ltr_rec (s);
  1616.           xfree (s);
  1617.         }
  1618.     }
  1619.   | TOK_USER
  1620.     {  $<node>$ = gen_object(USERNAME,@1); }
  1621.   ;
  1623. funcref
  1624.   : TOK_COUNT '(' '*' ')'
  1625.     {
  1626.       $<node>$=gen_func(COUNT,@1, TNULL,0);
  1627.     }
  1628.   | TOK_COUNT '(' TOK_DISTINCT column ')'
  1629.     {
  1630.       $<node>$=gen_func(COUNT,@1,$<node>4,1);
  1631.     }
  1632.   | fname '(' TOK_DISTINCT column ')'
  1633.     {
  1634.       $<node>$=gen_func($<code>1,@1,$<node>4,1);
  1635.     }
  1636.   | fname '(' all expr ')'
  1637.     {
  1638.       $<node>$=gen_func($<code>1,@1,$<node>4,0);
  1639.     }
  1640.   ;
  1642. fname
  1643.   : TOK_AVG { $<code>$=AVG; }
  1644.   | TOK_MAX { $<code>$=MAX; }
  1645.   | TOK_MIN { $<code>$=MIN; }
  1646.   | TOK_SUM { $<code>$=SUM; }
  1647.   ;
  1649. constant
  1650.   : TOK_INTEGER_CONST { $<node>$=$<node>1; }
  1651.   | TOK_REAL_CONST    { $<node>$=$<node>1; }
  1652.   | TOK_NUM_CONST     { $<node>$=$<node>1; }
  1653.   | TOK_STRING_CONST  { $<node>$=$<node>1; }
  1654.   ;
  1656. type
  1657.   : TOK_T_CHAR
  1658.      { $<type>$=pack_type(SQLType_Char,1,0);                        }
  1659.   | TOK_T_SINT
  1660.      { $<type>$=pack_type(SQLType_Short,5,0);                       }
  1661.   | TOK_T_INT
  1662.      { $<type>$=pack_type(SQLType_Int,10,0);                        }
  1663.   | TOK_T_REAL
  1664.      { $<type>$=pack_type(SQLType_Real,0,0);                        }
  1665.   | TOK_T_DOUBLE
  1666.      { $<type>$=pack_type(SQLType_Double,0,0);                      }
  1667.   | TOK_T_DOUBLE TOK_T_PRECISION
  1668.      { $<type>$=pack_type(SQLType_Double,0,0);                      }
  1669.   | TOK_T_FLT  '(' TOK_INTEGER_CONST ')'
  1670.      { $<type>$=pack_type(SQLType_Float,atol(STRING(CNST_NAME($<node>3))),0);  }
  1671.   | TOK_T_FLT  
  1672.      { $<type>$=pack_type(SQLType_Real,0,0);  }
  1673.   | TOK_T_CHAR '(' TOK_INTEGER_CONST ')'
  1674.      { $<type>$=pack_type(SQLType_Char,atol(STRING(CNST_NAME($<node>3))),0);   }
  1675.   | TOK_T_NUM 
  1676.      { $<type>$=pack_type(SQLType_Int,0,0);    }
  1677.   | TOK_T_NUM '(' TOK_INTEGER_CONST ')'
  1678.      { $<type>$=pack_type(SQLType_Num,atol(STRING(CNST_NAME($<node>3))),0);    }
  1679.   | TOK_T_NUM '(' TOK_INTEGER_CONST ',' TOK_INTEGER_CONST ')'
  1680.      { $<type>$=pack_type(SQLType_Num,atol(STRING(CNST_NAME($<node>3))),
  1681.                            atol(STRING(CNST_NAME($<node>5))));
  1682.      }
  1683.   ;
  1685. table_def:  tablename
  1686.      {
  1687.        TXTREF n;
  1688.        if(!tblnm.a)
  1689.          tblnm.a=GL_AUTHOR;
  1690.        n = find_table (ANY_TBL, tblnm.a, tblnm.n);
  1691.        if (n)
  1692.          {
  1693.            yyerror ("Error: Duplicate table name definitionn");
  1694.            $<node>$ = TNULL;
  1695.          }
  1696.        else
  1697.          {
  1698.            n = gen_node (ANY_TBL);
  1699.            /* SetF_TRN(n,CHECKED_F); */
  1700.            /* table hasn't  not already defined yet */
  1701.            TBL_FNAME (n) = tblnm.a;
  1702.            TBL_NAME (n) = tblnm.n;
  1703.            add_info (n);
  1704.            $<node>$ = new_table = n;
  1705.    new_table_col_no = 0;
  1706.          }
  1707.      }
  1708.   ;
  1710. table_desc: tablename
  1711.      {
  1712.        TXTREF n;
  1713.        if (!tblnm.a)
  1714.          tblnm.a=GL_AUTHOR;
  1715.        n = find_table (ANY_TBL, tblnm.a, tblnm.n);
  1716.        if (!n)
  1717.          {
  1718.            n = gen_node (ANY_TBL);
  1719.            TBL_FNAME (n) = tblnm.a;
  1720.            TBL_NAME (n) = tblnm.n;
  1721.            add_info (n);
  1722.          }
  1723.        $<node>$ = n;
  1724.      }
  1725.   ;
  1727. host_scan:  table_desc
  1728.      {
  1729.        $<node>$ = gen_scanptr ($<node>1, (LTRLREF) NULL, tblnm.p);
  1730.      }
  1731.   ;
  1733. tablename      /*++*/
  1734.   : TOK_IDENTIFIER
  1735.     { /*  user_identifier.tablename  or correlation name */
  1736.       tblnm.a  = (LTRLREF) NULL;
  1737.       tblnm.n  = $<ltrp>1;
  1738.       tblnm.p  = @1;
  1739.       $<code>$ = 0;
  1740.     }
  1741.   | TOK_IDENTIFIER '.' TOK_IDENTIFIER
  1742.     { /* authorization.tablename */
  1743.       tblnm.a  = $<ltrp>1;
  1744.       tblnm.n  = $<ltrp>3;
  1745.       tblnm.p  = @1;
  1746.       $<code>$ = 0;
  1747.     }
  1748.   ;
  1750. column_list
  1751.   : column                    { $<node>$ = $<node>1;                     }
  1752.   | column_list ',' column    { $<node>$ = join_list($<node>1,$<node>3); }
  1753.   ;
  1755. column
  1756.   : TOK_IDENTIFIER
  1757.     {  $<node>$=gen_column(NULL,$<ltrp>1,@1);  }
  1758.   | TOK_IDENTIFIER  '.' TOK_IDENTIFIER
  1759.     { /*  user_identifier.tablename  or correlation name */
  1760.       tblnm.a  = (LTRLREF) NULL;
  1761.       tblnm.n  = $<ltrp>1;
  1762.       tblnm.p  = @1;
  1763.       $<node>$ = gen_column (&tblnm, $<ltrp>3, @3);
  1764.     }
  1765.   | TOK_IDENTIFIER '.' TOK_IDENTIFIER  '.' TOK_IDENTIFIER
  1766.     { /* authorization.tablename */
  1767.       tblnm.a  = $<ltrp>1;
  1768.       tblnm.n  = $<ltrp>3;
  1769.       tblnm.p  = @1;
  1770.       $<node>$ = gen_column (&tblnm, $<ltrp>5, @5);
  1771.     }
  1772.   ;
  1774. target_list
  1775.   : target                  { $<node>$=$<node>1;                     }
  1776.   | target_list ',' target  { $<node>$=join_list($<node>1,$<node>3); }
  1777.   ;
  1779. target
  1780.   : target1 
  1781.     {
  1782.       register TXTREF t=OBJ_DESC($<node>1);
  1783.       SetF_TRN(t,OUT_F);
  1784.   if( !TstF_TRN(t,INDICATOR_F) && PAR_INDICATOR(t) != TNULL )
  1785.     SetF_TRN(PAR_INDICATOR(t),OUT_F);
  1786.       $<node>$=$<node>1;
  1787.     }
  1788.   ;
  1789.   
  1790. target1
  1791.   : TOK_IDENTIFIER
  1792.     {  $<node>$=get_parm_node($<ltrp>1,@1,1);  }
  1793.   | TOK_PARAM
  1794.     {  $<node>$=get_parm_node($<ltrp>1,@1,0);  }
  1795.   | TOK_IDENTIFIER TOK_INDICATOR TOK_IDENTIFIER
  1796.     {
  1797.       $<node>$=get_ind(get_param($<ltrp>1,1,@1),get_param($<ltrp>3,1,@3),@2);
  1798.     }
  1799.   | TOK_IDENTIFIER TOK_IDENTIFIER
  1800.     {
  1801.       $<node>$=get_ind(get_param($<ltrp>1,1,@1),get_param($<ltrp>2,1,@2),@2);
  1802.     }
  1803.   | TOK_PARAM TOK_INDICATOR TOK_PARAM
  1804.     {
  1805.       $<node>$=get_ind(get_param($<ltrp>1,0,@1),get_param($<ltrp>3,0,@3),@2);
  1806.     }
  1807.   | TOK_PARAM TOK_PARAM
  1808.     {
  1809.       $<node>$=get_ind(get_param($<ltrp>1,0,@1),get_param($<ltrp>2,0,@2),@2);
  1810.     }
  1811.   ;
  1813. coltar
  1814.   : TOK_IDENTIFIER
  1815.      {
  1816.        TXTREF n;
  1817.        n=find_info(PARAMETER,$<ltrp>1);
  1818.        if(n)
  1819.          $<node>$=get_parm_node($<ltrp>1,@1,1);
  1820.        else
  1821.          $<node>$=gen_column(NULL,$<ltrp>1,@1);
  1822.      }
  1823.   | TOK_IDENTIFIER  '.' TOK_IDENTIFIER
  1824.     { /*  user_identifier.tablename  or correlation name */
  1825.       tblnm.a  = (LTRLREF) NULL;
  1826.       tblnm.n  = $<ltrp>1;
  1827.       tblnm.p  = @1;
  1828.       $<node>$ = gen_column (&tblnm, $<ltrp>3, @3);
  1829.     }
  1830.   | TOK_IDENTIFIER '.' TOK_IDENTIFIER  '.' TOK_IDENTIFIER
  1831.     { /* authorization.tablename */
  1832.       tblnm.a  = $<ltrp>1;
  1833.       tblnm.n  = $<ltrp>3;
  1834.       tblnm.p  = @1;
  1835.       $<node>$ = gen_column (&tblnm, $<ltrp>5, @5);
  1836.     }
  1837.   | TOK_PARAM
  1838.      { $<node>$=get_parm_node($<ltrp>1,@1,0);     }
  1839.   | TOK_IDENTIFIER TOK_INDICATOR TOK_IDENTIFIER
  1840.      {
  1841.        $<node>$=get_ind(get_param($<ltrp>1,1,@1),get_param($<ltrp>3,1,@3),@2);
  1842.      }
  1843.   | TOK_IDENTIFIER TOK_IDENTIFIER
  1844.      {
  1845.        $<node>$=get_ind(get_param($<ltrp>1,1,@1),get_param($<ltrp>2,1,@2),@2);
  1846.      }
  1847.   | TOK_PARAM TOK_INDICATOR TOK_PARAM
  1848.      {
  1849.        $<node>$=get_ind(get_param($<ltrp>1,0,@1),get_param($<ltrp>3,0,@3),@2);
  1850.      }
  1851.   | TOK_PARAM TOK_PARAM
  1852.      {
  1853.        $<node>$=get_ind(get_param($<ltrp>1,0,@1),get_param($<ltrp>2,0,@2),@2);
  1854.      }
  1855.   ;
  1858. /* end of rules */
  1859. %%
  1861. static void
  1862. free_tail(void)
  1863. {
  1864.   if (del_local_vcb)
  1865.     FREE_VCB;
  1866.   LOCAL_VCB_ROOT = TNULL;
  1867.   del_local_vcb = 0;
  1868. }
  1871. static TXTREF holes_tbl = TNULL;
  1873. static TXTREF 
  1874. replace_clm_hole(TXTREF clmptr,i4_t f)
  1875. {
  1876.   register TXTREF ptr,clm;
  1877.   register enum token code=CODE_TRN(clmptr);
  1878.   assert(f==CYCLER_LD);
  1879.   if(code!=COLPTR)return clmptr;
  1880.   ptr=OBJ_DESC(clmptr);
  1881.   if(CODE_TRN(ptr)!=COLUMN_HOLE)return clmptr;
  1882.   clm=find_column(holes_tbl,CHOLE_CNAME(ptr));
  1883.   if(!clm)
  1884.     {
  1885.       if (TstF_TRN(holes_tbl,CHECKED_F))
  1886.         lperror("Incorrect column name '%s' used",STRING(CHOLE_CNAME(ptr)));
  1887.       else
  1888.         {
  1889.           add_column(holes_tbl,CHOLE_CNAME(ptr));
  1890.           clm=find_column(holes_tbl,CHOLE_CNAME(ptr));
  1891.         }
  1892.     }
  1893.   free_node(ptr);
  1894.   OBJ_DESC(clmptr)=clm;
  1895.   return clmptr;
  1896. }
  1898. static TXTREF 
  1899. replace_column_holes(TXTREF rb,VCBREF tbl)
  1900. {
  1901.   holes_tbl = tbl;
  1902.   rb=cycler(rb,replace_clm_hole,CYCLER_LD+CYCLER_LN);
  1903.   holes_tbl = TNULL;
  1904.   return rb;
  1905. }
  1907. static void 
  1908. add_table_column(enum token tbl_code,LTRLREF ltrp,sql_type_t type,TXTREF def,TXTREF constr)
  1909. {
  1910.   register TXTREF col;
  1911.   register i4_t    can_be_null = 1;
  1912.   
  1913.   if(!new_table) return;
  1914.   if(CODE_TRN(new_table)==ANY_TBL)
  1915.     CODE_TRN(new_table)=tbl_code;
  1916.   TASSERT(tbl_code == CODE_TRN(new_table),new_table);
  1917.   col = find_column(new_table,ltrp);
  1918.   if (col)
  1919.     {
  1920.       lperror("Duplicate column '%s' definition in table '%s.%s'",STRING(ltrp),
  1921.               STRING(TBL_FNAME(new_table)),STRING(TBL_NAME(new_table)));
  1922.       if(def)
  1923.         free_tree(def);
  1924.       if(constr)
  1925.         free_tree(constr);
  1926.     }
  1927.   else
  1928.     {
  1929.       add_column(new_table,ltrp);
  1930.       col=find_column(new_table,ltrp);
  1931.       COL_TYPE(col)   = type;
  1932.       COL_DEFAULT(col)= def;
  1933.       COL_NO(col) = new_table_col_no++;
  1934.     }
  1936.   while(constr)
  1937.     {
  1938.       register TXTREF c = constr;
  1939.       i4_t             null_vl = 0;
  1940.       constr = RIGHT_TRN(c);
  1941.       RIGHT_TRN(c) = TNULL;
  1942.       switch(CODE_TRN(c))
  1943. {
  1944. case NULL_VL:
  1945.           free_node(c);
  1946.           null_vl=1;
  1947. case PRIMARY:
  1948. case UNIQUE:
  1949.   can_be_null = 0;
  1950. #define P_(code,subtree) gen_parent(code,subtree)
  1951.           TBL_CONSTR(new_table) = 
  1952.     join_list(P_(CHECK,P_(ISNOTNULL,gen_colptr(col))),
  1953.       TBL_CONSTR(new_table));
  1954. #undef P_
  1955.           if(null_vl)
  1956.             break;
  1957. case INDEX:
  1958.   ARITY_TRN(c) = 1;
  1959.   DOWN_TRN(c)  = gen_colptr(col);
  1960.   IND_INFO(new_table)=join_list(c,IND_INFO(new_table));
  1961.   break;
  1962. case CHECK:
  1963.   TBL_CONSTR(new_table) = 
  1964.     join_list (replace_column_holes(c,new_table),
  1965.        TBL_CONSTR(new_table));
  1966.   break;
  1967. case REFERENCE:
  1968.           TBL_CONSTR(new_table)=
  1969.             join_list(gen_parent(FOREIGN,
  1970.                                  join_list(gen_parent(LOCALLIST,gen_colptr(col)),c)),
  1971.                       TBL_CONSTR(new_table));
  1972.           break;
  1973. default:
  1974.   debug_trn(c);
  1975.   yyfatal("Unexpected column constraints found");
  1976.   break;
  1977. }
  1978.     }
  1979.   
  1980.   if (!def && can_be_null)
  1981.     COL_DEFAULT (col) = gen_node (NULL_VL);
  1982.   
  1983.   if(COL_DEFAULT(col) && CODE_TRN(COL_DEFAULT(col))==NULL_VL)
  1984.     {
  1985.       if (can_be_null)
  1986.         NULL_TYPE(COL_DEFAULT (col)) = COL_TYPE(col);
  1987.       else
  1988.         yyerror("Error: ambiguous column description");
  1989.     }
  1990. #if 0
  1991.   {
  1992.     MASKTYPE x = MASK_TRN(new_table);
  1993.     debug_trn(new_table);
  1994.     MASK_TRN(new_table) = x;
  1995.   }
  1996. #endif
  1997. }
  1999. /*
  2000.  * 'check_not_null' check columns in UNIQUE or PRIMARY key definition
  2001.  * for constraints 'not null'.
  2002.  */
  2004. static void
  2005. check_not_null(TXTREF ind)
  2006. {
  2007.   TXTREF tbl = COL_TBL(OBJ_DESC(DOWN_TRN(ind)));
  2008.   TXTREF constr,cp;
  2009.   for ( cp = DOWN_TRN(ind);cp;cp = RIGHT_TRN(cp)) /* check every column */
  2010.     {
  2011.       TXTREF col = OBJ_DESC(cp);
  2012.       for(constr = TBL_CONSTR(tbl);constr;constr = RIGHT_TRN(constr))
  2013.         {
  2014.           /*
  2015.            * if ( constr = (Check (IsNotNull (ColPtr <col>))))
  2016.            */
  2017.           TXTREF pred = DOWN_TRN(constr);
  2018.           if(CODE_TRN(pred) == NOT)
  2019.             {
  2020.               pred = DOWN_TRN(pred);
  2021.               switch(CODE_TRN(pred))
  2022.                 {
  2023.                 case ISNULL:
  2024.                   CODE_TRN(pred)  = ISNOTNULL;
  2025.                   free_node(DOWN_TRN(constr));
  2026.                   DOWN_TRN(constr) = pred;
  2027.                   break;
  2028.                 default: break; 
  2029.                 }
  2030.             }
  2031.           if(CODE_TRN(pred) != ISNOTNULL)
  2032.             continue;
  2033.           pred = DOWN_TRN(pred);
  2034.           if(CODE_TRN(pred) != COLPTR) /* it quite strange */
  2035.             continue;
  2036.           if(OBJ_DESC(pred) == col) /* if there is a constraint on given column */
  2037.             break;
  2038.         }
  2039.       if (constr) /* something was found */
  2040.         continue;
  2041.       /* if we have not found 'not null' constraints on given column */
  2042.       file_pos = LOCATION_TRN(cp);
  2043.       lperror("Warning: primary key column '%s.%s.%s' not restrictedn"
  2044.               "ttby 'not null' qualifier",
  2045.               STRING(TBL_FNAME(tbl)),STRING(TBL_NAME(tbl)),
  2046.               STRING(COL_NAME(col)));
  2047.       errors--; /* clear error flag - translate message as a warning */
  2048.       if (CODE_TRN(COL_DEFAULT(col))==NULL_VL)
  2049.         {
  2050.           free_node(COL_DEFAULT(col));
  2051.           COL_DEFAULT(col) = TNULL;
  2052.         }
  2053.       col = gen_node(COLPTR);
  2054.       OBJ_DESC(col) = OBJ_DESC(cp);
  2055.       TBL_CONSTR(tbl) = 
  2056.         join_list (gen_parent(CHECK,gen_parent(ISNOTNULL,col)),
  2057.                    TBL_CONSTR(new_table));
  2058.     }
  2059. }
  2061. static void
  2062. emit_module_proc(VCBREF parmlist,LTRLREF procname)
  2063. {
  2064.   if (call.subst==NULL)
  2065.     call.subst = (call_subst_t*)xmalloc (sizeof(call_subst_t));
  2066.   call.subst->proc_name = savestring(STRING(procname));
  2067.   describe_stmt(&(call.subst->interface),parmlist,'I');
  2068.   free_tail();
  2069. }
  2071. static void
  2072. emit_call(TXTREF vcb,i4_t object_id, i4_t method_id)
  2073. {
  2074.   if (call.subst==NULL)
  2075.     call.subst = (call_subst_t*)xmalloc ( sizeof(call_subst_t));
  2076.   call.subst->object = object_id;
  2077.   call.subst->method = method_id;
  2078.   describe_stmt(&(call.subst->in_sql_parm),vcb,'>');
  2079.   describe_stmt(&(call.subst->out_sql_parm),vcb,'<');
  2080.   call.subst->jmp_on_eofscan = savestring(label_nf?label_nf:"");
  2081.   call.subst->jmp_on_error   = savestring(label_er?label_er:"");
  2082. }
  2084. call_t *
  2085. prepare_replacement(void)
  2086. {
  2087.   call_t *c;
  2088.   c = (call_t*)xmalloc ( sizeof(call_t));
  2089.   c->subst = call.subst;
  2090.   if(c->subst)  /* preserve NULL string reference */
  2091.     {
  2092.       if (!call.subst->proc_name)
  2093.         call.subst->proc_name      =  savestring("");
  2094.       if (!call.subst->jmp_on_eofscan)
  2095.         call.subst->jmp_on_eofscan =  savestring("");
  2096.       if (!call.subst->jmp_on_error)
  2097.         call.subst->jmp_on_error   =  savestring("");
  2098.     }
  2099.   return c;
  2100. }
  2102. i4_t 
  2103. sql_parse(void)
  2104. {
  2105.   i4_t rc;
  2106.   yydebug=parse_debug;
  2107.   parse_mode=Esql;
  2108.   dyn_sql_section_id = 0;
  2109.   bzero(&call,sizeof(call));
  2110.   rc = yyparse();
  2111.   dyn_sql_stmt_name = NULL;
  2112.   return rc;
  2113. }