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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > Oracle数据库 > 查看源码
ifparse.y
资源名称：sqlweb-2.2.0.tar.gz　[点击查看]
上传用户：aidanglao
上传日期：2007-01-07
资源大小：69k
文件大小：8k
源码类别：

Oracle数据库

开发平台：

Unix_Linux

ifparse.y：源码内容
  1. %{
  2. /* ifparse.y - EXPR Parser
  3. /*
  4. /* Copyright (c) 1995-1999 Applied Information Technologies, Inc.
  5. /* All Rights Reserved.
  6. /*  
  7. /* Distributed uder the GNU General Public License which was included in
  8. /* the file named "LICENSE" in the package that you recieved.
  9. /* If not, write to:
  10. /* The Free Software Foundation, Inc.,
  11. /* 675 Mass Ave, Cambridge, MA 02139, USA.
  12.  */
  13. #include "scalar.h"
  14. #include "boolean.h"
  15. #include "ifwords.h"
  17. /* 
  18. /* The Global Variables for the IfParser
  19.  */
  20. static eBoolean_t gbIfResult; /* The Answer */
  21. static char       *gpIfExpr; /* The Expression to Parse */
  22. static int        giRestart = 0; /* Start a new expression */
  24. %}
  25. %union {
  26.     eBoolean_t bVal; /* Boolean Value eTrue or eFalse */
  27.     Scalar_t *pScalar; /* Scalar Variable */
  28. }
  30. %token IF AND OR NOT BETWEEN LIKE IS NULLX TRUEX FALSEX IN ASSIGN CAT
  31. %token COMPARISON LT GT LE GE EQ NEQ
  32. %token STRING INTNUM APPROXNUM FUNCNAME LITERAL TO_SCALAR
  33. %type <bVal>    IfExp BoolExp BoolCond /* Expr */
  34. %type <bVal>    BetweenCond LikeCond IsNullCond InCond CompareCond AssignCond
  35. %type <bVal>    IsTrueCond IsFalseCond
  36. %type <pScalar> ScalarExp ScalarCommaList SymbolRef SimpleExp
  37. %type <pScalar> COMPARISON LT GT LE GE EQ NEQ
  38. %type <pScalar> STRING INTNUM APPROXNUM FUNCNAME LITERAL
  39. %left AND OR
  40. %nonassoc NOT
  41. %left BETWEEN LIKE IS IN COMPARISON /* LT GT LE GE EQ NEQ */
  42. %left '+' '-' CAT
  43. %left '*' '/' '%'
  44. %nonassoc UMINUS ':'
  45. %%
  46. /*
  47. /* STARTING point an IF-Expression
  48.  */
  49. IfExp:   BoolExp ';'  {gbIfResult=$1;}
  50. | IF BoolExp ';'  {gbIfResult=$2;}
  51. ;
  52. /*
  53. /* Boolean Expression-- True or False
  54.  */
  55. BoolExp:  BoolExp AND BoolExp {$$= (ISeTrue($1) && ISeTrue($3));}
  56. | BoolExp  OR BoolExp {$$= (ISeTrue($1) || ISeTrue($3));}
  57. | NOT BoolExp {$$= !ISeTrue($2);}
  58. | '(' BoolExp ')' {$$= ISeTrue($2);}
  59. | BoolCond {$$= ISeTrue($1);}
  60. ;
  61. /* 
  62. /* Predicates that return Boolean Values
  63.  */
  64. BoolCond: CompareCond {$$=$1;}
  65. | BetweenCond {$$=$1;}
  66. | LikeCond {$$=$1;}
  67. | IsNullCond {$$=$1;}
  68. | IsTrueCond {$$=$1;}
  69. | IsFalseCond {$$=$1;}
  70. | InCond {$$=$1;}
  71. | AssignCond {$$=$1;}
  72. | ScalarExp {$$=OutputScalar($1);}
  73. ;
  74. /*
  75. /* The Specific Boolean Conditions
  76.  */
  77. BetweenCond: ScalarExp NOT BETWEEN ScalarExp AND ScalarExp
  78. {$$=!BetweenCond($1,$4,$6);}
  79. | ScalarExp     BETWEEN ScalarExp AND ScalarExp
  80. {$$= BetweenCond($1,$3,$5);}
  81. ;
  82. LikeCond: ScalarExp NOT LIKE ScalarExp {$$=!LikeCond($1,$4);}
  83. | ScalarExp LIKE ScalarExp {$$= LikeCond($1,$3);}
  84. ;
  85. IsNullCond: ScalarExp IS NOT NULLX {$$=!IsNullCond($1);}
  86. | ScalarExp IS NULLX {$$= IsNullCond($1);}
  87. ;
  88. IsTrueCond: ScalarExp IS NOT TRUEX {$$=!IsScalar($1);}
  89. | ScalarExp IS TRUEX {$$= IsScalar($1);}
  90. ;
  91. IsFalseCond: ScalarExp IS NOT FALSEX {$$= IsScalar($1);}
  92. | ScalarExp IS FALSEX {$$=!IsScalar($1);}
  93. ;
  94. InCond: ScalarExp NOT IN '(' ScalarCommaList ')'
  95. {$$=!InCond($1,$5);}
  96. | ScalarExp IN '(' ScalarCommaList ')'
  97. {$$= InCond($1,$4);}
  98. ;
  99. CompareCond: ScalarExp COMPARISON ScalarExp {$$=CompareCond($2,$1,$3);}
  100. ;
  101. AssignCond: SymbolRef ASSIGN ScalarExp {$$=AssignCond($1,$3);}
  102. ;
  103. /*
  104. /* scalar expressions
  105.  */
  106. ScalarExp: ScalarExp '+' ScalarExp {$$=AddScalar($1,$3);}
  107. | ScalarExp CAT ScalarExp {$$=CatScalar($1,$3);}
  108. | ScalarExp '-' ScalarExp {$$=SubScalar($1,$3);}
  109. | ScalarExp '*' ScalarExp {$$=MultScalar($1,$3);}
  110. | ScalarExp '/' ScalarExp {$$=DivScalar($1,$3);}
  111. | ScalarExp '%' ScalarExp {$$=ModScalar($1,$3);}
  112. | '+' ScalarExp %prec UMINUS {$$=$2;}
  113. | '-' ScalarExp %prec UMINUS {$$=USubScalar($2);}
  114. | FUNCNAME '(' ScalarCommaList ')'{$$=CallFunction($1,$3);}
  115. /* All function get called
  116. /* with a LIST* of Scalar_t
  117.  */
  118. | '(' ScalarExp ')' {$$=$2;}
  119. | SimpleExp {$$=$1;}
  120. | SymbolRef {$$=$1;}
  121. ;
  122. SimpleExp: STRING {$$=$1;} /* Quoted str 'xtr' */
  123. | INTNUM {$$=$1;} /* 242 */
  124. | APPROXNUM {$$=$1;} /* 234.223 */
  125. | TO_SCALAR '(' BoolExp ')' {$$=ToScalar($3);}
  126. ;
  127. SymbolRef: ':' ScalarExp  {$$=ScalarGetSym($2,"cE");}
  128. | ':' LITERAL {$$=ScalarGetSym($2,"cL");}
  129. | ':' LITERAL '[' ScalarExp ']' {$$=ScalarGetSymARR($2,$4);}
  130. /* | LITERAL  {$$=ScalarGetSym($1,"xL");}
  131.  */
  132. ;
  134. ScalarCommaList:
  135. /* nothing */ {$$=(Scalar_t*)0;}
  136. | ScalarExp {$$=MkScalar(eListType,$1,$1->lSize);}
  137. | ScalarCommaList ',' ScalarExp
  138. {$$=AddScalarToList($1,$3);}
  139. ;
  140. %%
  142. int
  143. yylex()
  144. {
  145.     static char *fp;
  146.     static char ssBuf[ BUFSIZ ]; /* Needs to stay around */
  147. /* so I can return pointer to... */
  148.     int    i;
  150.     if(giRestart == 0) {
  151. fp = gpIfExpr;
  152. giRestart = 1;
  153.     }
  155.     /* Skip White Space
  156.      */
  157.     while( isspace( *fp ) )
  158. fp++;
  160.     /*
  161.     /* Deal with the End-Of-String
  162.      */
  163.     if( *fp == 0) {
  164. if( giRestart == -1 ) {
  165.     giRestart=0;/* Second time... */
  166.     return(0); /* That's all */
  167. }
  168. giRestart= -1; /* Sets for End above */
  169. return(';'); /* Returns Sentinal Token */
  170.     }
  172.     /* fprintf(stderr,"yylex:%sn",fp);
  173.     /* fflush(stderr);
  174.      */
  176.     /*
  177.     /* Process known single and double character character tokens
  178.      */
  179.     switch(*fp) {
  180. /*
  181. /* COMPARISON's
  182.  */
  183. case '<':
  184.     if(*(fp+1) == '='){
  185. fp+=2;
  186. yylval.pScalar = MkScalarToken(LE);
  187. return COMPARISON;
  188.     }
  189.     if(*(fp+1) == '>'){
  190. fp+=2;
  191. yylval.pScalar = MkScalarToken(NEQ);
  192. return COMPARISON;
  193.     } else {
  194. fp++;
  195. yylval.pScalar = MkScalarToken(LT);
  196. return COMPARISON;
  197.     }
  198. case '>':
  199.     if(*(fp+1) == '='){
  200. fp+=2;
  201. yylval.pScalar = MkScalarToken(GE);
  202. return COMPARISON;
  203.     } else{
  204. fp++;
  205. yylval.pScalar = MkScalarToken(GT);
  206. return COMPARISON;
  207.     }
  208. case '!':
  209.     if(*(fp+1) == '=') {
  210. fp+=2;
  211. yylval.pScalar = MkScalarToken(NEQ);
  212. return COMPARISON;
  213.     } else {
  214. fp++;
  215. yylval.pScalar = MkScalarToken('!');
  216. return COMPARISON;
  217.     }
  218. case '=':
  219.     fp++;
  220.     yylval.pScalar = MkScalarToken(EQ);
  221.     return COMPARISON;
  222. case ':':
  223.     if(*(fp+1) == '=') {
  224. yylval.pScalar = MkScalarToken(ASSIGN);
  225. fp+=2;
  226. return(ASSIGN);
  227.     } else {
  228. yylval.pScalar = MkScalarToken(':');
  229. fp++;
  230. return(':');
  231.     }
  232. case '|':
  233.     if(*(fp+1) == '|') {
  234. yylval.pScalar = MkScalarToken(CAT);
  235. fp+=2;
  236. return(CAT);
  237.     } else {
  238. yylval.pScalar = MkScalarToken('|');
  239. fp++;
  240. return('|');
  241.     }
  242.     }
  244.     /*
  245.     /* Literal strings are Single Quoted
  246.      */
  247.     if( *fp == ''' ) {
  248. for(i=0, ++fp; *fp; fp++,i++) {
  249.     if(*fp==''' && *(fp+1) != ''')
  250. break;
  251.     ssBuf[i] = *fp;
  252. }
  253. ssBuf[i]='';
  254. if(*fp) ++fp;
  255. yylval.pScalar = MkScalar(eStringType,ssBuf,1+iStrLen(ssBuf));
  256. return(STRING);
  257.     }
  259.     /*
  260.     /* Numbers start with a digit or '.'
  261.      */
  262.     if(*fp =='.' || isdigit(*fp)) {
  263. for(i=0; *fp =='.' || isdigit(*fp); fp++,i++) {
  264.     ssBuf[i] = *fp;
  265. }
  266. ssBuf[i]='';
  267. /*
  268. /* Here's where we can differentiate between INTS and
  269. /* REALS, but don't need to...
  270.  */
  271. yylval.pScalar = MkScalar(eDoubleType,ssBuf,0);
  272. return(APPROXNUM);
  273.     }
  275.     /*
  276.     /* Variables/Builtins/Reserved words start with alpha
  277.      */
  278.     if( isalpha(*fp) || *fp == '_' ) {
  279. char *pBuf;
  280. Reserved_t *pResWord;
  282. for(i=0; *fp == '_' || isalnum(*fp) ; fp++,i++)
  283.     ssBuf[i]= *fp;
  284. ssBuf[i]='';
  286. for(pResWord=gaReservedWordTable; pResWord->pName; pResWord++){
  287.     if(bStrCaseMatch(pResWord->pName,ssBuf)) {
  288. /* Got one!
  289.  */
  290. if(pResWord->iType == TOKEN)
  291.     return(pResWord->iToken);
  292. yylval.pScalar = MkScalar(eStringType,ssBuf,1+iStrLen(ssBuf));
  293. return(pResWord->iToken);
  294.     }
  295. }
  296. /*
  297. /* Look up variable name
  298.  */
  299. yylval.pScalar = MkScalar(eStringType,ssBuf,1+iStrLen(ssBuf));
  300. return(LITERAL);
  301.     }
  303.     return(*fp++);
  304. }
  306. void
  307. yyerror(char *s)
  308. {
  309.     giRestart=0;
  310.     /*
  311.     /* fprintf(stderr,"yyerror:%sn",s);
  312.      */
  313.     MsgPush("ifparse error:%sn",s);
  314.     return;
  315. }
  317. eBoolean_t 
  318. ParseIf(char *pExpr, eBoolean_t *pbResult)
  319. {
  320.     giRestart=0; /* Restart at beginning of string */
  321.     gbIfResult=eFalse; /* Init Result to FALSE, feel lucky punk? */
  322.     gpIfExpr=pExpr; /* Set the Global Expression for yylex(); */
  323.     if(yyparse()) { /* Parse it! */
  324. MsgPush("Parser:Failed on "%s"",pExpr);
  325. *pbResult = gbIfResult;
  326. return(eFalse);
  327.     }
  328.     *pbResult = gbIfResult;
  329.     return(eTrue);
  330. }
  332. #ifdef MAIN_TEST
  333. int
  334. main(int argc, char **argv)
  335. {
  336.     if( ISeTrue(ParseIf(argv[1]) ) ) {
  337. fprintf(stderr,"Its TRUE!n");
  338.     } else {
  339. fprintf(stderr,"FALSEn");
  340.     }
  341.     exit(0);
  342. }
  343. int strcasecmp(char *s, char *t){ return iStrCaseCmp(s,t); }
  344. #endif