mql.ypp

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

%{
/******************************************************************************
Meridian prototype distribution
Copyright (C) 2005 Bernard Wong

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

The copyright owner can be contacted by e-mail at [e-mail]
*******************************************************************************/

using namespace std;

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
//#include <setjmp.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <ucontext.h>
#include "Marshal.h"
#include "MQLState.h"
#include "MeridianDSL.h"

#define YYPARSE_PARAM param
#define YYLEX_PARAM param


ucontext_t global_env_thread;	// For ending an intepreter immediately
//jmp_buf global_env_pc;		// For switching between threads
//ucontext_t* global_env_pc = NULL;

void yyerror(const char *str) {
	DSL_ERROR( "%s: line %d\n", str, g_parser_line);
}

int yylex(YYSTYPE* next_token, void* in_parser) {
	if (in_parser == NULL) {
		return 0;
	}	
	ParserState* cur_parser = static_cast<ParserState*>(in_parser);
	cur_parser->set_parse_result(next_token);
	return cur_parser->get_lex()->scan(cur_parser);
}

%}

%union{
	double 	 	d_val;
	int		 	i_val;
	string*  	s_val;
	ASTType		v_val;
	ASTNode*	n_val;
};

%token<s_val> IDENTIFIER STRING_LITERAL
%token<i_val> INT_CONSTANT 
%token<d_val> DOUBLE_CONSTANT
%token INT DOUBLE STRING IF ELSE AND_OP OR_OP LEFT_OP RIGHT_OP LE_OP GE_OP
%token SIN COS POW PRINT ROUND CEIL FLOOR EQ_OP NE_OP WHILE VOID DBL TAN ASIN
%token ACOS ATAN CONTINUE BREAK RETURN STRUCT RPC ARRAY_SIZE LOG_OP EXP
%token DNS_LOOKUP DNS_ADDR GET_SELF RING_GT RING_GE RING_LT RING_LE
%token GET_DISTANCE_TCP GET_DISTANCE_DNS GET_DISTANCE_PING PUSH_BACK POP_BACK
%token ARRAY_INTERSECT FOR PRINTLN ARRAY_AVG ARRAY_MAX ARRAY_MIN 
%token ARRAY_MAX_OFFSET ARRAY_MIN_OFFSET ARRAY_UNION GET_DISTANCE_ICMP
%type<v_val> type
%type<n_val> primary_expression postfix_expression unary_expression
%type<n_val> multiplicative_expression additive_expression assign_expression
%type<n_val> expression declaration_statement statement statement_list
%type<n_val> expression_statement compound_statement selection_statement
%type<n_val> and_expression iteration_statement jump_statement
%type<n_val> exclusive_or_expression
%type<n_val> inclusive_or_expression
%type<n_val> logical_and_expression expression_sep parameter_sep
%type<n_val> logical_or_expression relational_expression shift_expression
%type<n_val> input_state global_declaration parameter_array_fixed
%type<n_val> equality_expression parameter_list parameter parameter_adt

%start start_state
%pure-parser
%%

start_state
	: input_state 
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			ps->set_start($1);
		}
	;

input_state
	:	/* Empty */
		{ $$ = static_cast<ParserState*>(param)->empty_token(); }
	| input_state global_declaration 
		{ $$ = mk_node_list(static_cast<ParserState*>(param), $2, $1); }
	;
		
global_declaration
	: IDENTIFIER IDENTIFIER '(' parameter_sep ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(ps, ADT_TYPE, $1, EMPTY_TYPE, $2, $4, $7); 
		}
	| IDENTIFIER IDENTIFIER '(' ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(
				ps, ADT_TYPE, $1, EMPTY_TYPE, $2, ps->empty_token(), $6); 
		}				
	| type IDENTIFIER '(' parameter_sep ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(ps, $1, NULL, EMPTY_TYPE, $2, $4, $7); 
		}
	| type IDENTIFIER '(' ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(
				ps, $1, NULL, EMPTY_TYPE, $2, ps->empty_token(), $6); 
		}
	| IDENTIFIER '[' ']' IDENTIFIER '(' parameter_sep ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(ps, ARRAY_TYPE, $1, ADT_TYPE, $4, $6, $9); 
		}
	| IDENTIFIER '[' ']' IDENTIFIER '(' ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(
				ps, ARRAY_TYPE, $1, ADT_TYPE, $4, ps->empty_token(), $8); 
		}				
	| type '[' ']' IDENTIFIER '(' parameter_sep ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(ps, ARRAY_TYPE, NULL, $1, $4, $6, $9); 
		}
	| type '[' ']' IDENTIFIER '(' ')' '{' statement_list '}'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_function_declare(
				ps, ARRAY_TYPE, NULL, $1, $4, ps->empty_token(), $8); 
		}		
	| STRUCT IDENTIFIER '{' parameter_list '}' ';'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_adt(ps, $2, $4);
		}	
	;
	
parameter
	: type IDENTIFIER
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_var(ps, $1, $2); 
		}		
	| type IDENTIFIER '[' ']'  			
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_var_array(ps, $1, $2, mk_int(ps, 0)); 
		}
	;
		
parameter_array_fixed
	: parameter { $$ = $1; }
	| type IDENTIFIER '[' INT_CONSTANT ']'  			
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_var_array(ps, $1, $2, mk_int(ps, $4)); 
		}
	;
	
// Parameter list cannot contain ADTs
// Can contain fixed size arrays
parameter_list
	: parameter_array_fixed ';'	
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_sep_list(ps, $1); 
		}	 
	| parameter_list parameter_array_fixed ';'
		{ 	$1->val.p_val.p_vector->push_back($2);
			$$ = $1; 
		}
	;

parameter_adt
	: parameter	{ $$ = $1; }
	| IDENTIFIER IDENTIFIER		
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var(ps, $1, $2); 
		}
	| IDENTIFIER IDENTIFIER '[' ']'		
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var_array(ps, $1, $2, mk_int(ps, 0)); 
		}		
	;

// Can contain ADTs
// Can only contain 0 sized arrays
parameter_sep
	: parameter_adt	
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_sep_list(ps, $1); 
		}	
	| parameter_sep ',' parameter_adt
		{ 	$1->val.p_val.p_vector->push_back($3);
			$$ = $1; 
		}
	;
	
expression_sep
	: expression
		{ 	ParserState* ps = static_cast<ParserState*>(param);	
			$$ = mk_sep_list(ps, $1);
		}
	| expression_sep ',' expression
		{ 	$1->val.p_val.p_vector->push_back($3);
			$$ = $1; 
		}
	;

statement_list
	: /* Empty */				
		{ $$ = static_cast<ParserState*>(param)->empty_token(); }
	| statement_list statement	
		{ $$ = mk_node_list(static_cast<ParserState*>(param), $2, $1); }
	;
		
type
	: INT 						{ $$ = INT_TYPE; }
	| DOUBLE					{ $$ = DOUBLE_TYPE; }
	| STRING					{ $$ = STRING_TYPE; }
	| VOID						{ $$ = VOID_TYPE; }
	;

//	Making declaration a statement in this language
declaration_statement
	: parameter_adt ';' 	{$$ = $1;}
	| type IDENTIFIER '[' expression ']' ';'  			
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_var_array(ps, $1, $2, $4); 
		}		
	| IDENTIFIER IDENTIFIER '[' expression']' ';'		
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var_array(ps, $1, $2, $4); 
		}	
	| type IDENTIFIER '=' expression ';'	
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_var_assign(ps, $1, $2, $4); 
		}
	| IDENTIFIER IDENTIFIER '=' expression ';'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var_assign(ps, $1, $2, $4); 
		}
	| IDENTIFIER IDENTIFIER '=' '{' expression_sep '}' ';'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var_assign(ps, $1, $2, $5); 
		}
	| type IDENTIFIER '[' ']' '=' expression ';'	
		{ 	ParserState* ps = static_cast<ParserState*>(param);		
			$$ = mk_new_var_array_assign(ps, $1, $2, $6, mk_int(ps, 0)); 
		}
	| type IDENTIFIER '[' ']' '=' '{' expression_sep '}' ';'	
		{ 	ParserState* ps = static_cast<ParserState*>(param);		
			$$ = mk_new_var_array_assign(ps, $1, $2, $7, mk_int(ps, 0)); 
		}		
	| IDENTIFIER IDENTIFIER '[' ']' '=' expression ';'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var_array_assign(ps, $1, $2, $6, mk_int(ps, 0)); 
		}
	| IDENTIFIER IDENTIFIER '[' ']' '=' '{' expression_sep '}' ';'
		{ 	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_new_adt_var_array_assign(ps, $1, $2, $7, mk_int(ps, 0)); 
		}		
	;
		
statement
	: compound_statement		{ $$ = $1; }	
	| selection_statement		{ $$ = $1; }
	| expression_statement		{ $$ = $1; }
	| declaration_statement		{ $$ = $1; }
	| iteration_statement		{ $$ = $1; }
	| jump_statement			{ $$ = $1; }
	;
	
jump_statement
	: CONTINUE ';'				
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = ps->continue_token();
		}
	| BREAK ';'
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = ps->break_token();
		}
	| RETURN expression ';'
		{
			ParserState* ps = static_cast<ParserState*>(param);			
			$$ = mk_return(ps, $2);
		}
	| RETURN ';'
		{
			ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_return(ps, ps->empty_token());
		}
	;
	
iteration_statement
	: WHILE '(' expression ')' compound_statement
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_loop(ps, $3, $5);			
		}
	| FOR '(' statement expression_statement expression ')' compound_statement
		{	ParserState* ps = static_cast<ParserState*>(param);
			// Give the for loop it's own context
			$$ = mk_context(ps, mk_for_loop(ps, $3, $4, $5, $7));		
		}
	;
		
selection_statement
	: IF '(' expression ')' compound_statement
		{	ParserState* ps = static_cast<ParserState*>(param);
			$$ = mk_selection(ps, $3, $5, ps->empty_token());
		}
	| IF '(' expression ')' compound_statement ELSE compound_statement 
		{	ParserState* ps = static_cast<ParserState*>(param);