mql.ypp

件主要用于帮助计算机爱好者学习蚁群算法时做有关蚁群算法的试验。蚁群算法作为一种优秀的新兴的算法

			$$ = mk_selection(ps, $3, $5, $7);
		}
	| IF '(' expression ')' compound_statement ELSE selection_statement 
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_selection(ps, $3, $5, $7);
		}
	;
		
expression_statement
	: ';'				
		{ $$ = static_cast<ParserState*>(param)->empty_token(); }
	| expression ';'	{ $$ = $1; }
	;
	
compound_statement		
	: '{' statement_list '}'
		/*	Note that it traverse right to left */ 	
		{  ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_context(ps, $2);
		}								
	;
		
primary_expression
	: IDENTIFIER				
		{ $$ = mk_ref_var(static_cast<ParserState*>(param), $1); }
	| INT_CONSTANT 				
		{ $$ = mk_int(static_cast<ParserState*>(param), $1); }
	| DOUBLE_CONSTANT			
		{ $$ = mk_double(static_cast<ParserState*>(param), $1); } 
	| STRING_LITERAL			
		{ $$ = mk_string(static_cast<ParserState*>(param), $1); } 
	| '(' expression ')'		{ $$ = $2; }
	;

postfix_expression
	: primary_expression		{ $$ = $1; }
	| postfix_expression '.' IDENTIFIER
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_ref_adt_var(ps, $1, $3); 
		}
	| postfix_expression '[' expression ']'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_ref_array_var(ps, $1, $3);
		}
	| PRINT '(' expression ')'
		{ $$ = mk_print(static_cast<ParserState*>(param), $3); }
	| PRINTLN '(' expression ')'
		{ $$ = mk_println(static_cast<ParserState*>(param), $3); }		
	| IDENTIFIER '(' expression_sep ')'
		{ $$ = mk_function_ref(static_cast<ParserState*>(param), $1, $3); }
	| IDENTIFIER '(' ')'
		{ 	ParserState* ps = static_cast<ParserState*>(param); 
			$$ = mk_function_ref(ps, $1, ps->empty_token()); 
		}
	| RPC '(' expression ',' IDENTIFIER ',' expression_sep ')'
		{
			ParserState* ps = static_cast<ParserState*>(param);	
			$$ = mk_rpc(ps, $3, $5, $7);			
		}
	| RPC '(' expression ',' IDENTIFIER ')'
		{
			ParserState* ps = static_cast<ParserState*>(param);	
			$$ = mk_rpc(ps, $3, $5, ps->empty_token());			
		}				
	| ROUND '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ROUND, $3);
		}	
	| CEIL '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, CEIL, $3);
		}	
	| FLOOR '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, FLOOR, $3);
		}	
	| SIN '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, SIN, $3);
		}	
	| COS '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, COS, $3);
		}	
	| POW '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_2(ps, POW, $3, $5);
		}
	| DBL '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, DBL, $3);
		}
	| TAN '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, TAN, $3);
		}	
	| ASIN '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ASIN, $3);
		}	
	| ACOS '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ACOS, $3);
		}	
	| ATAN '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ATAN, $3);
		}
	| ARRAY_SIZE '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ARRAY_SIZE, $3);
		}
	| LOG_OP '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, LOG_OP, $3);
		}
	| EXP '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, EXP, $3);
		}
	| DNS_LOOKUP '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, DNS_LOOKUP, $3);		
		}
	| DNS_ADDR '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, DNS_ADDR, $3);		
		}
	| GET_SELF '(' ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_0(ps, GET_SELF);
		}
	| RING_GT '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, RING_GT, $3);
		}
	| RING_GE '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, RING_GE, $3);
		}
	| RING_LT '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, RING_LT, $3);
		}
	| RING_LE '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, RING_LE, $3);
		}
	| PUSH_BACK '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_2(ps, PUSH_BACK, $3, $5);
		}
	| POP_BACK '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, POP_BACK, $3);
		}
	| GET_DISTANCE_TCP '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(
					ps, GET_DISTANCE_TCP, mk_empty(ps), $3, $5);
		}		
	| GET_DISTANCE_TCP '(' expression ',' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(ps, GET_DISTANCE_TCP, $3, $5, $7);
		}
	| GET_DISTANCE_DNS '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(
				ps, GET_DISTANCE_DNS, mk_empty(ps), $3, $5);
		}		
	| GET_DISTANCE_DNS '(' expression ',' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(ps, GET_DISTANCE_DNS, $3, $5, $7);
		}
	| GET_DISTANCE_PING '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(
				ps, GET_DISTANCE_PING, mk_empty(ps), $3, $5);
		}				
	| GET_DISTANCE_PING '(' expression ',' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(ps, GET_DISTANCE_PING, $3, $5, $7);
		}
	| GET_DISTANCE_ICMP '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(
				ps, GET_DISTANCE_ICMP, mk_empty(ps), $3, $5);
		}				
	| GET_DISTANCE_ICMP '(' expression ',' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_3(ps, GET_DISTANCE_ICMP, $3, $5, $7);
		}
	| ARRAY_INTERSECT '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_2(ps, ARRAY_INTERSECT, $3, $5);		
		}
	| ARRAY_AVG '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ARRAY_AVG, $3);		
		}
	| ARRAY_MIN '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ARRAY_MIN, $3);		
		}
	| ARRAY_MAX '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ARRAY_MAX, $3);		
		}
	| ARRAY_MIN_OFFSET '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ARRAY_MIN_OFFSET, $3);		
		}
	| ARRAY_MAX_OFFSET '(' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_1(ps, ARRAY_MAX_OFFSET, $3);		
		}
	| ARRAY_UNION '(' expression ',' expression ')'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_native_func_2(ps, ARRAY_UNION, $3, $5);		
		}		
	;

unary_expression
	: postfix_expression		{ $$ = $1; }
	| '+' postfix_expression	{ $$ = $2; }
	| '-' postfix_expression	
		{ $$ = mk_unary(static_cast<ParserState*>(param), '-', $2); }
	| '!' postfix_expression	
		{ $$ = mk_unary(static_cast<ParserState*>(param), '!', $2); }
	;
	
multiplicative_expression
	: unary_expression			{ $$ = $1; }
	| multiplicative_expression '*' unary_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '*', $1, $3); }
	| multiplicative_expression '/' unary_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '/', $1, $3); }
	| multiplicative_expression '%' unary_expression 
		{ $$ = mk_arith(static_cast<ParserState*>(param), '%', $1, $3); }
	;
		
additive_expression
	: multiplicative_expression								{ $$ = $1; }	
	| additive_expression '+' multiplicative_expression 
		{ $$ = mk_arith(static_cast<ParserState*>(param), '+', $1, $3); }
	| additive_expression '-' multiplicative_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '-', $1, $3); }
	;
	
shift_expression
	: additive_expression		{ $$ = $1; }
	| shift_expression LEFT_OP additive_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), LEFT_OP, $1, $3); }
	| shift_expression RIGHT_OP additive_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), RIGHT_OP, $1, $3); }
	;

relational_expression
	: shift_expression			{ $$ = $1; }
	| relational_expression '<' shift_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '<', $1, $3); }
	| relational_expression '>' shift_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '>', $1, $3); }
	| relational_expression LE_OP shift_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), LE_OP, $1, $3); }	
	| relational_expression GE_OP shift_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), GE_OP, $1, $3); }
	;

equality_expression
	: relational_expression		{ $$ = $1; }
	| equality_expression EQ_OP relational_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), EQ_OP, $1, $3); }
	| equality_expression NE_OP relational_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), NE_OP, $1, $3); }
	;	

and_expression
	: equality_expression		{ $$ = $1; }
	| and_expression '&' relational_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '&', $1, $3); }
	;
	
exclusive_or_expression
	: and_expression			{ $$ = $1; }
	| exclusive_or_expression '^' and_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '^', $1, $3); }
	;
	
inclusive_or_expression
	: exclusive_or_expression	{ $$ = $1; }
	| inclusive_or_expression '|' exclusive_or_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), '|', $1, $3); }
	;
	
logical_and_expression
	: inclusive_or_expression	{ $$ = $1; }
	| logical_and_expression AND_OP inclusive_or_expression	
		{ $$ = mk_arith(static_cast<ParserState*>(param), AND_OP, $1, $3); }
	;
	
logical_or_expression
	: logical_and_expression	{ $$ = $1; }
	| logical_or_expression OR_OP logical_and_expression
		{ $$ = mk_arith(static_cast<ParserState*>(param), OR_OP, $1, $3); } 
	;
	
assign_expression
	: logical_or_expression		{ $$ = $1; }
	| postfix_expression '=' assign_expression
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_adt_assign(ps, $1, $3);
		}
	;
	
expression				
	: assign_expression			{ $$ = $1;}	
	;
	
%%