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

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

SQL Server

开发平台：

Unix_Linux

node.c：源码内容
  1. /*
  2.  * node.c  - this module contains functions those generate C-code for
  3.  *           tree generating.
  4.  *
  5.  *  This file is a part of GNU SQL Server
  6.  *
  7.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  8.  *  Developed at the Institute of System Software
  9.  *  This file is written by Andrew Yahin.
  10.  *  Modified 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.  *  Contacts: gss@ispras.ru
  27.  *
  28.  */
  30. /* $Id: node.c,v 1.246 1997/03/31 11:03:38 kml Exp $ */
  32. #include <stdarg.h>
  33. #include <string.h>
  34. #include "kitty.h"
  36. extern FILE *yout;
  37. static void  emit_mknode_parms  __P(( TXTREF t,i4_t look_to_the_right));
  38. static i4_t   indent = 2;
  39. static char *spaces = "                                               "; 
  41. #define TYPE_INDENT fprintf(yout,"nt%s",spaces+strlen(spaces)-indent)
  43. #define is_tree(s) 
  44.         ((CODE_TRN(s)<RULE)||(CODE_TRN(s)>SKIP_CODES)||(TstF_TRN(s,PATTERN_F)))
  45. #define is_production(s) 
  46.         ((CODE_TRN(s)!=TRLcmd_REMOVE)&&(CODE_TRN(s)!=TRLcmd_CCODE)
  47.  &&(CODE_TRN(s)!=TRLcmd_SWITCH))
  49. static void
  50. strupr(char *s)
  51. {
  52.   for(;*s;s++)
  53.     if( (*s>='a') && (*s<='z'))
  54.       *s-='a'-'A';
  55.   return;
  56. }
  58. static void 
  59. type_header(TXTREF s)
  60. {
  61.   enum token tmp_code;
  62.   MASKTYPE   msk ;
  63.   char       cn[100];
  64.   
  65.   tmp_code=CODE_TRN(s);
  66.   msk = MASK_TRN(s);
  67.   if (tmp_code == UNKNOWN)
  68.     yyfatal("Unknown trn read");
  69.   if (tmp_code == NIL_CODE)
  70.     return ;
  71.   if(!TstF(msk,PATTERN_F))
  72.     {
  73.       i4_t n=OPs_IND(s);
  74.       if(n>=0)
  75. {
  76.   fprintf(yout,"Op[%d]=",n);
  77.   msk CLRVL (n+1);
  78. }
  79.     }    
  80.   MASK_TRN(s) = msk;
  81.   ClrF(msk,ACTION_F);
  82.   fputs("mk_node(",yout);
  83.   switch(tmp_code)
  84.     {
  85.     case OPERAND:
  86.       strcpy(cn,"OPERAND");
  87.       break;
  88.     default:
  89.       strcpy(cn,NAME(tmp_code));
  90.       strupr(cn);
  91.     }
  92.   fprintf(yout,"%s,%d,",cn,(u4_t)msk);
  93. } 
  95. void
  96. emit_trn_constructor(TXTREF s,i4_t look_to_the_right)
  97. {
  98.   static i4_t lrop=0;
  99.   i4_t i;
  100.   char *rl_cor_str;
  101.   if(s==0)
  102.     {
  103.       fputs("TNULL",yout);
  104.       return;
  105.     }
  107.   if(is_tree(s))
  108.     {
  109.       TYPE_INDENT;  indent+=4;
  110.       type_header(s);
  111.       emit_mknode_parms(s,look_to_the_right);
  112.       return;
  113.     }
  114.   if(TstF_TRN(s,LIST_F))
  115.     rl_cor_str="rl_corrector(1,";
  116.   else
  117.     rl_cor_str="rl_corrector(0,";
  118.   i=OPs_IND(s);
  119.   if(CODE_TRN(s)==OPERAND)
  120.     {
  121.       if(i>=0)
  122. {
  123.   register i4_t ind=0;
  124.   if(look_to_the_right)
  125.     {
  126.       TYPE_INDENT;  indent+=4;
  127.       ind++;
  128.       fputs(rl_cor_str,yout);
  129.     }
  130.   if(DOWN_TRN(s))
  131.     {
  132.       if(ind==0)
  133. { TYPE_INDENT;  indent+=4; }
  134.       ind++;
  135.       if(TstF_TRN(s,LIST_F))
  136. fputs("dl_corrector(1,",yout);
  137.       else
  138. fputs("dl_corrector(0,",yout);
  139.     }
  140.   fprintf(yout,"Op[%d]",i);
  141.   if(DOWN_TRN(s))
  142.     {
  143.       fputs(",",yout);
  144.       emit_trn_constructor(DOWN_TRN(s),1);
  145.       fputs(")",yout);
  146.     }
  147.   if(ind)
  148.     indent-=4;
  149.   if(look_to_the_right)
  150.     {
  151.       fputs(",",yout);
  152.       emit_trn_constructor(RIGHT_TRN(s),1);
  153.       fputs(")",yout);
  154.     }
  155. }
  156.       else
  157. trl_err("Unexpected operand expression",__FILE__,__LINE__,
  158. Ptree(s));
  159.       return;
  160.     }
  163.   TYPE_INDENT;  indent+=4;
  164.   if(lrop)
  165.     {
  166.       lrop=0;
  167.       fputs("Rop=",yout);
  168.     }
  169.       
  170.   if(i>=0)
  171.     fprintf(yout,"Op[%d]=",i);
  172.   if(look_to_the_right)
  173.     fputs(rl_cor_str,yout);
  174.   switch(CODE_TRN(s))
  175.     {
  176.     case TRLcmd_CCODE :
  177.       fputs(STRING(XLTR_TRN(s,0)),yout);
  178.       indent-=4;
  179.       if(look_to_the_right)
  180. {
  181.   fputs(",",yout);
  182.   emit_trn_constructor(RIGHT_TRN(s),look_to_the_right);
  183.   fputs(")",yout);
  184. }
  185.       return; 
  186.     case TRLcmd_DELETE :
  187.       fprintf(yout,"del_op(");
  188.       break;
  189.     case TRLcmd_DOWN   :
  190.       fprintf(yout,"DOWN_TRN(");
  191.       break;
  192.     case TRLcmd_SET    :
  193.       fprintf(yout,"(");
  194.       break;
  195.     case TRLcmd_RIGHT  :
  196.       fprintf(yout,"RIGHT_TRN(");
  197.       break;
  198.     case TRLcmd_COPY   :
  199.       fprintf(yout,"copy_tree(");
  200.       break;
  201.     case TRLcmd_IMAGE  :
  202.       fprintf(yout,"image(");
  203.       break;
  204.     case TRLcmd_INSERT :
  205.       fprintf(yout,"insert_node(%d,",(TstF_TRN(s,BEFORE_F))?1:0);
  206.       break;
  207.     case TRLcmd_REPLACE:
  208.       fprintf(yout,"replace_node(");
  209.       break;
  210.     case TRLcmd_REMOVE :
  211.       if(TstF_TRN(s,TREE_F))
  212. fputs("free_tree(",yout);
  213.       else
  214. fputs("free_node(",yout);
  215.       break;
  216.     case TRLcmd_SWITCH :
  217.       {
  218. TXTREF ss=DOWN_TRN(s);
  219. fputs("( ( { i4_t kitty_lcc=0;",yout);
  220. if(XTXT_TRN(s,0))
  221.   {
  222.     TYPE_INDENT;
  223.     fputs("Rop=",yout);
  224.     indent+=4;
  225.     emit_trn_constructor(XTXT_TRN(s,0),0);
  226.     fputs(";",yout);
  227.     indent-=4;
  228.   }
  229. TYPE_INDENT;
  230. fputs("while(1)",yout);
  231. indent+=2;
  232. TYPE_INDENT;
  233. fputs("{",yout);
  234. indent+=2;
  235. TYPE_INDENT;
  236. fputs("kitty_lcc=0;",yout);
  237. while (ss)
  238.   { 
  239.     if(is_production(ss))
  240.       lrop=1;
  241.     if(CODE_TRN(ss)==TRLcmd_CASE)
  242.       {
  243. TYPE_INDENT;
  244. fprintf(yout,"Rop=rule_%s(&kitty_lcc,Rop)",
  245. STRING(XLTR_TRN(ss,0)));
  246.       }
  247.     else
  248.       emit_trn_constructor(ss,0);
  249.     fprintf(yout,";");
  250.     TYPE_INDENT;
  251.     /* if(CODE_TRN(ss)==RUN_RULE) */
  252.             if(TstF_TRN(s,CYCLE_F))
  253.               fputs("if(kitty_lcc) continue;",yout);
  254.             else
  255.               fputs("if(kitty_lcc) break;",yout);
  256.     ss=RIGHT_TRN(ss);
  257.   }
  258.         if( ! TstF_TRN(s,CYCLE_F) )
  259.   fputs(
  260.              /* "yyfatal("Unrecognizable SWITCH selector");" */
  261.      /* "yyerror("Unrecognizable SWITCH selector");" */
  262.         "puts("Unrecognizable SWITCH selector")   ;"
  263.       ,yout);
  264.         fputs("break;",yout);
  265. indent-=2;
  266. TYPE_INDENT;
  267. fputs("}",yout);
  268. indent-=4;
  269. TYPE_INDENT;
  270. fputs("} ), Rop)",yout);
  271. if(look_to_the_right)
  272.   {
  273.     fputs(",",yout);
  274.     emit_trn_constructor(RIGHT_TRN(s),look_to_the_right);
  275.     fputs(")",yout);
  276.   }
  277. return;
  278.       }
  279.     case RUN_RULE:
  280.       fprintf(yout,"rule_%s(&kitty_lcc,",STRING(XLTR_TRN(s,0)));
  281.       emit_trn_constructor(XTXT_TRN(s,2),0);
  282.       fputs(")",yout);
  283.       indent-=4;
  284.       if(look_to_the_right)
  285. {
  286.   fputs(",",yout);
  287.   emit_trn_constructor(RIGHT_TRN(s),look_to_the_right);
  288.   fputs(")",yout);
  289. }
  290.       return;
  291.     default:
  292.       trl_wrn("Unexpected node here",__FILE__,__LINE__,Ptree(s));
  293.       type_header(s);
  294.     }
  295.   emit_mknode_parms(s,look_to_the_right);
  296. }
  298. #define CHECK_COMMA {if (need_comma) fputs(",",yout); else need_comma=1;}
  299. #define IS_SET(n)  TST_BIT(XLNG_TRN(t,PTRN_OP(tmp_code,(n))),PTRN_BIT((n)))
  301. static void 
  302. emit_mknode_parms( TXTREF t,i4_t look_to_the_right )
  303. {
  304.   enum token tmp_code;
  305.   char      *format_ptr;
  306.   i4_t        right_ptr=0;
  307.   i4_t        down_ptr=0;
  308.   i4_t        need_comma=0;
  309.   i4_t        i,act,shift;
  310.   
  311.   tmp_code   = CODE_TRN(t);
  312.   format_ptr = FORMAT (tmp_code);
  313.   act = TstF_TRN(t,ACTION_F);
  314.   shift = (TstF_TRN(t,PATTERN_F) ? LENGTH(tmp_code) : 0);
  315.   
  316.   for (i = 0; i < LENGTH (tmp_code); i++)
  317.     {
  318.       i4_t subst = 0;
  319.       char *transform = "SIMPLE2L";
  320.       switch(format_ptr[i]) /* step for substitution C expr for atributes */
  321. {
  322. case '0': case 'r': case 'a': case 'd': case 'V': 
  323.   break;
  324. case 'y':
  325.   transform = "type2long";
  326. default:
  327.   if (act && IS_SET (i + shift) )
  328.     {
  329.       CHECK_COMMA;
  330.       fprintf(yout,"%s(%s)",transform,STRING(XLTR_TRN(t, i)));
  331.       subst = 1;
  332.     }
  333. }
  334.       if (subst)
  335. continue;
  336.       switch (format_ptr[i])
  337. {
  338. case '0':break;
  339. case 'r':
  340.   right_ptr=1;
  341.   break;
  342. case 'a':
  343.   break;
  344. case 'd':
  345.   down_ptr=1;
  346.   break;
  348. case 'V': /* special vocabulary reference (backward link) */
  349.   break;
  350. case 't':
  351.   CHECK_COMMA;
  352.   emit_trn_constructor(XTXT_TRN(t,i),0);
  353.   break;
  354. case 'N':
  355.   CHECK_COMMA;
  356.   emit_trn_constructor(XTXT_TRN(t,i),1);
  357.   break;
  358. case 'v':
  359.   /*   emit_trn_constructor(XTXT_TRN(t, i),0);*/
  360.   CHECK_COMMA;
  361.   fputs("0",yout);
  362.   break;
  364. case 'S':
  365.   /* 'S' is an optional string: if a closeparen follows,
  366.      just store NULL for this element.  */
  368. case 's':
  369.   {
  370.     CHECK_COMMA;
  371.     if((tmp_code==OPERAND) && (TstF_TRN(t,PATTERN_F)))
  372.       fprintf(yout,"%d",XLNG_TRN(t,i));
  373.     else  if(is_tree(t))
  374.       {
  375. char *ptr=STRING(XLTR_TRN(t, i));
  376. if(ptr && *ptr)
  377.   fprintf(yout,"ltr_rec("%s")",ptr);
  378. else
  379.   fputs("TNULL",yout);
  380.       }
  381.   }
  382.   break;
  383. case 'p':
  384. case 'y':
  385. case 'i':
  386. case 'x':
  387. case 'l':
  388. case 'R':
  389.   CHECK_COMMA;
  390.   fprintf(yout,"%d",XLNG_TRN(t,i));
  391.   break;
  392. case 'f':
  393.   CHECK_COMMA;
  394.   fprintf(yout,"%g",XFLT_TRN(t, i));
  395.   break;
  396. case 'T':
  397. case 'L':
  398.   CHECK_COMMA;
  399.   if(XTXT_TRN(t,i))
  400.     {
  401.       TXTREF v = XVEC_TRN(t,i);
  402.       i4_t    l = VLEN(v),n;
  403.     
  404.       fprintf(yout,"mk_vect(%d,%d",(format_ptr[i]=='T'?1:0),l);
  405.       for(n=0;n<l;n++)
  406. {
  407.   fputs(",",yout); 
  408.   if(format_ptr[i]=='T')
  409.     emit_trn_constructor(VOP(v,n).txtp,0);
  410.   else
  411.     fprintf(yout,"%d",VOP(v,n).l);
  412. }
  413.       fputs(")",yout);
  414.     }
  415.   else
  416.     fputs("TNULL",yout);
  417.   break;
  419. default:
  420.   fprintf (stderr,
  421.    "switch format wrong in emit_mknode_parm(). format was: '%c'.n",
  422.    format_ptr[i]);
  423.   yyfatal("Abort");
  424. }
  425.     }  
  426.   /* print null attribute information */
  427.   if (shift)
  428.     for(i = LENGTH(CODE_TRN(t));
  429. i < LENGTH(CODE_TRN(t)) + PTRN_ELEM(CODE_TRN(t));
  430. i++)
  431.       {
  432. CHECK_COMMA;
  433. fprintf(yout,"%d",XLNG_TRN(t,i));
  434.       }
  435.   
  436.   indent-=2;
  437.   if(down_ptr)
  438.     {
  439.       CHECK_COMMA;
  440.       emit_trn_constructor(DOWN_TRN(t),1);
  441.     }
  442.   indent-=2;
  443.   if(right_ptr)
  444.     if(look_to_the_right)
  445.       {
  446. if(!is_tree(t))
  447.   fputs(")",yout);
  448. CHECK_COMMA;
  449. emit_trn_constructor(RIGHT_TRN(t),1);
  450.       }
  451.     else if(is_tree(t))
  452.       fputs(",TNULL",yout);
  453.   fprintf(yout,")");
  454.   return;
  455. }