⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 bug.y

📁 开放源码的编译器open watcom 1.6.0版的源代码
💻 Y
📖 第 1 页 / 共 4 页
字号:
🔍
1234 
	    |	query_term T_UNION  T_ALL  query_term
		    {T( $$ = pa_binary_expr( E_UNIONALL, $1, $4 ); )}
	    ;

query_union:	query_union  T_UNION  query_term
		    {T( $$ = pa_binary_expr( E_UNION, $1, $3 ); )}
	    |	query_term T_UNION  query_term
		    {T( $$ = pa_binary_expr( E_UNION, $1, $3 ); )}
	    ;

query_term:	query_spec
	    |	T_LPAREN  query_expr  T_RPAREN
		    {T( $$ = pa_unary_expr( E_PAREN, $2 ); )}
	    ;

query_spec:	T_SELECT  summarizer  selectlist  selinto  from  where
		groupby  having
		    {T( $$ = pa_query_spec( $2, $3, $5, $6, $7, $8 ); )}
	    ;

single_subquery:T_LPAREN  query_spec  T_RPAREN
		    {T( $$ = pa_subquery( $2 );
		      $$ = pa_unary_expr( E_PAREN, $$ );
		    )}
	    ;

subquery:	T_LPAREN  query_expr  T_RPAREN
		    {T( $$ = pa_subquery( $2 );
		      $$ = pa_unary_expr( E_PAREN, $$ );
		    )}
	    ;

summarizer:	 /* empty */
		    {T( $$ = FALSE; )}
	    |	T_ALL
		    {T( $$ = FALSE; )}
	    |	distinct
		    {T( $$ = TRUE; )}
	    ;

distinct:	T_DISTINCT
		    {T( $$ = pa_distinct(); )}
	    ;

selectlist:	T_TIMES
		    {T( $$ = NULL; )}
	    |	sellist  optcomma
		    {T( $$ = pa_reverse_plist( $1 ); )}
	    ;

sellist:	selvalue
		    {T( $$ = pa_add_plist( NULL, $1 ); )}
	    |	sellist  T_COMMA  selvalue
		    {T( $$ = pa_add_plist( $1, $3 ); )}
	    ;

selvalue:	expression
	    |	expression  T_IDENTIFIER
		    {T( $$ = pa_binary_expr( E_NAME, $1, $2 ); )}
            |   tabname  T_DOTSTAR
	    ;

expression:	expression_nosub
	    |	subquery
	    ;

expression_notnull: expression
		    {T( if( pa_isnull( $1 ) ){
		          sql_errors( SQLE_SYNTAX_ERROR, "NULL" );
		      }
		    )}
	    ;

expression_nosub: expression T_PLUS expression
		    {T( $$ = pa_binary_expr( E_ADD, $1, $3 ); )}
	    |	expression T_MINUS expression
		    {T( $$ = pa_binary_expr( E_SUB, $1, $3 ); )}
	    |	expression T_TIMES expression
		    {T( $$ = pa_binary_expr( E_MUL, $1, $3 ); )}
	    |	expression T_DIVIDE expression
		    {T( $$ = pa_binary_expr( E_DIV, $1, $3 ); )}
	    |	expression T_CONCAT expression
		    {T( $$ = pa_binary_expr( E_CONCAT, $1, $3 ); )}
	    |	T_MINUS expression	%prec T_TIMES
		    {T( $$ = pa_unary_expr( E_UMINUS, $2 ); )}
	    |	T_PLUS expression	%prec T_TIMES
		    {T( $$ = $2; )}
	    |	colref  duration
	    |	constant  duration
	    |	T_NULL
		    {T( $$ = pa_zero_expr( E_NULL ); )}
	    |	builtin T_LPAREN parmlist  T_RPAREN  duration
		    { $$ = pa_builtin( $1, pa_reverse_plist( $3 ) ); }
	    |	builtin T_LPAREN T_TIMES T_RPAREN  duration
		    { $$ = pa_builtin( $1, NULL ); }
	    |	T_LPAREN expression_nosub T_RPAREN  duration
		    {T( $$ = pa_unary_expr( E_PAREN, $2 ); )}
	    |	T_IF searchcond T_THEN	expression  T_ELSE  expression	T_ENDIF
		    {  pa_specific( L_PACE );
		    T( $$ = pa_ternary_expr( E_IF, $2, $4, $6 ); 
		    )}
	    |	T_IF searchcond T_THEN	expression  T_ENDIF
		    {  pa_specific( L_PACE );
		    T( $$ = pa_ternary_expr( E_IF, $2, $4, NULL ); 
		    )}
	    ;

duration:   	/* empty */
	    |	T_YEAR
	    |	T_MONTH
	    |	T_DAY
	    |	T_DAYS
	    |	T_HOUR
	    |	T_MINUTE
	    |	T_SECOND
	    |	T_MICROSECOND
	    ;

parmlist:	parameter
		    { $$ = pa_add_plist( NULL, $1 ); }
	    |	parmlist  T_COMMA  parameter
		    { $$ = pa_add_plist( $1, $3 ); }
	    ;

parameter:	expression
		    {T( $$ = $1; )}
	    |	T_ALL  expression
		    {T( $$ = $2; )}
	    |	distinct  colref
		    {T( $$ = pa_unary_expr( E_DISTINCT, $2 ); )}
	    ;

builtin:	T_IDENTIFIER
            |	T_MAX
            |	T_MIN
            |	T_AVG
            |	T_SUM
            |	T_COUNT
            |	T_DATE
            |	T_YEAR
	    |	T_MONTH
	    |	T_DAYS
	    |	T_DAY
	    |	T_HOUR
	    |	T_MINUTE
	    |	T_SECOND
	    |	T_MICROSECOND
	    |	T_MILLISECOND
	    |	T_TIME
	    |	T_TIMESTAMP
	    |	T_LOWER
	    |	T_UPPER
	    |	T_SUBSTRING
	    |	T_RTRIM
	    |	T_RIGHT
	    |	T_LTRIM
	    |	T_LEFT
	    |	T_LENGTH
	    |	T_CHAR
	    ;

constant:	number
	    |	hostvar
	    |	string
	    |	special_register
	    ;

string: 	T_STRING
		    {T( $$ = pa_unary_expr( E_STRING, $1 ); )}
	    ;

special_register: T_USER
		    {T( $$ = pa_zero_expr( E_USER ); )}
	    |	T_CURRENT  T_DATE
	            { pa_specific( L_SAA ); }
	    |	T_CURRENT  T_TIME
	            { pa_specific( L_SAA ); }
	    |	T_CURRENT  T_TIMESTAMP
	            { pa_specific( L_SAA ); }
	    ;

from:		T_FROM	tabspec
		    {T( $$ = $2; )}
	    ;

tabspec:	{T( tabrefs = NULL; )} tabexprlist
		    {T( $$ = pa_tabspec( $2, tabrefs ); )}
	    ;

tabexprlist:	tabexprlistrev	optcomma
		    {T( $$ = pa_reverse_plist( $1 ); )}
	    ;

tabexprlistrev: tabexpr
		    {T( $$ = pa_add_plist( NULL, $1 ); )}
	    |	tabexprlistrev	T_COMMA  tabexpr
		    {T( $$ = pa_add_plist( $1, $3 ); )}
	    ;

tabexpr:	tabref
		    {T( $$ = pa_unary_expr( E_TABLE, $1 ); )}
	    |	tabexpr  T_JOIN  tabexpr
		    {T( $$ = pa_binary_expr( E_JOIN, $1, $3 ); )}
	    |	T_LPAREN  tabexprlist  T_RPAREN
		    {T( $$ = pa_unary_expr( E_PAREN, $2 ); )}
	    ;


tabref: 	T_IDENTIFIER  T_DOT  T_IDENTIFIER  corrname
		    {T( $$ = pa_tabref( &tabrefs, $3, $1, $4 ); )}
	    |	T_IDENTIFIER  corrname
		    {T( $$ = pa_tabref( &tabrefs, $1, NULL, $2 ); )}
	    ;

corrname:	T_IDENTIFIER
	    |	/* empty */
		    {T( $$ = NULL; )}
	    ;

tabname:	T_IDENTIFIER  T_DOT  T_IDENTIFIER
		    {T( $$ = pa_table( $3, $1 ); )}
	    |	T_IDENTIFIER
		    {T( $$ = pa_table( $1, NULL ); )}
	    ;

indexname:	T_IDENTIFIER
	    ;

colref: 	T_IDENTIFIER  T_DOT  colname
		    {T( $$ = pa_column( $1, $3 ); )}
	    |	colname
		    {T( $$ = pa_column( NULL, $1 ); )}
	    |   T_IDENTIFIER  T_DOT  T_IDENTIFIER  T_DOT  colname
	            { pa_specific( L_SAA ); }
	    ;

colreflist:	colreflistrev  optcomma
		    {T( $$ = pa_reverse_plist( $1 ); )}
	    ;

colreflistrev:	colref
		    {T( $$ = pa_add_plist( NULL, $1 ); )}
	    |	colreflistrev  T_COMMA  colref
		    {T( $$ = pa_add_plist( $1, $3 ); )}
	    ;

colname:	T_IDENTIFIER
	    ;

where:		T_WHERE  searchcond
		    {T( $$ = $2; )}
	    |	/* empty */
		    {T( $$ = NULL; )}
	    ;

searchcond:	boolterm
	    |	searchcond  T_OR  boolterm
		    {T( $$ = pa_binary_expr( E_OR, $1, $3 ); )}
	    ;

boolterm:	boolfactor
	    |	boolterm  T_AND  boolfactor
		    {T( $$ = pa_binary_expr( E_AND, $1, $3 ); )}
	    ;

boolfactor:	boolprimary
	    |	T_NOT  boolprimary
		    {T( $$ = pa_unary_expr( E_NOT, $2 ); )}
	    ;

boolprimary:	srchpred
	    |	T_LPAREN  searchcond  T_RPAREN
		    {T( $$ = pa_unary_expr( E_PAREN, $2 ); )}
	    |	T_LPAREN  searchcond  T_COMMA  expression  T_RPAREN
	            {  pa_specific( L_PACE );
		    T( $$ = pa_binary_expr( E_ESTIMATE, $2, $4 ); 
		    )}
	    ;

srchpred:	expression_notnull  comp_op  expression_notnull
		    {T( $$ = pa_binary_expr( (an_expr_type)$2, $1, $3 ); )}
	    |	expression_notnull  comp_op  quantified_subquery
		    {T( $$ = pa_binary_expr( (an_expr_type)$2, $1, $3 ); )}
	    |	T_EXISTS  subquery
		    {T( $$ = pa_unary_expr( E_EXISTS, $2 ); )}
	    |	expression_notnull  not  T_IN  single_subquery
		    { /* no UNIONS in subquery - grammar conflicts */
		   T( $$ = pa_binary_expr( E_EQ,
					   $1,
					   pa_unary_expr( E_ANY, $4 ) );
		      if( $2 ){
			  $$ = pa_unary_expr( E_NOT, $$ );
		      }
		    )}
	    |	expression_notnull  not  T_IN  T_LPAREN  vallist  T_RPAREN
		    {T( $$ = pa_binary_expr( E_IN, $1, $5 );
		      if( $2 ){
			  $$ = pa_unary_expr( E_NOT, $$ );
		      }
		    )}
	    |	expression_notnull  not  T_BETWEEN  expression  T_AND expression
		    {T( $$ = pa_ternary_expr( E_BETWEEN, $1, $4, $6 ); 
		      if( $2 ){
		          $$ = pa_unary_expr( E_NOT, $$ );
		      }
		    )}
	    |	expression  T_IS  not  T_NULL
		    {T( $$ = pa_unary_expr( E_ISNULL, $1 );
		      if( $3 ){
			  $$ = pa_unary_expr( E_NOT, $$ );
		      }
		    )}
	    |	expression_notnull  not  T_EXISTS
		    /* NOTE: the above expression must be a colref but
		       it causes a conflict
		    */
	            {  pa_specific( L_PACE ); 
		    T( pa_must_be_column( $1 );
		       $$ = pa_unary_expr( E_FKEYEXISTS, $1 );
		       if( $2 ){
		 	   $$ = pa_unary_expr( E_NOT, $$ );
		       }
		    )}
	/*
	    |   T_USING T_PRIMARY T_KEY T_FOR corrname
		    {T( $$ = pa_unary_expr( E_PKEYUSED, $5 ); )}
	*/
	    |	expression_notnull  not  T_LIKE  expression_notnull
		    {T( $$ = pa_like( $1, $4 );
		      if( $2 ) {
			  $$ = pa_unary_expr( E_NOT, $$ );
		      }
		    )}
	    ;

comp_op:	T_EQ
		    {T( $$ = E_EQ; )}
	    |	T_NE
		    {T( $$ = E_NE; )}
	    |	T_GT
		    {T( $$ = E_GT; )}
	    |	T_GE
		    {T( $$ = E_GE; )}
	    |	T_LT
		    {T( $$ = E_LT; )}
	    |	T_LE
		    {T( $$ = E_LE; )}
	    ;

quantified_subquery:	quantifier  subquery
		    {T( $$ = pa_unary_expr( (an_expr_type)$1, $2 ); )}
	    ;

quantifier:	T_ALL
		    {T( $$ = E_ALL; )}
	    |	T_ANY
		    {T( $$ = E_ANY; )}
	    |	T_SOME
		    {T( $$ = E_ANY; )}
	    ;

vallist:	vallistrev  optcomma
		    {T( $$ = pa_reverse_plist( $1 ); )}
	    ;

vallistrev:	valitem
		    {T( $$ = pa_add_plist( NULL, $1 ); )}
	    |	vallistrev  T_COMMA  valitem
		    {T( $$ = pa_add_plist( $1, $3 ); )}
	    ;

valitem:	expression
	    ;

ins_vallist:	ins_vallistrev	optcomma
		    {T( $$ = pa_reverse_plist( $1 ); )}
	    ;

ins_vallistrev: ins_valitem
		    {T( $$ = pa_add_plist( NULL, $1 ); )}
	    |	ins_vallistrev	T_COMMA  ins_valitem
		    {T( $$ = pa_add_plist( $1, $3 ); )}
	    ;

ins_valitem:	expression
	    ;

not:		T_NOT
		    {T( $$ = TRUE; )}
	    |	/* empty */
		    {T( $$ = FALSE; )}
	    ;

groupby:	/* empty */
		    {T( $$ = NULL; )}
	    |	T_GROUP  T_BY  vallist
		    {T( $$ = $3; )}
	    ;

having: 	/* empty */
		    {T( $$ = NULL; )}
	    |	T_HAVING searchcond
		    {T( $$ = $2; )}
	    ;

/*	Moved to rnsql.y
delete: 	T_DELETE  T_FROM  tabname  where
		    {T( $$ = pa_delete( $3, $4, NULL ); )}
	    |	T_DELETE  T_FROM  tabname  wherecurrentof
		    {T( $$ = pa_delete( $3, NULL, $4 ); )}
	    ;
*/

/* Following is used by the delete rule */

runid_spec:	string
	    |   hostvar
	    |   T_IDENTIFIER
	            {T( $$ = pa_unary_expr( E_STRING, $1 ); )}
	    ;
	    
wherecurrentof: T_WHERE  T_CURRENT  {SQLStmt=FALSE;}  T_OF  T_IDENTIFIER
		    {T( $$ = $5; )}
	    ;

update: 	T_UPDATE  tabspec  sets  where
		    {T( if( !pa_onetable( $2 ) ){
		          pa_specific( L_PACE );
		      }
		      $$ = pa_update( $2, $3, $4, NULL ); 
		    )}
	    |	T_UPDATE  tabspec  sets  wherecurrentof
		    { pa_specific( L_PACE );
		    T( if( !pa_onetable( $2 ) ){
		          pa_specific( L_PACE );
		      }
		      $$ = pa_update( $2, $3, NULL, $4 ); 
		    )}
	    ;

sets:		T_SET  setlist	optcomma
		    {T( $$ = pa_reverse_plist( $2 ); )}
	    ;

setlist:	setitem
		    {T( $$ = pa_iadd_plist( NULL, $1 ); )}
	    |	setlist  T_COMMA  setitem
		    {T( $$ = pa_iadd_plist( $1, $3 ); )}
	    ;

setitem:	colref	T_EQ  expression
		    {T( $$ = pa_setitem( $1, $3 ); )}
	    ;

insert: 	T_INSERT  T_INTO  tabname  columns  insertvalues
		    {T( $$ = pa_insert( $3, $4, $5, NULL ); )}
	    |	T_INSERT  T_INTO  tabname  columns  query_expr
		    {T( $$ = pa_insert( $3, $4, NULL, $5 ); )}
	    ;

insertvalues:	T_VALUES T_LPAREN ins_vallist T_RPAREN
		    {T( $$ = $3; )}
	    ;

columns:	/* empty */
		    {T( $$ = NULL; )}
	    |	T_LPAREN  T_RPAREN
		    {T( $$ = NULL; )}
	    |	T_LPAREN collist  T_RPAREN
		    {T( $$ = $2; )}
	    ;

collist:	collistrev  optcomma
		    {T( $$ = pa_reverse_plist( $1 ); )}
	    ;

collistrev:	colname
		    {T( $$ = pa_add_plist( NULL, $1 ); )}
	    |	collistrev  T_COMMA  colname
		    {T( $$ = pa_add_plist( $1, $3 ); )}
	    ;

optcomma:	/* empty */
	    |	T_COMMA
	    ;

createtable:	T_CREATE  T_TABLE  tabname  
                T_LPAREN  tblelmtlist  optcomma  T_RPAREN inclause  
		    {T( $$ = pa_create_table( $5, $3, $8 ); )}
	    ;

inclause:	/* empty */
		    {T( $$ = NULL; )}
	    |	T_IN  dbspacename
		    {T( $$ = $2; )}
	    ;
1234

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -