parse.y

firebird源代码

			PROCEDURE simple_proc_name FROM user_grantee_list
			{ $$ = make_node (nod_revoke, 
				(int) e_grant_count, $2, $5,
				make_list($7), NULL); }
		| REVOKE privileges ON prot_table_name
			FROM grantee_list
			{ $$ = make_node (nod_revoke, 
				(int) e_grant_count, $2, $4,
				make_list($6), NULL); }
		| REVOKE proc_privileges ON
			PROCEDURE simple_proc_name FROM grantee_list
			{ $$ = make_node (nod_revoke, 
				(int) e_grant_count, $2, $5,
				make_list($7), NULL); }
		| REVOKE role_name_list FROM role_grantee_list
			{ $$ = make_node (nod_revoke, 
				(int) e_grant_count, make_list($2), make_list($4),
				NULL, NULL); }
                ; 

rev_grant_option : GRANT OPTION FOR
			{ $$ = make_node (nod_grant, (int) 0, NULL); }
		;

grantee_list	: grantee
		| grantee_list ',' grantee
			{ $$ = make_node (nod_list, (int) 2, $1, $3); }
		| grantee_list ',' user_grantee
			{ $$ = make_node (nod_list, (int) 2, $1, $3); }
		| user_grantee_list ',' grantee
			{ $$ = make_node (nod_list, (int) 2, $1, $3); }
		;

grantee : PROCEDURE symbol_procedure_name
		{ $$ = make_node (nod_proc_obj, (int) 1, $2); }
	| TRIGGER symbol_trigger_name
		{ $$ = make_node (nod_trig_obj, (int) 1, $2); }
	| VIEW symbol_view_name
		{ $$ = make_node (nod_view_obj, (int) 1, $2); }
	| ROLE symbol_role_name
	        { $$ = make_node (nod_role_name, (int) 1, $2); }
	;

user_grantee_list : user_grantee
		| user_grantee_list ',' user_grantee
			{ $$ = make_node (nod_list, (int) 2, $1, $3); }
		;

/* CVC: In the future we can deprecate the first implicit form since we'll support
explicit grant/revoke for both USER and ROLE keywords & object types. */

user_grantee	: symbol_user_name
		{ $$ = make_node (nod_user_name, (int) 1, $1); }
	| USER symbol_user_name
		{ $$ = make_node (nod_user_name, (int) 2, $2, NULL); }
	| GROUP symbol_user_name
		{ $$ = make_node (nod_user_group, (int) 1, $2); }
	;

role_name_list  : role_name
        | role_name_list ',' role_name
            { $$ = make_node (nod_list, (int) 2, $1, $3); }
        ;

role_name   : symbol_role_name
        { $$ = make_node (nod_role_name, (int) 1, $1); }
        ;

role_grantee_list  : role_grantee
        | role_grantee_list ',' role_grantee
            { $$ = make_node (nod_list, (int) 2, $1, $3); }
        ;

role_grantee   : symbol_user_name
        { $$ = make_node (nod_user_name, (int) 1, $1); }
    | USER symbol_user_name
        { $$ = make_node (nod_user_name, (int) 1, $2); }
        ;

/* DECLARE operations */

declare		: DECLARE declare_clause
			{ $$ = $2;}
		;

declare_clause  : FILTER filter_decl_clause
			{ $$ = $2; }
		| EXTERNAL FUNCTION udf_decl_clause
			{ $$ = $3; }
		;

udf_decl_clause : symbol_UDF_name arg_desc_list1 RETURNS return_value1
			ENTRY_POINT sql_string MODULE_NAME sql_string
		    	{ $$ = make_node (nod_def_udf, (int) e_udf_count, 
				$1, $6, $8, make_list ($2), $4); }
		;

udf_data_type	: simple_type
		| BLOB
			{ field->fld_dtype = dtype_blob; }
		| CSTRING '(' pos_short_integer ')' charset_clause
			{ 
			field->fld_dtype = dtype_cstring; 
			field->fld_character_length = (SLONG) $3; }
		;

arg_desc_list1	: 
		 	{ $$ = (NOD) NULL; }
		| arg_desc_list	
		| '(' arg_desc_list ')'	
		 	{ $$ = $2; }
		;

arg_desc_list	: arg_desc
		| arg_desc_list ',' arg_desc
			{ $$ = make_node (nod_list, (int) 2, $1, $3); }
		;

/*arg_desc	: init_data_type udf_data_type
			{ $$ = $1; }*/
arg_desc	: init_data_type udf_data_type
			{ $$ = make_node (nod_udf_param, (int) e_udf_param_count,
				$1, NULL); }
		| init_data_type udf_data_type BY KW_DESCRIPTOR
			{ $$ = make_node (nod_udf_param, (int) e_udf_param_count,
				$1, MAKE_constant ((STR) FUN_descriptor, CONSTANT_SLONG)); }
		;

return_value1	: return_value
		| '(' return_value ')'
			{ $$ = $2; }
		;
return_value	: init_data_type udf_data_type
			{ $$ = make_node (nod_udf_return_value, (int) 2, $1, 
				MAKE_constant ((STR) FUN_reference, CONSTANT_SLONG));}
		| init_data_type udf_data_type FREE_IT
			{ $$ = make_node (nod_udf_return_value, (int) 2, $1, 
				MAKE_constant ((STR) (-1 * FUN_reference), CONSTANT_SLONG));}
                                         /* FUN_refrence with FREE_IT is -ve */
		| init_data_type udf_data_type BY KW_VALUE
			{ $$ = make_node (nod_udf_return_value, (int) 2, $1, 
				MAKE_constant ((STR) FUN_value, CONSTANT_SLONG));}
/* CVC: Enable return by descriptor for the future.*/
		| init_data_type udf_data_type BY KW_DESCRIPTOR
			{ $$ = make_node (nod_udf_return_value, (int) 2, $1,
				MAKE_constant ((STR) FUN_descriptor, CONSTANT_SLONG));}
		| PARAMETER pos_short_integer
			{ $$ = make_node (nod_udf_return_value, (int) 2, 
		  		(NOD) NULL, MAKE_constant ((STR) $2, CONSTANT_SLONG));}
		;

filter_decl_clause : symbol_filter_name INPUT_TYPE blob_subtype OUTPUT_TYPE blob_subtype 
			ENTRY_POINT sql_string MODULE_NAME sql_string
		    	{ $$ = make_node (nod_def_filter, (int) e_filter_count, 
						$1, $3, $5, $7, $9); }
		;

/* CREATE metadata operations */

create	 	: CREATE create_clause
			{ $$ = $2; }
                ; 

create_clause	: EXCEPTION symbol_exception_name sql_string
			{ $$ = make_node (nod_def_exception, (int) e_xcp_count, 
						$2, $3); }
		| unique_opt order_direction INDEX symbol_index_name ON simple_table_name index_definition
			{ $$ = make_node (nod_def_index, (int) e_idx_count, 
					$1, $2, $4, $6, $7); }
		| PROCEDURE procedure_clause
			{ $$ = $2; }
		| TABLE table_clause
			{ $$ = $2; }
		| TRIGGER def_trigger_clause
			{ $$ = $2; }
		| VIEW view_clause
			{ $$ = $2; }
		| GENERATOR generator_clause
			{ $$ = $2; }
		| DATABASE db_clause
			{ $$ = $2; }
		| DOMAIN domain_clause
			{ $$ = $2; }             
		| SHADOW shadow_clause
			{ $$ = $2; }             
		| ROLE role_clause
			{ $$ = $2; }
		;

recreate 	: RECREATE recreate_clause
			{ $$ = $2; }
		;

recreate_clause	: PROCEDURE rprocedure_clause
			{ $$ = $2; }
		| TABLE rtable_clause
			{ $$ = $2; }
/*		| TRIGGER def_trigger_clause
			{ $$ = $2; }
		| VIEW rview_clause
			{ $$ = $2; }
		| DOMAIN rdomain_clause
			{ $$ = $2; }             
*/
                ;


/* CREATE INDEX */

unique_opt	: UNIQUE
			{ $$ = make_node (nod_unique, (int) 0, NULL); }
		|
			{ $$ = NULL; }
		;

index_definition : column_list 
			{ $$ = make_list ($1); }
		| column_parens 
		| computed_by '(' begin_trigger value end_trigger ')'
			{ $$ = make_node (nod_def_computed, 2, $4, $5); }
		;

/* CREATE SHADOW */
shadow_clause	: pos_short_integer manual_auto conditional sql_string
			first_file_length sec_shadow_files
		 	{ $$ = make_node (nod_def_shadow, (int) e_shadow_count,
			     $1, $2, $3, $4, $5, make_list ($6)); }
		;

manual_auto	: MANUAL
			{ $$ = MAKE_constant ((STR) 1, CONSTANT_SLONG); } 
		| AUTO
			{ $$ = MAKE_constant ((STR) 0, CONSTANT_SLONG); } 
		| 
			{ $$ = MAKE_constant ((STR) 0, CONSTANT_SLONG); } 
		;

conditional	: 
			{ $$ = MAKE_constant ((STR) 0, CONSTANT_SLONG); }
		| CONDITIONAL
			{ $$ = MAKE_constant ((STR) 1, CONSTANT_SLONG); }
		;	

first_file_length : 
			{ $$ = (NOD) 0;}
		| LENGTH equals long_integer page_noise
			{ $$ = $3; }
		;

sec_shadow_files :
		 	{ $$ = (NOD) NULL; }
		| db_file_list
		;

db_file_list    : db_file
		| db_file_list db_file
			{ $$ = make_node (nod_list, (int) 2, $1, $2); }
		;

/* CREATE DOMAIN */

domain_clause	: column_def_name
		  as_opt
		  data_type
		  begin_trigger
		  domain_default_opt
		  end_trigger
		  domain_constraint_clause
		  collate_clause
			{ $$ = make_node (nod_def_domain, (int) e_dom_count,
                                          $1, $5, $6, make_list ($7), $8); }
                ;

/*
rdomain_clause	: DOMAIN alter_column_name alter_domain_ops
                        { $$ = make_node (nod_mod_domain, (int) e_alt_count,
                                          $2, make_list ($3)); }
*/

as_opt		: AS
                  { $$ = NULL; }
                | 
                  { $$ = NULL; }  
                ;

domain_default_opt	: DEFAULT begin_trigger default_value
				{ $$ = $3; }
			|
				{ $$ = (NOD) NULL; }
			;

domain_constraint_clause	: 
                                  { $$ = (NOD) NULL; }
				| domain_constraint_list
                                ; 

domain_constraint_list  	: domain_constraint_def
				| domain_constraint_list domain_constraint_def
                                  { $$ = make_node (nod_list, (int) 2, $1, $2); }
                        ;
domain_constraint_def		: domain_constraint
				  { $$ = make_node (nod_rel_constraint, (int) 2, NULL, $1);}
 
                        ;	

domain_constraint	  	: null_constraint
				| domain_check_constraint
                        	;
                                
null_constraint			: NOT KW_NULL
                                  { $$ = make_node (nod_null, (int) 0, NULL); }
                                ;

domain_check_constraint 	: begin_trigger CHECK '(' search_condition ')' end_trigger
				  { $$ = make_node (nod_def_constraint, 
				  (int) e_cnstr_count, MAKE_string (NULL_STRING, 0), NULL, 
				  NULL, NULL, $4, NULL, $6, NULL, NULL); }
                                ;

/* CREATE GENERATOR */

generator_clause : symbol_generator_name
			{ $$ = make_node (nod_def_generator, 
						(int) e_gen_count, $1); }
		 ;

/* CREATE ROLE */

role_clause : symbol_role_name
			{ $$ = make_node (nod_def_role, 
						(int) 1, $1); }


/* CREATE DATABASE */

db_clause	:  db_name db_initial_desc1 db_rem_desc1
			{ $$ = make_node (nod_def_database, (int) e_cdb_count,
				 $1, make_list($2), make_list ($3));}
		;

equals		:
		| '='
		;

db_name		: sql_string
			{ log_defined = FALSE;
			  cache_defined = FALSE;
			  $$ = (NOD) $1; }
		;

db_initial_desc1 :  
			{$$ = (NOD) NULL;}
		| db_initial_desc
		;

db_initial_desc : db_initial_option
		| db_initial_desc db_initial_option
			{ $$ = make_node (nod_list, 2, $1, $2); }
		; 
 
db_initial_option: PAGE_SIZE equals pos_short_integer 
			{ $$ = make_node (nod_page_size, 1, $3);}
		| LENGTH equals long_integer page_noise
			{ $$ = make_node (nod_file_length, 1, $3);}
		| USER sql_string
			{ $$ = make_node (nod_user_name, 1, $2);} 
		| PASSWORD sql_string	
			{ $$ = make_node (nod_password, 1, $2);} 
		| SET NAMES sql_string	
			{ $$ = make_node (nod_lc_ctype, 1, $3);} 
		;

db_rem_desc1	:  
			{$$ = (NOD) NULL;} 
		| db_rem_desc
		;

db_rem_desc	: db_rem_option
		| db_rem_desc db_rem_option
			{ $$ = make_node (nod_list, 2, $1, $2); }
		;

db_rem_option   : db_file  
/*   		| db_cache */
		| db_log
		| db_log_option
		| DEFAULT CHARACTER SET symbol_character_set_name
			{ $$ = make_node (nod_dfl_charset, 1, $4);} 
		;

db_log_option   : GROUP_COMMIT_WAIT equals long_integer
			{ $$ = make_node (nod_group_commit_wait, 1, $3);}
		| CHECK_POINT_LEN equals long_integer
			{ $$ = make_node (nod_check_point_len, 1, $3);}
		| NUM_LOG_BUFS equals pos_short_integer
			{ $$ = make_node (nod_num_log_buffers, 1, $3);}
		| LOG_BUF_SIZE equals unsigned_short_integer
			{ $$ = make_node (nod_log_buffer_size, 1, $3);}
		;

db_log		: db_default_log_spec
			{ if (log_defined)
			    yyabandon (-260, isc_log_redef);  /* Log redefined */
			  log_defined = TRUE;
			  $$ = $1; }
		| db_rem_log_spec
			{ if (log_defined)
			    yyabandon (-260, isc_log_redef);
			  log_defined = TRUE;
			  $$ = $1; }
		;	

db_rem_log_spec	: LOGFILE '(' logfiles ')' OVERFLOW logfile_desc
			{ file->fil_flags |= LOG_serial | LOG_overflow; 
			  if (file->fil_partitions)
			      yyabandon (-261, isc_partition_not_supp);
			/* Partitions not supported in series of log file specification */
			 $$ = make_node (nod_list, 2, $3, $6); }  
		| LOGFILE BASENAME logfile_desc
			{ file->fil_flags |= LOG_serial;
			  if (file->fil_partitions)
			      yyabandon (-261, isc_partition_not_supp);
			  $$ = $3; }
		;

db_default_log_spec : LOGFILE 
			{ file = make_file(); 
			  file->fil_flags = LOG_serial | LOG_default;
			  $$ = make_node (nod_log_file_desc, (int) 1,
						(NOD) file);}
		;

db_file		: file1 sql_string file_desc1
			{ file->fil_name = (STR) $2; 
			  $$ = (NOD) make_node (nod_file_desc, (int) 1,
						(NOD) file); }
		;

/*
db_cache	: CACHE sql_string cache_length 
			{ 
			  if (cache_defined)
			      yyabandon (-260, isc_cache_redef);
				  */ /* Cache redefined */ /*
			  file = make_file();
			  file->fil_length = (SLONG) $3;
			  file->fil_name = (STR) $2;
			  cache_defined = TRUE;
			  $$ = (NOD) make_node (nod_cache_file_desc, (int) 1,
					 (NOD) file); } 
		;
*/

/*
cache_length	: 
			{ $$ = (NOD) (SLONG) DEF_CACHE_BUFFERS; }
		| LENGTH equals long_integer page_noise
			{ if ((SLONG) $3 < MIN_CACHE_BUFFERS)
			      yyabandon (-239, isc_cache_too_small);
				  */ /* Cache length too small */ /*
			  else 
			      $$ = (NOD) $3; }
		;
*/

logfiles	: logfile_desc 
		| logfiles ',' logfile_desc
			{ $$ = make_node (nod_list, 2, $1, $3); }
		;
logfile_desc	: logfile_name logfile_attrs 
			{ 
#ifndef WINDOWS_ONLY
		         check_log_file_attrs(); 
#endif
			 $$ = (NOD) make_node (nod_log_file_desc, (int) 1,
                                                (NOD) file); }
		;
logfile_name	: sql_string 
			{ file = make_file();
			  file->fil_name = (STR) $1; } 
		;
logfile_attrs	: 
		| logfile_attrs logfile_attr
		;

logfile_attr	: SIZE equals long_integer
			{ file->fil_length = (SLONG) $3; }
/*
		| RAW_PARTITIONS equals pos_short_integer
			{ file->fil_partitions = (SSHORT) $3; 
			  file->fil_flags |= LOG_raw; } */
		;

file1		: KW_FILE
			{ file  = make_file ();}
		;

file_desc1	:
		| file_desc
		;

file_desc	: file_clause
		| file_desc file_clause
		;

file_clause	: STARTING file_clause_noise long_integer
			{ file->fil_start = (SLONG) $3;}
		| LENGTH equals long_integer page_noise
			{ file->fil_length = (SLONG) $3;}
		;

file_clause_noise :
		| AT
		| AT PAGE
		;

page_noise	:
		| PAGE
		| PAGES
		;