%skeleton "lalr1.cc"
%require "2.3"
%defines

%{
using namespace std;

class ParsingDriver;

#include "ExprNode.hh"
%}

%parse-param { ParsingDriver &driver }
%lex-param { ParsingDriver &driver }

%locations
%initial-action
{
  // Initialize the location filenames
  @$.begin.filename = @$.end.filename = &driver.file;
};

%debug
%error-verbose

%union
{
  string *string_val;
  NodeID node_val;
};

%{
#include "ParsingDriver.hh"
%}

%token AR AUTOCORR
%token BAYESIAN_IRF BETA_PDF
%token BVAR_DENSITY BVAR_FORECAST
%token BVAR_PRIOR_DECAY BVAR_PRIOR_FLAT BVAR_PRIOR_LAMBDA
%token BVAR_PRIOR_MU BVAR_PRIOR_OMEGA BVAR_PRIOR_TAU BVAR_PRIOR_TRAIN
%token BVAR_REPLIC
%token CALIB CALIB_VAR CHECK CONF_SIG CONSTANT CORR COVAR CUTOFF
%token DATAFILE DR_ALGO DROP DSAMPLE DYNASAVE DYNATYPE
%token END ENDVAL EQUAL ESTIMATION ESTIMATED_PARAMS ESTIMATED_PARAMS_BOUNDS ESTIMATED_PARAMS_INIT
%token FILENAME FILTER_STEP_AHEAD FILTERED_VARS FIRST_OBS
%token <string_val> FLOAT_NUMBER
%token FORECAST
%token GAMMA_PDF GCC_COMPILER GRAPH
%token HISTVAL HP_FILTER HP_NGRID
%token INITVAL
%token <string_val> INT_NUMBER
%token INV_GAMMA_PDF IRF
%token KALMAN_ALGO KALMAN_TOL
%token LAPLACE LCC_COMPILER LIK_ALGO LIK_INIT LINEAR LOAD_MH_FILE LOGLINEAR MARKOWITZ
%token MH_DROP MH_INIT_SCALE MH_JSCALE MH_MODE MH_NBLOCKS MH_REPLIC MH_RECOVER
%token MODE_CHECK MODE_COMPUTE MODE_FILE MODEL MODEL_COMPARISON MSHOCKS
%token MODEL_COMPARISON_APPROXIMATION MODIFIEDHARMONICMEAN MOMENTS_VARENDO
%token <string_val> NAME
%token NOBS NOCONSTANT NOCORR NODIAGNOSTIC NOFUNCTIONS NOGRAPH NOMOMENTS NOPRINT NORMAL_PDF
%token OBSERVATION_TRENDS OLR OLR_INST OLR_BETA OPTIM OPTIM_WEIGHTS ORDER OSR OSR_PARAMS
%token PARAMETERS PERIODS PLANNER_OBJECTIVE PREFILTER PRESAMPLE PRINT PRIOR_TRUNC PRIOR_ANALYSIS POSTERIOR_ANALYSIS
%token QZ_CRITERIUM
%token RELATIVE_IRF REPLIC RPLOT
%token SHOCKS SIGMA_E SIMUL SIMUL_ALGO SIMUL_SEED SMOOTHER SOLVE_ALGO SPARSE_DLL STDERR STEADY STOCH_SIMUL
%token TEX RAMSEY_POLICY PLANNER_DISCOUNT
%token <string_val> TEX_NAME
%token UNIFORM_PDF UNIT_ROOT_VARS USE_DLL
%token VALUES VAR VAREXO VAREXO_DET VAROBS
%token XLS_SHEET XLS_RANGE
%left COMMA
%left PLUS MINUS
%left TIMES DIVIDE
%left UMINUS
%nonassoc POWER
%token EXP LOG LOG10 SIN COS TAN ASIN ACOS ATAN SINH COSH TANH ASINH ACOSH ATANH SQRT

%type <node_val> expression
%type <node_val> equation hand_side model_var
%type <string_val> signed_float signed_integer prior
%type <string_val> value filename filename_elem vec_int_elem vec_int_1 vec_int
%type <string_val> calib_arg2 range

%%

%start statement_list;

 statement_list
 	: statement
        | statement_list statement
        ;

 statement
  	: declaration
 	| periods
  | cutoff
  | markowitz
 	| model
 	| initval
 	| endval
 	| histval
 	| init_param
 	| shocks
 	| mshocks
 	| sigma_e
 	| steady
 	| check
 	| simul
 	| stoch_simul
 	| estimation
        | prior_analysis
        | posterior_analysis
	| estimated_params
	| estimated_params_bounds
	| estimated_params_init
	| varobs
	| observation_trends
	| unit_root_vars
	| dsample
	| rplot
	| optim_weights
	| osr_params
	| osr
	| calib_var
	| calib
	| dynatype
	| dynasave
	| olr
	| olr_inst
        | model_comparison
        | planner_objective
	| ramsey_policy
  | bvar_density
  | bvar_forecast
	;


 declaration
 	: parameters
 	| var
 	| varexo
 	| varexo_det
 	;


 dsample : DSAMPLE INT_NUMBER ';' { driver.dsample($2);}
         | DSAMPLE INT_NUMBER INT_NUMBER ';' {driver.dsample($2, $3);}
         ;

 rplot : RPLOT tmp_var_list ';' {driver.rplot();}
      ;
 var
 	: VAR var_list ';'
 	;

 varexo
 	: VAREXO varexo_list ';'
	;

 varexo_det
 	: VAREXO_DET varexo_det_list ';'
	;

 parameters
 	: PARAMETERS parameter_list ';'
 	;

 var_list
 	: var_list NAME
 		{ driver.declare_endogenous($2); }
 	| var_list COMMA NAME
 		{ driver.declare_endogenous($3); }
 	| NAME
 		{ driver.declare_endogenous($1); }
 	| var_list NAME TEX_NAME
 		{ driver.declare_endogenous($2, $3); }
 	| var_list COMMA NAME TEX_NAME
 		{ driver.declare_endogenous($3, $4); }
 	| NAME TEX_NAME
 		{ driver.declare_endogenous($1, $2); }
	;

 varexo_list
 	: varexo_list NAME
 		{ driver.declare_exogenous($2); }
 	| varexo_list COMMA NAME
 		{ driver.declare_exogenous($3); }
 	| NAME
 		{ driver.declare_exogenous($1); }
 	| varexo_list NAME TEX_NAME
 		{ driver.declare_exogenous($2, $3); }
 	| varexo_list COMMA NAME TEX_NAME
 		{ driver.declare_exogenous($3, $4); }
 	| NAME TEX_NAME
 		{ driver.declare_exogenous($1, $2); }
	;

 varexo_det_list
 	: varexo_det_list NAME
 		{ driver.declare_exogenous_det($2); }
 	| varexo_det_list COMMA NAME
 		{ driver.declare_exogenous_det($3); }
 	| NAME
 		{ driver.declare_exogenous_det($1); }
 	| varexo_det_list NAME TEX_NAME
 		{ driver.declare_exogenous_det($2, $3); }
 	| varexo_det_list COMMA NAME TEX_NAME
 		{ driver.declare_exogenous_det($3, $4); }
 	| NAME TEX_NAME
 		{ driver.declare_exogenous_det($1, $2); }
	;

 parameter_list
 	: parameter_list NAME
 		{ driver.declare_parameter($2); }
 	| parameter_list COMMA NAME
 		{ driver.declare_parameter($3); }
 	| NAME
 		{ driver.declare_parameter($1); }
 	| parameter_list NAME TEX_NAME
 		{ driver.declare_parameter($2, $3); }
 	| parameter_list COMMA NAME TEX_NAME
 		{ driver.declare_parameter($3, $4); }
 	| NAME TEX_NAME
 		{ driver.declare_parameter($1, $2); }
	;

 periods
 	: PERIODS INT_NUMBER ';'
 		{
      driver.periods($2);
		}
    | PERIODS EQUAL INT_NUMBER ';'
 		{
      driver.periods($3);
		}
    ;

cutoff
 	: CUTOFF FLOAT_NUMBER ';'
 		{
      driver.cutoff($2);
		}
    | CUTOFF EQUAL FLOAT_NUMBER ';'
 		{
      driver.cutoff($3);
		}
    ;

markowitz
 	: MARKOWITZ FLOAT_NUMBER ';'
 		{
      driver.markowitz($2);
		}
    | MARKOWITZ EQUAL FLOAT_NUMBER ';'
 		{
      driver.markowitz($3);
		}
    ;


 init_param
 	: NAME EQUAL expression ';'
    {driver.init_param($1, $3);}
	;

 expression
	: '(' expression ')'
		{ $$ = $2;}
	| NAME
		{$$ = driver.add_expression_variable($1);}
	| FLOAT_NUMBER
		{$$ = driver.add_constant($1);}
	| INT_NUMBER
		{$$ = driver.add_constant($1);}
	| expression PLUS expression
    {$$ = driver.add_plus($1, $3);}
	| expression MINUS expression
    {$$ = driver.add_minus($1, $3);}
	| expression DIVIDE expression
    {$$ = driver.add_divide($1, $3);}
	| expression TIMES expression
    {$$ = driver.add_times($1, $3);}
	| expression POWER expression
    {$$ = driver.add_power($1, $3);}
	| MINUS expression %prec UMINUS
    {$$ = driver.add_uminus($2);}
	| PLUS expression
	  {$$ = $2;}
	| EXP '(' expression ')'
    {$$ = driver.add_exp($3);}
	| LOG '(' expression ')'
    {$$ = driver.add_log($3);}
	| LOG10 '(' expression ')'
    {$$ = driver.add_log10($3);}
	| SIN '(' expression ')'
    {$$ = driver.add_sin($3);}
	| COS '(' expression ')'
    {$$ = driver.add_cos($3);}
	| TAN '(' expression ')'
    {$$ = driver.add_tan($3);}
	| ASIN '(' expression ')'
    {$$ = driver.add_asin($3);}
	| ACOS '(' expression ')'
    {$$ = driver.add_acos($3);}
	| ATAN '(' expression ')'
    {$$ = driver.add_atan($3);}
	| SQRT '(' expression ')'
    {$$ = driver.add_sqrt($3);}
  | NAME '(' comma_expression ')'
    {$$ = driver.add_unknown_function($1);}
	;

 comma_expression :
          expression
          { driver.add_unknown_function_arg($1); }
        | comma_expression COMMA expression
          { driver.add_unknown_function_arg($3); }

 initval
 	: INITVAL ';' initval_list END
 		{driver.end_initval();}
 	|	INITVAL '(' initval_option ')' ';' initval_list END
 		{driver.end_initval();}
 	;

 initval_option
  : FILENAME EQUAL NAME {driver.init_val_filename($3);}
  ;

 endval
 	: ENDVAL ';' initval_list END
 		{driver.end_endval();}
 	;

 initval_list
 	: initval_list initval_elem
	| initval_elem
	;

 initval_elem
 	: NAME EQUAL expression ';'
    {driver.init_val($1, $3);}
 	;

 histval
  : HISTVAL ';' histval_list END
    { driver.end_histval(); }
  ;

 histval_list
 	: histval_list histval_elem
	| histval_elem
	;

 histval_elem
 	: NAME '(' signed_integer ')' EQUAL expression ';'
    {driver.hist_val($1, $3, $6);}
 	;

 model_sparse_options_list : model_sparse_options_list COMMA model_sparse_options
                     | model_sparse_options
                     ;

 model_sparse_options :
      LCC_COMPILER { driver.init_compiler(0); }
    | GCC_COMPILER { driver.init_compiler(1); }
    | o_cutoff
    | o_markowitz
  ;

 model
  : MODEL ';' { driver.begin_model(); } equation_list END { driver.reset_data_tree(); }
 	| MODEL '(' o_linear ')' ';' { driver.begin_model(); }
    equation_list END { driver.reset_data_tree(); }
  | MODEL '(' USE_DLL ')' ';' { driver.begin_model(); driver.use_dll(); }
    equation_list END { driver.reset_data_tree(); }
	| MODEL '(' SPARSE_DLL COMMA model_sparse_options_list ')' { driver.begin_model(); driver.sparse_dll(); } ';'
    equation_list END { driver.reset_data_tree(); }
	| MODEL '(' SPARSE_DLL ')' { driver.begin_model(); driver.sparse_dll(); } ';'
    equation_list END { driver.reset_data_tree(); }
 	;

 equation_list
    : equation_list equation
    | equation_list pound_expression
    | equation
    | pound_expression
    ;

 equation
 	: hand_side EQUAL hand_side ';'
 		{$$ = driver.add_model_equal($1, $3);}
 	| hand_side ';'
 		{$$ = driver.add_model_equal_with_zero_rhs($1);}
	;

 hand_side
	: '(' hand_side ')' {$$ = $2;}
	| model_var
	| FLOAT_NUMBER
		{$$ = driver.add_constant($1);}
	| INT_NUMBER
    {$$ = driver.add_constant($1);}
	| hand_side PLUS hand_side
    	{$$ = driver.add_plus($1, $3);}
	| hand_side MINUS hand_side
    	{$$ = driver.add_minus($1, $3);}
	| hand_side DIVIDE hand_side
    	{$$ = driver.add_divide($1, $3);}
	| hand_side TIMES hand_side
    	{$$ = driver.add_times($1, $3);}
	| hand_side POWER hand_side
    	{$$ = driver.add_power($1, $3);}
        | MINUS hand_side %prec UMINUS
      { $$ = driver.add_uminus($2);}
	| PLUS hand_side
	{$$ = $2;}
	| EXP '(' hand_side ')'
    	{$$ = driver.add_exp($3);}
	| LOG '(' hand_side ')'
    	{$$ = driver.add_log($3);}
	| LOG10 '(' hand_side ')'
    	{$$ = driver.add_log10($3);}
	| SIN '(' hand_side ')'
    	{$$ = driver.add_sin($3);}
	| COS '(' hand_side ')'
    	{$$ = driver.add_cos($3);}
	| TAN '(' hand_side ')'
    	{$$ = driver.add_tan($3);}
	| ASIN '(' hand_side ')'
    	{$$ = driver.add_asin($3);}
	| ACOS '(' hand_side ')'
    	{$$ = driver.add_acos($3);}
	| ATAN '(' hand_side ')'
    	{$$ = driver.add_atan($3);}
	| SQRT '(' hand_side ')'
    	{$$ = driver.add_sqrt($3);}
	;

 pound_expression: '#' NAME EQUAL hand_side ';'
                   {driver.declare_and_init_model_local_variable($2, $4);}

 model_var
 	: NAME
 		{$$ = driver.add_model_variable($1);}
	| NAME '(' signed_integer ')'
		{$$ = driver.add_model_variable($1, $3);}
	;

 shocks
 	: SHOCKS  ';' shock_list END {driver.end_shocks();}
 	;

 mshocks
  : MSHOCKS  ';' shock_list END {driver.end_mshocks();}
 	;

 shock_list
 	: shock_list shock_elem
	| shock_elem
    ;

 shock_elem
	: VAR NAME ';' PERIODS period_list ';' VALUES value_list ';'
		{driver.add_det_shock($2);}
	| VAR NAME ';' STDERR expression ';'
    {driver.add_stderr_shock($2, $5);}
	| VAR NAME EQUAL expression ';'
    {driver.add_var_shock($2, $4);}
	| VAR NAME COMMA NAME EQUAL expression ';'
    {driver.add_covar_shock($2, $4, $6);}
	| CORR NAME COMMA NAME EQUAL expression ';'
    {driver.add_correl_shock($2, $4, $6);}
	;

 period_list
 	: period_list INT_NUMBER
 		{driver.add_period($2);}
	| period_list INT_NUMBER ':' INT_NUMBER
 		{driver.add_period($2,$4);}
        | period_list COMMA INT_NUMBER
 		{driver.add_period($3);}
	| period_list COMMA INT_NUMBER ':' INT_NUMBER
 		{driver.add_period($3, $5);}
	| INT_NUMBER ':' INT_NUMBER
 		{driver.add_period($1, $3);}
	| INT_NUMBER
 		{driver.add_period($1);}
	;


 value_list
 	: value_list signed_float
		{driver.add_value_const($2);}
	| value_list signed_integer
		{driver.add_value_const($2);}
	| value_list NAME
		{driver.add_value_var($2);}
	| signed_float
		{driver.add_value_const($1);}
	| signed_integer
		{driver.add_value_const($1);}
	| NAME
		{driver.add_value_var($1);}
	| value_list '(' expression ')'
    {driver.add_value($3);}
	| '(' expression ')'
    {driver.add_value($2);}
	;

 sigma_e
 	: SIGMA_E EQUAL '[' triangular_matrix ']' ';'
 		{driver.do_sigma_e();}
    ;

 triangular_matrix
 	: triangular_matrix ';' triangular_row
 		{driver.end_of_row();}
    | triangular_row
    	{driver.end_of_row();}
	;

 triangular_row
 	: triangular_row COMMA '(' expression ')'
    {driver.add_to_row($4);}
	| triangular_row COMMA FLOAT_NUMBER
		{driver.add_to_row_const($3);}
	| triangular_row COMMA INT_NUMBER
		{driver.add_to_row_const($3);}
	| triangular_row '(' expression ')'
    {driver.add_to_row($3);}
	| triangular_row FLOAT_NUMBER
		{driver.add_to_row_const($2);}
	| triangular_row INT_NUMBER
		{driver.add_to_row_const($2);}
	| '(' expression ')'
    {driver.add_to_row($2);}
	| FLOAT_NUMBER
		{driver.add_to_row_const($1);}
	| INT_NUMBER
		{driver.add_to_row_const($1);}
	;

 steady
 	: STEADY ';'
 		{
 			driver.steady();
 		}
    | STEADY '(' steady_options_list ')' ';'
    	 {driver.steady();}
    ;

 steady_options_list : steady_options_list COMMA steady_options
                     | steady_options
                     ;

 steady_options: o_solve_algo
               ;

 check
 	: CHECK ';'
 		{driver.check();}
	| CHECK '(' check_options_list ')' ';'
		{driver.check();}
	;

 check_options_list : check_options_list COMMA check_options
        | check_options
        ;

 check_options : o_solve_algo
               ;

 simul
	: SIMUL ';'
		{driver.simulate();}
	| SIMUL '(' simul_options_list ')' ';'
		{driver.simulate();}
        ;

 simul_options_list: simul_options_list COMMA simul_options
                   | simul_options
                   ;

 simul_options: o_periods
              | o_datafile
              ;

 stoch_simul
 	: STOCH_SIMUL ';'
 		{driver.stoch_simul();}
	| STOCH_SIMUL '(' stoch_simul_options_list ')' ';'
		{driver.stoch_simul();}
	| STOCH_SIMUL tmp_var_list ';'
		{driver.stoch_simul();}
	| STOCH_SIMUL '(' stoch_simul_options_list ')' tmp_var_list ';'
		{driver.stoch_simul();}
	;

 stoch_simul_options_list: stoch_simul_options_list COMMA stoch_simul_options
                         | stoch_simul_options
                         ;

 stoch_simul_options : o_dr_algo
                     | o_solve_algo
         	     | o_simul_algo
		     | o_linear
		     | o_order
                     | o_replic
                     | o_drop
                     | o_ar
                     | o_nocorr
                     | o_nofunctions
                     | o_nomoments
                     | o_nograph
                     | o_irf
                     | o_relative_irf
                     | o_hp_filter
                     | o_hp_ngrid
                     | o_periods
                     | o_cutoff
                     | o_simul
                     | o_simul_seed
                     | o_qz_criterium
                     ;

 tmp_var_list
	: tmp_var_list NAME
		{driver.add_tmp_var($2);}
	| tmp_var_list NAME EQUAL NAME
		{driver.add_tmp_var($2, $4);}
	| tmp_var_list COMMA NAME
		{driver.add_tmp_var($3);}
	| tmp_var_list COMMA NAME EQUAL NAME
		{driver.add_tmp_var($3, $5);}
	| NAME
		{driver.add_tmp_var($1);}
	| NAME EQUAL NAME
		{driver.add_tmp_var($1, $3);}
	;

 signed_integer
 	: PLUS INT_NUMBER
 		{$$ = $2;}
 	| MINUS INT_NUMBER
 		{$2->insert(0, "-"); $$ = $2;}
 	| INT_NUMBER
 		{$$ = $1;}
 	;

 signed_float
 	: PLUS FLOAT_NUMBER
 		{$$ = $2;}
 	| MINUS FLOAT_NUMBER
 		{$2->insert(0, "-"); $$ = $2;}
 	| FLOAT_NUMBER
 		{$$ = $1;}
 	;

 estimated_params
	: ESTIMATED_PARAMS ';' estimated_list END
    { driver.estimated_params(); }
	;

 estimated_list
	: estimated_list estimated_elem
		{driver.add_estimated_params_element();}
	| estimated_elem
		{driver.add_estimated_params_element();}
	;

 estimated_elem
	: estimated_elem1 COMMA estimated_elem2 ';'
	;

 estimated_elem1
	: STDERR NAME
		{driver.estim_params.type = 1;
		 driver.estim_params.name = *$2;
     delete $2;
		}
	| NAME
		{driver.estim_params.type = 2;
		 driver.estim_params.name = *$1;
     delete $1;
		}
	| CORR NAME COMMA NAME
		{driver.estim_params.type = 3;
		 driver.estim_params.name = *$2;
		 driver.estim_params.name2 = *$4;
     delete $2;
     delete $4;
		}
	;

 estimated_elem2
	: prior COMMA estimated_elem3
		{
      driver.estim_params.prior=*$1;
      delete $1;
    }
	| value COMMA prior COMMA estimated_elem3
		{driver.estim_params.init_val=*$1;
		 driver.estim_params.prior=*$3;
     delete $1;
     delete $3;
		}
	| value COMMA value COMMA value COMMA prior COMMA estimated_elem3
		{driver.estim_params.init_val=*$1;
		 driver.estim_params.low_bound=*$3;
		 driver.estim_params.up_bound=*$5;
		 driver.estim_params.prior=*$7;
     delete $1;
     delete $3;
     delete $5;
     delete $7;
		}
	| value
		{
      driver.estim_params.init_val=*$1;
      delete $1;
    }
	| value COMMA value COMMA value
		{driver.estim_params.init_val=*$1;
		 driver.estim_params.low_bound=*$3;
		 driver.estim_params.up_bound=*$5;
     delete $1;
     delete $3;
     delete $5;
		}
	;

 estimated_elem3
 	: value COMMA value
 		{driver.estim_params.mean=*$1;
 		 driver.estim_params.std=*$3;
     delete $1;
     delete $3;
 		}
	| value COMMA value COMMA value
		{driver.estim_params.mean=*$1;
		 driver.estim_params.std=*$3;
		 driver.estim_params.p3=*$5;
     delete $1;
     delete $3;
     delete $5;
		}
	| value COMMA value COMMA value COMMA value
		{driver.estim_params.mean=*$1;
		 driver.estim_params.std=*$3;
		 driver.estim_params.p3=*$5;
		 driver.estim_params.p4=*$7;
     delete $1;
     delete $3;
     delete $5;
     delete $7;
		}
	| value COMMA value COMMA value COMMA value COMMA value
		{driver.estim_params.mean=*$1;
		 driver.estim_params.std=*$3;
		 driver.estim_params.p3=*$5;
		 driver.estim_params.p4=*$7;
		 driver.estim_params.jscale=*$9;
     delete $1;
     delete $3;
     delete $5;
     delete $7;
     delete $9;
		}
	;

 estimated_params_init: ESTIMATED_PARAMS_INIT ';' estimated_init_list END
                        { driver.estimated_params_init(); }
                      ;

 estimated_init_list : estimated_init_list estimated_init_elem
                       {driver.add_estimated_params_element();}
                     | estimated_init_elem
                       {driver.add_estimated_params_element();}
                     ;

 estimated_init_elem : STDERR NAME COMMA value ';'
 		     		{driver.estim_params.type = 1;
				 driver.estim_params.name = *$2;
				 driver.estim_params.init_val=*$4;
         delete $2;
         delete $4;
				}
                     | CORR NAME COMMA NAME COMMA value ';'
 		     		{driver.estim_params.type = 3;
				 driver.estim_params.name = *$2;
				 driver.estim_params.name2 = *$4;
				 driver.estim_params.init_val=*$6;
         delete $2;
         delete $4;
         delete $6;
				}
                     | NAME COMMA value ';'
 		     		{driver.estim_params.type = 2;
				 driver.estim_params.name = *$1;
				 driver.estim_params.init_val=*$3;
         delete $1;
         delete $3;
				}
                     ;

 estimated_params_bounds: ESTIMATED_PARAMS_BOUNDS ';' estimated_bounds_list END
                          { driver.estimated_params_bounds(); }
                      ;

 estimated_bounds_list : estimated_bounds_list estimated_bounds_elem
                       {driver.add_estimated_params_element();}
                     | estimated_bounds_elem
                       {driver.add_estimated_params_element();}
                     ;

 estimated_bounds_elem : STDERR NAME COMMA value COMMA value ';'
 		     		{driver.estim_params.type = 1;
				 driver.estim_params.name = *$2;
				 driver.estim_params.low_bound=*$4;
				 driver.estim_params.up_bound=*$6;
         delete $2;
         delete $4;
         delete $6;
				}
                     | CORR NAME COMMA NAME COMMA value COMMA value ';'
 		     		{driver.estim_params.type = 3;
				 driver.estim_params.name = *$2;
				 driver.estim_params.name2 = *$4;
				 driver.estim_params.low_bound=*$6;
				 driver.estim_params.up_bound=*$8;
         delete $2;
         delete $4;
         delete $6;
         delete $8;
				}
                     | NAME COMMA value COMMA value ';'
 		     		{driver.estim_params.type = 2;
				 driver.estim_params.name = *$1;
				 driver.estim_params.low_bound=*$3;
				 driver.estim_params.up_bound=*$5;
         delete $1;
         delete $3;
         delete $5;
				}
                     ;

 prior
	: BETA_PDF
    {$$ = new string("1");}
	| GAMMA_PDF
    {$$ = new string("2");}
	| NORMAL_PDF
    {$$ = new string("3");}
	| INV_GAMMA_PDF
    {$$ = new string("4");}
	| UNIFORM_PDF
    {$$ = new string("5");}
	;

 value
  : {$$ = new string("NaN");}
  | INT_NUMBER
	| FLOAT_NUMBER
	| NAME
  | MINUS INT_NUMBER
    {$2->insert(0, "-"); $$ = $2;}
  | MINUS FLOAT_NUMBER
    {$2->insert(0, "-"); $$ = $2;}
	;



 estimation
	: ESTIMATION ';'
		{driver.run_estimation();}
	| ESTIMATION '(' estimation_options_list ')' ';'
		{driver.run_estimation();}
	| ESTIMATION tmp_var_list ';'
		{driver.run_estimation();}
	| ESTIMATION '(' estimation_options_list ')' tmp_var_list ';'
		{driver.run_estimation();}
	;

 estimation_options_list
	: estimation_options_list COMMA estimation_options
	| estimation_options
	;

 estimation_options : o_datafile
                   | o_nobs
                   | o_first_obs
                   | o_prefilter
                   | o_presample
                   | o_lik_algo
                   | o_lik_init
                   | o_nograph
                   | o_conf_sig
                   | o_mh_replic
                   | o_mh_drop
                   | o_mh_jscale
                   | o_optim
                   | o_mh_init_scale
                   | o_mode_file
                   | o_mode_compute
                   | o_mode_check
                   | o_prior_trunc
                   | o_mh_mode
                   | o_mh_nblcks
                   | o_load_mh_file
                   | o_loglinear
                   | o_nodiagnostic
                   | o_bayesian_irf
                   | o_irf
                   | o_tex
                   | o_forecast
                   | o_smoother
                   | o_moments_varendo
                   | o_filtered_vars
                   | o_kalman_algo
                   | o_kalman_tol
                   | o_xls_sheet
                   | o_xls_range
                   | o_filter_step_ahead
                   | o_solve_algo
                   | o_constant
                   | o_noconstant
                   | o_mh_recover
                   ;

 prior_analysis
	: PRIOR_ANALYSIS '(' prior_posterior_options_list ')' ';'
                {driver.run_prior_analysis();}
	| PRIOR_ANALYSIS '(' prior_posterior_options_list ')' tmp_var_list ';'
                {driver.run_prior_analysis();}
	;

 prior_posterior_options_list
	: prior_posterior_options_list COMMA prior_posterior_options
	| prior_posterior_options
	;

 prior_posterior_options
                   : o_nograph
                   | o_conf_sig
                   | o_prior_trunc
                   | o_bayesian_irf
                   | o_irf
                   | o_tex
                   | o_forecast
                   | o_smoother
                   | o_moments_varendo
                   | o_filtered_vars
                   | o_xls_sheet
                   | o_xls_range
                   | o_filter_step_ahead
                   ;

 posterior_analysis
	: POSTERIOR_ANALYSIS '(' prior_posterior_options_list ')' ';'
		{driver.run_posterior_analysis();}
	| POSTERIOR_ANALYSIS '(' prior_posterior_options_list ')' tmp_var_list ';'
		{driver.run_posterior_analysis();}
	;

 list_optim_option
 	: '\'' NAME '\'' COMMA '\'' NAME '\'' {driver.optim_options_string($2, $6);}
	| '\'' NAME '\'' COMMA value {driver.optim_options_num($2, $5);}
	;

 optim_options
	: list_optim_option
	| optim_options COMMA list_optim_option;
	;

 varobs
 	: VAROBS tmp_var_list ';'
 		{driver.set_varobs();}
	;

 observation_trends
        : OBSERVATION_TRENDS ';' trend_list END
{ driver.set_trends(); }
	;

 trend_list
        : trend_list trend_element
	| trend_element
	;

 trend_element :  NAME '(' expression ')' ';'
{driver.set_trend_element($1, $3);}
               ;

 unit_root_vars : UNIT_ROOT_VARS tmp_var_list ';' {driver.set_unit_root_vars();}
                ;

 optim_weights : OPTIM_WEIGHTS ';' optim_weights_list END
                 { driver.optim_weights(); }
               ;

 optim_weights_list : optim_weights_list NAME expression ';'
                      {driver.set_optim_weights($2, $3);}
                    | optim_weights_list NAME COMMA NAME expression ';'
                      {driver.set_optim_weights($2, $4, $5);}
                    | NAME expression ';'
                      {driver.set_optim_weights($1, $2);}
                    | NAME COMMA NAME expression ';'
                      {driver.set_optim_weights($1, $3, $4);}
                    ;

 osr_params : OSR_PARAMS tmp_var_list ';' {driver.set_osr_params();}
            ;

 osr : OSR ';' {driver.run_osr();}
     | OSR '(' olr_options ')' ';' {driver.run_osr();}
     | OSR tmp_var_list ';' {driver.run_osr();}
     | OSR '(' olr_options ')' tmp_var_list ';' {driver.run_osr();}
     ;

 olr : OLR ';' {driver.run_olr();}
     | OLR '(' olr_options ')' ';' {driver.run_olr();}
     | OLR tmp_var_list ';' {driver.run_olr();}
     | OLR '(' olr_options ')' tmp_var_list ';' {driver.run_olr();}
     ;

 olr_option : o_olr_beta
     | stoch_simul_options
     ;

 olr_options : olr_option
     | olr_options COMMA olr_option
     ;

 olr_inst : OLR_INST tmp_var_list ';' {driver.set_olr_inst();}
          ;

 calib_var : CALIB_VAR ';' calib_var_list END
             { driver.run_calib_var(); }
           ;

 calib_var_list : calib_var_list calib_arg1
                | calib_arg1
                ;

 calib_arg1 : NAME calib_arg2 EQUAL expression ';' {driver.set_calib_var($1, $2, $4);}
            | NAME COMMA NAME calib_arg2 EQUAL expression ';' {driver.set_calib_covar($1, $3, $4, $6);}
            | AUTOCORR NAME '(' INT_NUMBER ')' calib_arg2 EQUAL expression ';' {driver.set_calib_ac($2, $4, $6, $8);}
            ;

 calib_arg2 : { $$ = new string("1"); }
            | '(' INT_NUMBER ')' {$$ = $2;}
            | '(' FLOAT_NUMBER ')' {$$ = $2;}
            ;

 calib : CALIB ';' {driver.run_calib(0);}
       | CALIB '(' COVAR ')' ';' {driver.run_calib(1);}
       ;

 dynatype : DYNATYPE '(' NAME ')'';' {driver.run_dynatype($3);}
          | DYNATYPE '(' NAME ')' tmp_var_list ';' {driver.run_dynatype($3);}
          | DYNATYPE NAME ';' {driver.run_dynatype($2);}
          | DYNATYPE '(' NAME '.' NAME ')'';' {driver.run_dynatype($3, $5);}
          | DYNATYPE '(' NAME '.' NAME ')' tmp_var_list ';' {driver.run_dynatype($3, $5);}
          | DYNATYPE NAME '.' NAME ';' {driver.run_dynatype($2,$4);};

 dynasave : DYNASAVE '(' NAME ')'';' {driver.run_dynasave($3);}
          | DYNASAVE '(' NAME ')' tmp_var_list ';' {driver.run_dynasave($3);}
          | DYNASAVE NAME ';' {driver.run_dynasave($2);}
          | DYNASAVE '(' NAME '.' NAME ')'';' {driver.run_dynasave($3, $5);}
          | DYNASAVE '(' NAME '.' NAME ')' tmp_var_list ';' {driver.run_dynasave($3, $5);}
          | DYNASAVE NAME '.' NAME ';' {driver.run_dynasave($2, $4);};

 model_comparison : MODEL_COMPARISON '(' model_comparison_options ')' filename_list ';'
                    {driver.run_model_comparison();}
                  ;

 model_comparison_options: model_comparison_options COMMA model_comparison_option
              | model_comparison_option
              ;

 model_comparison_option : o_model_comparison_approximation
              | o_print
              | o_noprint
              ;

 filename_list : filename {driver.add_mc_filename($1);}
        | filename_list COMMA filename {driver.add_mc_filename($3);}
	| filename '(' value ')' {driver.add_mc_filename($1, $3);}
        | filename_list COMMA filename '(' value ')' {driver.add_mc_filename($3, $5);}
        ;

 filename : filename_elem {$$ = $1;}
          | filename filename_elem {$1->append(*$2); delete $2; $$ = $1;}
        ;

 filename_elem : NAME
               | '\\' { $$ = new string("\\"); }
               | DIVIDE { $$ = new string("/"); }
               | ':' { $$ = new string(":"); }
               | '.' { $$ = new string("."); }
               ;

 planner_objective : PLANNER_OBJECTIVE { driver.begin_planner_objective(); } hand_side { driver.end_planner_objective($3); } ';'
               ;

 ramsey_policy : RAMSEY_POLICY ';'
 		{driver.ramsey_policy();}
	| RAMSEY_POLICY '(' ramsey_policy_options_list ')' ';'
		{driver.ramsey_policy();}
	| RAMSEY_POLICY tmp_var_list ';'
		{driver.ramsey_policy();}
	| RAMSEY_POLICY '(' ramsey_policy_options_list ')' tmp_var_list ';'
		{driver.ramsey_policy();}
	;

 ramsey_policy_options_list :
          ramsey_policy_options_list COMMA ramsey_policy_options
        | ramsey_policy_options
	;

 ramsey_policy_options : stoch_simul_options
        | o_planner_discount
        ;

 bvar_prior_option : o_bvar_prior_tau
                   | o_bvar_prior_decay
                   | o_bvar_prior_lambda
                   | o_bvar_prior_mu
                   | o_bvar_prior_omega
                   | o_bvar_prior_flat
                   | o_bvar_prior_train
                   ;

 bvar_common_option : bvar_prior_option
                    | o_datafile
                    | o_xls_sheet
                    | o_xls_range
                    | o_first_obs
                    | o_presample
                    | o_nobs
                    | o_prefilter
                    ;

 bvar_density_options_list : bvar_common_option COMMA bvar_density_options_list
                           | bvar_common_option
                           ;

 bvar_density : BVAR_DENSITY INT_NUMBER ';'
                { driver.bvar_density($2); }
              | BVAR_DENSITY '(' bvar_density_options_list ')' INT_NUMBER ';'
                { driver.bvar_density($5); }
              ;
 
 bvar_forecast_option : bvar_common_option
                      | o_forecast
                      | o_conf_sig
                      | o_bvar_replic
                      ;

 bvar_forecast_options_list : bvar_forecast_option COMMA bvar_forecast_options_list
                            | bvar_forecast_option
                            ;

 bvar_forecast : BVAR_FORECAST INT_NUMBER ';'
                 { driver.bvar_forecast($2); }
               | BVAR_FORECAST '(' bvar_forecast_options_list ')' INT_NUMBER ';'
                 { driver.bvar_forecast($5); }
               ;

 o_dr_algo: DR_ALGO EQUAL INT_NUMBER {driver.option_num("dr_algo", $3);};
 o_solve_algo: SOLVE_ALGO EQUAL INT_NUMBER {driver.option_num("solve_algo", $3);};
 o_simul_algo: SIMUL_ALGO EQUAL INT_NUMBER {driver.option_num("simul_algo", $3);};
 o_linear: LINEAR {driver.linear();};
 o_order: ORDER EQUAL INT_NUMBER {driver.option_num("order", $3);};
 o_replic: REPLIC EQUAL INT_NUMBER {driver.option_num("replic", $3);};
 o_drop: DROP EQUAL INT_NUMBER {driver.option_num("drop", $3);};
 o_ar: AR EQUAL INT_NUMBER {driver.option_num("ar", $3);};
 o_nocorr: NOCORR {driver.option_num("nocorr", "1");};
 o_nofunctions: NOFUNCTIONS {driver.option_num("nofunctions", "1");};
 o_nomoments: NOMOMENTS {driver.option_num("nomoments", "1");};
 o_irf: IRF EQUAL INT_NUMBER {driver.option_num("irf", $3);};
 o_hp_filter: HP_FILTER EQUAL INT_NUMBER {driver.option_num("hp_filter", $3);};
 o_hp_ngrid: HP_NGRID EQUAL INT_NUMBER {driver.option_num("hp_ngrid", $3);};
 o_periods: PERIODS EQUAL INT_NUMBER {driver.option_num("periods", $3); driver.option_num("simul", "1");};
 o_cutoff: CUTOFF EQUAL FLOAT_NUMBER {driver.option_num("cutoff", $3);}
 o_markowitz: MARKOWITZ EQUAL FLOAT_NUMBER {driver.option_num("markowitz", $3);}
 o_simul: SIMUL {driver.option_num("simul", "1");};
 o_simul_seed: SIMUL_SEED EQUAL INT_NUMBER { driver.option_num("simul_seed", $3)};
 o_qz_criterium: QZ_CRITERIUM EQUAL INT_NUMBER { driver.option_num("qz_criterium", $3)}
               | QZ_CRITERIUM EQUAL FLOAT_NUMBER { driver.option_num("qz_criterium", $3)}
               ;
 o_datafile: DATAFILE EQUAL NAME {driver.option_str("datafile", $3);};
 o_nobs: NOBS EQUAL vec_int {driver.option_num("nobs", $3);}
       | NOBS EQUAL INT_NUMBER {driver.option_num("nobs", $3);}
       ;
 o_first_obs: FIRST_OBS EQUAL INT_NUMBER {driver.option_num("first_obs", $3);};
 o_prefilter: PREFILTER EQUAL INT_NUMBER {driver.option_num("prefilter", $3);};
 o_presample: PRESAMPLE EQUAL INT_NUMBER {driver.option_num("presample", $3);};
 o_lik_algo: LIK_ALGO EQUAL INT_NUMBER {driver.option_num("lik_algo", $3);};
 o_lik_init: LIK_INIT EQUAL INT_NUMBER {driver.option_num("lik_init", $3);};
 o_nograph: NOGRAPH {driver.option_num("nograph","1");};
          | GRAPH {driver.option_num("nograph", "0");};
 o_conf_sig: CONF_SIG EQUAL FLOAT_NUMBER {driver.option_num("conf_sig", $3);};
 o_mh_replic: MH_REPLIC EQUAL INT_NUMBER {driver.option_num("mh_replic", $3);};
 o_mh_drop: MH_DROP EQUAL FLOAT_NUMBER {driver.option_num("mh_drop", $3);};
 o_mh_jscale: MH_JSCALE EQUAL FLOAT_NUMBER {driver.option_num("mh_jscale", $3);};
 o_optim: OPTIM  EQUAL '(' optim_options ')';
 o_mh_init_scale: MH_INIT_SCALE EQUAL FLOAT_NUMBER {driver.option_num("mh_init_scale", $3);};
                | MH_INIT_SCALE EQUAL INT_NUMBER {driver.option_num("mh_init_scale", $3);};
 o_mode_file : MODE_FILE EQUAL NAME {driver.option_str("mode_file", $3);};
 o_mode_compute : MODE_COMPUTE EQUAL INT_NUMBER {driver.option_num("mode_compute", $3);};
 o_mode_check : MODE_CHECK {driver.option_num("mode_check", "1");};
 o_prior_trunc : PRIOR_TRUNC EQUAL FLOAT_NUMBER {driver.option_num("prior_trunc", $3);};
 o_mh_mode : MH_MODE EQUAL INT_NUMBER {driver.option_num("mh_mode", $3);};
 o_mh_nblcks : MH_NBLOCKS EQUAL INT_NUMBER {driver.option_num("mh_nblck", $3);};
 o_load_mh_file : LOAD_MH_FILE {driver.option_num("load_mh_file", "1");};
 o_loglinear : LOGLINEAR {driver.option_num("loglinear", "1");};
 o_nodiagnostic : NODIAGNOSTIC {driver.option_num("nodiagnostic", "1");};
 o_bayesian_irf : BAYESIAN_IRF {driver.option_num("bayesian_irf", "1");};
 o_tex : TEX {driver.option_num("TeX", "1");};
 o_forecast : FORECAST EQUAL INT_NUMBER {driver.option_num("forecast", $3);};
 o_smoother : SMOOTHER {driver.option_num("smoother", "1");};
 o_moments_varendo : MOMENTS_VARENDO {driver.option_num("moments_varendo", "1");};
 o_filtered_vars : FILTERED_VARS {driver.option_num("filtered_vars", "1");};
 o_relative_irf : RELATIVE_IRF {driver.option_num("relative_irf", "1");};
 o_kalman_algo : KALMAN_ALGO EQUAL INT_NUMBER {driver.option_num("kalman_algo", $3);};
 o_kalman_tol : KALMAN_TOL EQUAL INT_NUMBER {driver.option_num("kalman_tol", $3);};
 o_olr_beta: OLR_BETA EQUAL value {driver.option_num("olr_beta", $3);};
 o_model_comparison_approximation:
     MODEL_COMPARISON_APPROXIMATION EQUAL LAPLACE
     { driver.option_str("model_comparison_approximation", "Laplace"); }
   | MODEL_COMPARISON_APPROXIMATION EQUAL MODIFIEDHARMONICMEAN
     { driver.option_str("model_comparison_approximation", "MODIFIEDHARMONICMEAN"); }
   ;
 o_print : PRINT {driver.option_num("noprint", "0");};
 o_noprint : NOPRINT {driver.option_num("noprint", "1");};
 o_xls_sheet : XLS_SHEET EQUAL NAME {driver.option_str("xls_sheet", $3);}
 o_xls_range : XLS_RANGE EQUAL range {driver.option_str("xls_range", $3);}
 o_filter_step_ahead : FILTER_STEP_AHEAD EQUAL vec_int {driver.option_num("filter_step_ahead", $3);}
 o_constant : CONSTANT {driver.option_num("noconstant", "0");}
 o_noconstant : NOCONSTANT {driver.option_num("noconstant", "1");}
 o_mh_recover : MH_RECOVER {driver.option_num("load_mh_file", "-1");}
 o_planner_discount : PLANNER_DISCOUNT EQUAL FLOAT_NUMBER {driver.option_num("planner_discount",$3);}

 o_bvar_prior_tau : BVAR_PRIOR_TAU EQUAL signed_float { driver.option_num("bvar_prior_tau", $3); }
 o_bvar_prior_decay : BVAR_PRIOR_DECAY EQUAL FLOAT_NUMBER { driver.option_num("bvar_prior_decay", $3); }
 o_bvar_prior_lambda : BVAR_PRIOR_LAMBDA EQUAL signed_float { driver.option_num("bvar_prior_lambda", $3); }
 o_bvar_prior_mu : BVAR_PRIOR_MU EQUAL FLOAT_NUMBER { driver.option_num("bvar_prior_mu", $3); }
 o_bvar_prior_omega : BVAR_PRIOR_OMEGA EQUAL INT_NUMBER { driver.option_num("bvar_prior_omega", $3); }
 o_bvar_prior_flat : BVAR_PRIOR_FLAT { driver.option_num("bvar_prior_flat", "1"); }
 o_bvar_prior_train : BVAR_PRIOR_TRAIN EQUAL INT_NUMBER { driver.option_num("bvar_prior_train", $3); }
 o_bvar_replic : BVAR_REPLIC EQUAL INT_NUMBER { driver.option_num("bvar_replic", $3); }

 range : NAME ':' NAME
  {
    $1->append(":");
    $1->append(*$3);
    delete $3;
    $$ = $1;
  }

 vec_int_elem : INT_NUMBER
              | INT_NUMBER ':' INT_NUMBER
                { $1->append(":"); $1->append(*$3); delete $3; $$ = $1; }
	            ;

 vec_int_1 : '[' vec_int_elem { $2->insert(0, "["); $$ = $2;}
           | vec_int_1 vec_int_elem
             {
               $1->append(" ");
               $1->append(*$2);
               delete $2;
               $$ = $1;
             }
           ;

 vec_int : vec_int_1 ']' { $1->append("]"); $$ = $1; };

%%

void
yy::parser::error(const yy::parser::location_type &l,
                  const string &m)
{
  driver.error(l, m);
}

/*
  Local variables:
  mode: C++
  End:
*/