diff --git a/parser.src/ComputingTasks.cc b/parser.src/ComputingTasks.cc index fd7e3e5eb..8e375181e 100644 --- a/parser.src/ComputingTasks.cc +++ b/parser.src/ComputingTasks.cc @@ -13,7 +13,7 @@ using namespace std; //------------------------------------------------------------------------------ //ostringstream ComputingTasks::output; //------------------------------------------------------------------------------ -ComputingTasks::ComputingTasks() +ComputingTasks::ComputingTasks(const SymbolTable &symbol_table_arg) : symbol_table(symbol_table_arg) { // Empty } @@ -120,8 +120,8 @@ void ComputingTasks::setEstimationInit(void) //------------------------------------------------------------------------------ void ComputingTasks::setOptimOptions(string str1, string str2, int task) { - static string optim_string; - static int start; + string optim_string; + int start; switch(task) { case 1: @@ -160,12 +160,12 @@ void ComputingTasks::setOptimOptions(string str1, string str2, int task) //------------------------------------------------------------------------------ void ComputingTasks::setEstimatedElements(void) { - if (!SymbolTable::Exist(EstimParams->name)) + if (!symbol_table.Exist(EstimParams->name)) { string msg = "Unknown symbol: "+EstimParams->name; error(msg.c_str()); } - if (SymbolTable::isReferenced(EstimParams->name) == eNotReferenced & EstimParams->name != "dsge_prior_weight") + if (symbol_table.isReferenced(EstimParams->name) == eNotReferenced & EstimParams->name != "dsge_prior_weight") { return; } @@ -176,31 +176,31 @@ void ComputingTasks::setEstimatedElements(void) switch(EstimParams->type) { case 1: - if( SymbolTable::getType(EstimParams->name) == eExogenous) + if (symbol_table.getType(EstimParams->name) == eExogenous) { *output << "estim_params_.var_exo = [estim_params_.var_exo; "; } - else if ( SymbolTable::getType(EstimParams->name) == eEndogenous) + else if (symbol_table.getType(EstimParams->name) == eEndogenous) { *output << "estim_params_.var_endo = [estim_params_.var_endo; "; } - *output << SymbolTable::getID(EstimParams->name)+1; + *output << symbol_table.getID(EstimParams->name)+1; break; case 2: *output << "estim_params_.param_vals = [estim_params_.param_vals; "; - *output << SymbolTable::getID(EstimParams->name)+1; + *output << symbol_table.getID(EstimParams->name)+1; break; case 3: - if( SymbolTable::getType(EstimParams->name) == eExogenous) + if (symbol_table.getType(EstimParams->name) == eExogenous) { *output << "estim_params_.corrx = [estim_params_.corrx; "; } - else if ( SymbolTable::getType(EstimParams->name) == eEndogenous) + else if (symbol_table.getType(EstimParams->name) == eEndogenous) { *output << "estim_params_.corrn = [estim_params_.corrn; "; } - *output << SymbolTable::getID(EstimParams->name)+1; - *output << " " << SymbolTable::getID(EstimParams->name2)+1; + *output << symbol_table.getID(EstimParams->name)+1; + *output << " " << symbol_table.getID(EstimParams->name2)+1; break; } *output << " " << EstimParams->init_val << " " << EstimParams->low_bound << " " << @@ -213,12 +213,12 @@ void ComputingTasks::setEstimatedElements(void) //------------------------------------------------------------------------------ void ComputingTasks::setEstimatedInitElements(void) { - if (!SymbolTable::Exist(EstimParams->name)) + if (!symbol_table.Exist(EstimParams->name)) { string msg = "Unknown symbol: "+EstimParams->name; error(msg.c_str()); } - if (SymbolTable::isReferenced(EstimParams->name) == eNotReferenced) + if (symbol_table.isReferenced(EstimParams->name) == eNotReferenced) { return; } @@ -228,32 +228,32 @@ void ComputingTasks::setEstimatedInitElements(void) } if (EstimParams->type < 3) { - if( SymbolTable::getType(EstimParams->name) == eExogenous) + if (symbol_table.getType(EstimParams->name) == eExogenous) { - *output << "tmp1 = find(estim_params_.var_exo(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ");\n"; + *output << "tmp1 = find(estim_params_.var_exo(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ");\n"; *output << "estim_params_.var_exo(tmp1,2) = " << EstimParams->init_val << ";\n"; } - else if ( SymbolTable::getType(EstimParams->name) == eEndogenous) + else if (symbol_table.getType(EstimParams->name) == eEndogenous) { - *output << "tmp1 = find(estim_params_.var_endo(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ");\n"; + *output << "tmp1 = find(estim_params_.var_endo(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ");\n"; *output << "estim_params_.var_endo(tmp1,2) = " << EstimParams->init_val << ";\n"; } - else if ( SymbolTable::getType(EstimParams->name) == eParameter) + else if (symbol_table.getType(EstimParams->name) == eParameter) { - *output << "tmp1 = find(estim_params_.param_vals(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ");\n"; + *output << "tmp1 = find(estim_params_.param_vals(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ");\n"; *output << "estim_params_.param_vals(tmp1,2) = " << EstimParams->init_val << ";\n"; } } else { - if( SymbolTable::getType(EstimParams->name) == eExogenous) + if (symbol_table.getType(EstimParams->name) == eExogenous) { - *output << "tmp1 = find((estim_params_.corrx(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ")) & (estim_params_.corrx(:,2)==SymbolTable::getID(EstimParams->name2)+1);\n"; + *output << "tmp1 = find((estim_params_.corrx(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ")) & (estim_params_.corrx(:,2)==" << symbol_table.getID(EstimParams->name2)+1 << ");\n"; *output << "estim_params_.corrx(tmp1,3) = " << EstimParams->init_val << ";\n"; } - else if ( SymbolTable::getType(EstimParams->name) == eEndogenous) + else if (symbol_table.getType(EstimParams->name) == eEndogenous) { - *output << "tmp1 = find((estim_params_.corrn(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ")) & (estim_params_.corrn(:,2)==" << SymbolTable::getID(EstimParams->name2)+1 << ";\n"; + *output << "tmp1 = find((estim_params_.corrn(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ")) & (estim_params_.corrn(:,2)==" << symbol_table.getID(EstimParams->name2)+1 << ";\n"; *output << "estim_params_.corrx(tmp1,3) = " << EstimParams->init_val << ";\n"; } } @@ -263,12 +263,12 @@ void ComputingTasks::setEstimatedInitElements(void) //------------------------------------------------------------------------------ void ComputingTasks::setEstimatedBoundsElements(void) { - if (!SymbolTable::Exist(EstimParams->name)) + if (!symbol_table.Exist(EstimParams->name)) { string msg = "Unknown symbol: "+EstimParams->name; error(msg.c_str()); } - if (SymbolTable::isReferenced(EstimParams->name) == eNotReferenced) + if (symbol_table.isReferenced(EstimParams->name) == eNotReferenced) { return; } @@ -278,36 +278,36 @@ void ComputingTasks::setEstimatedBoundsElements(void) } if (EstimParams->type < 3) { - if( SymbolTable::getType(EstimParams->name) == eExogenous) + if (symbol_table.getType(EstimParams->name) == eExogenous) { - *output << "tmp1 = find(estim_params_.var_exo(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ");\n"; + *output << "tmp1 = find(estim_params_.var_exo(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ");\n"; *output << "estim_params_.var_exo(tmp1,3) = " << EstimParams->low_bound << ";\n"; *output << "estim_params_.var_exo(tmp1,4) = " << EstimParams->up_bound << ";\n"; } - else if ( SymbolTable::getType(EstimParams->name) == eEndogenous) + else if (symbol_table.getType(EstimParams->name) == eEndogenous) { - *output << "tmp1 = find(estim_params_.var_endo(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ");\n"; + *output << "tmp1 = find(estim_params_.var_endo(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ");\n"; *output << "estim_params_.var_endo(tmp1,3) = " << EstimParams->low_bound << ";\n"; *output << "estim_params_.var_endo(tmp1,4) = " << EstimParams->up_bound << ";\n"; } - else if ( SymbolTable::getType(EstimParams->name) == eParameter) + else if (symbol_table.getType(EstimParams->name) == eParameter) { - *output << "tmp1 = find(estim_params_.param_vals(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ");\n"; + *output << "tmp1 = find(estim_params_.param_vals(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ");\n"; *output << "estim_params_.param_vals(tmp1,3) = " << EstimParams->low_bound << ";\n"; *output << "estim_params_.param_vals(tmp1,4) = " << EstimParams->up_bound << ";\n"; } } else { - if( SymbolTable::getType(EstimParams->name) == eExogenous) + if (symbol_table.getType(EstimParams->name) == eExogenous) { - *output << "tmp1 = find((estim_params_.corrx(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ")) & (estim_params_.corrx(:,2)==SymbolTable::getID(EstimParams->name2)+1);\n"; + *output << "tmp1 = find((estim_params_.corrx(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ")) & (estim_params_.corrx(:,2)==" << symbol_table.getID(EstimParams->name2)+1 << ");\n"; *output << "estim_params_.corrx(tmp1,4) = " << EstimParams->low_bound << ";\n"; *output << "estim_params_.corrx(tmp1,5) = " << EstimParams->up_bound << ";\n"; } - else if ( SymbolTable::getType(EstimParams->name) == eEndogenous) + else if (symbol_table.getType(EstimParams->name) == eEndogenous) { - *output << "tmp1 = find((estim_params_.corrn(:,1)==" << SymbolTable::getID(EstimParams->name)+1 << ")) & (estim_params_.corrn(:,2)==" << SymbolTable::getID(EstimParams->name2)+1 << ";\n"; + *output << "tmp1 = find((estim_params_.corrn(:,1)==" << symbol_table.getID(EstimParams->name)+1 << ")) & (estim_params_.corrn(:,2)==" << symbol_table.getID(EstimParams->name2)+1 << ";\n"; *output << "estim_params_.corrx(tmp1,4) = " << EstimParams->low_bound << ";\n"; *output << "estim_params_.corrx(tmp1,5) = " << EstimParams->up_bound << ";\n"; } @@ -319,13 +319,13 @@ void ComputingTasks::setEstimatedBoundsElements(void) void ComputingTasks::set_trend_element (string name, string expression) { //Testing if symbol exists - if (!SymbolTable::Exist(name)) + if (!symbol_table.Exist(name)) { string msg = "Unknown variable: " + name; (* error) (msg.c_str()); } - Type type = SymbolTable::getType(name); - // int id = SymbolTable::getID(name); + Type type = symbol_table.getType(name); + // int id = symbol_table.getID(name); if (type == eEndogenous) { *output << "tmp1 = strmatch('" << name << "',options_.varobs,'exact');\n"; @@ -354,19 +354,19 @@ void ComputingTasks::BeginCalibVar(void) //------------------------------------------------------------------------------ void ComputingTasks::setCalibVar(string name, string weight, string expression) { - if (!SymbolTable::Exist(name)) + if (!symbol_table.Exist(name)) { string msg = "calib_var: " + name + " doesn't exist"; error(msg.c_str()); } - int id = SymbolTable::getID(name)+1; - if (SymbolTable::getType(name) == eEndogenous) + int id = symbol_table.getID(name) + 1; + if (symbol_table.getType(name) == eEndogenous) { *output << "calib_var_index{1} = [calib_var_index{1};" << id << "," << id << "];\n"; *output << "calib_weights{1} = [calib_weights{1}; " << weight << "];\n"; *output << "calib_targets{1} =[calib_targets{1}; " << expression << "];\n"; } - else if (SymbolTable::getType(name) == eExogenous) + else if (symbol_table.getType(name) == eExogenous) { *output << "calib_var_index{3} = [calib_var_index{3};" << id << "," << id << "];\n"; *output << "calib_weights{3} = [calib_weights{3}; " << weight << "];\n"; @@ -382,30 +382,30 @@ void ComputingTasks::setCalibVar(string name, string weight, string expression) //------------------------------------------------------------------------------ void ComputingTasks::setCalibVar(string name1, string name2, string weight, string expression) { - if (!SymbolTable::Exist(name1)) + if (!symbol_table.Exist(name1)) { string msg = "calib_var: " + name1 + " doesn't exist"; error(msg.c_str()); } - if (!SymbolTable::Exist(name2)) + if (!symbol_table.Exist(name2)) { string msg = "calib_var: " + name2 + " doesn't exist"; error(msg.c_str()); } - if (SymbolTable::getType(name1) != SymbolTable::getType(name2)) + if (symbol_table.getType(name1) != symbol_table.getType(name2)) { string msg = "calib_var: " + name1 + " and " + name2 + " don't have the same type"; error(msg.c_str()); } - int id1 = SymbolTable::getID(name1)+1; - int id2 = SymbolTable::getID(name2)+1; - if (SymbolTable::getType(name1) == eEndogenous) + int id1 = symbol_table.getID(name1) + 1; + int id2 = symbol_table.getID(name2) + 1; + if (symbol_table.getType(name1) == eEndogenous) { *output << "calib_var_index{1} = [calib_var_index{1};" << id1 << "," << id2 << "];\n"; *output << "calib_weights{1} = [calib_weights{1}; " << weight << "];\n"; *output << "calib_targets{1} =[calib_targets{1}; " << expression << "];\n"; } - else if (SymbolTable::getType(name1) == eExogenous) + else if (symbol_table.getType(name1) == eExogenous) { *output << "calib_var_index{3} = [calib_var_index{3};" << id1 << "," << id2 << "];\n"; *output << "calib_weights{3} = [calib_weights{3}; " << weight << "];\n"; @@ -420,13 +420,13 @@ void ComputingTasks::setCalibVar(string name1, string name2, string weight, stri void ComputingTasks::setCalibAc(string name, string ar, string weight, string expression) { - static int max_iar = 3; - if (!SymbolTable::Exist(name)) + int max_iar = 3; + if (!symbol_table.Exist(name)) { string msg = "calib_var: " + name + " doesn't exist"; error(msg.c_str()); } - int id = SymbolTable::getID(name)+1; + int id = symbol_table.getID(name) + 1; int iar = atoi(ar.c_str())+3; if (iar > max_iar) { @@ -439,7 +439,7 @@ void ComputingTasks::setCalibAc(string name, string ar, string weight, string ex } max_iar = iar; } - if (SymbolTable::getType(name) == eEndogenous) + if (symbol_table.getType(name) == eEndogenous) { *output << "calib_var_index{" << iar << "} = [calib_var_index{" << iar << "};" << id << "];\n"; *output << "calib_weights{" << iar << "} = [calib_weights{" << iar << "}; " << weight << "];\n"; @@ -498,12 +498,12 @@ void ComputingTasks::BeginOptimWeights(void) //------------------------------------------------------------------------------ void ComputingTasks::setOptimWeights(string name, string exp) { - if (!SymbolTable::Exist(name) || SymbolTable::getType(name) != eEndogenous) + if (!symbol_table.Exist(name) || symbol_table.getType(name) != eEndogenous) { string msg = "optim_weights: " + name + " isn't an endogenous variable"; error(msg.c_str()); } - int id = SymbolTable::getID(name)+1; + int id = symbol_table.getID(name) + 1; *output << "optim_weights_(" << id << "," << id << ") = " << exp << ";\n"; *output << "obj_var_ = [obj_var_; " << id << "];\n"; } @@ -511,18 +511,18 @@ void ComputingTasks::setOptimWeights(string name, string exp) //------------------------------------------------------------------------------ void ComputingTasks::setOptimWeights(string name1, string name2, string exp) { - if (!SymbolTable::Exist(name1) || SymbolTable::getType(name1) != eEndogenous) + if (!symbol_table.Exist(name1) || symbol_table.getType(name1) != eEndogenous) { string msg = "optim_weights: " + name1 + " isn't an endogenous variable"; error(msg.c_str()); } - if (!SymbolTable::Exist(name2) || SymbolTable::getType(name2) != eEndogenous) + if (!symbol_table.Exist(name2) || symbol_table.getType(name2) != eEndogenous) { string msg = "optim_weights: " + name2 + " isn't an endogenous variable"; error(msg.c_str()); } - int id1 = SymbolTable::getID(name1)+1; - int id2 = SymbolTable::getID(name2)+1; + int id1 = symbol_table.getID(name1) + 1; + int id2 = symbol_table.getID(name2) + 1; *output << "optim_weights_(" << id1 << "," << id2 << ") = " << exp << ";\n"; *output << "obj_var_ = [obj_var_; " << id1 << " " << id2 << "];\n"; } diff --git a/parser.src/DataTree.cc b/parser.src/DataTree.cc index d4ca7d171..9bb13d04d 100644 --- a/parser.src/DataTree.cc +++ b/parser.src/DataTree.cc @@ -16,35 +16,30 @@ using namespace std; #include "VariableTable.hh" #include "NumericalConstants.hh" #include "DataTree.hh" -//------------------------------------------------------------------------------ -const int DataTree::NoOpCode = -1; -const NodeID DataTree::NullID = NULL; -const NodeID DataTree::Zero = new MetaToken(reinterpret_cast (0), eNumericalConstant, NULL, -1); -const NodeID DataTree::One = new MetaToken(reinterpret_cast (1), eNumericalConstant, NULL, -1); -const NodeID DataTree::MinusOne = new MetaToken(One, eTempResult, NULL, token::UMINUS); -const NodeID DataTree::ZeroEqZero = new MetaToken(Zero, eTempResult, Zero, token::EQUAL); -int DataTree::offset = 1; -//------------------------------------------------------------------------------ -DataTree::DataTree() + +DataTree::DataTree(SymbolTable &symbol_table_arg, VariableTable &variable_table_arg) : + symbol_table(symbol_table_arg), + variable_table(variable_table_arg), + NoOpCode(-1), NullID(NULL) { - + offset = 1; current_order = 0; - //Here "0" and "1" have been added to NumericalConstants class - SymbolTable::AddSymbolDeclar("0.0",eNumericalConstant, ""); - SymbolTable::AddSymbolDeclar("1.0",eNumericalConstant, ""); + Zero = new MetaToken(reinterpret_cast (0), eNumericalConstant, NULL, -1); Zero->op_name = ""; Zero->reference_count.resize(current_order+1,2); Zero->idx = 0; mModelTree.push_back(Zero); mIndexOfTokens[*Zero]=Zero; + One = new MetaToken(reinterpret_cast (1), eNumericalConstant, NULL, -1); One->op_name = ""; One->op_name = ""; One->reference_count.resize(current_order+1,1); One->idx = 1; mModelTree.push_back(One); mIndexOfTokens[*One]=One; + MinusOne = new MetaToken(One, eTempResult, NULL, token::UMINUS); MinusOne->op_name = operator_table.str(token::UMINUS); MinusOne->reference_count.resize(current_order+1,1); MinusOne->idx = 2; @@ -52,6 +47,7 @@ DataTree::DataTree() mIndexOfTokens[*MinusOne]=MinusOne; // Pushing "0=0" into mModelTree + ZeroEqZero = new MetaToken(Zero, eTempResult, Zero, token::EQUAL); ZeroEqZero->op_name = operator_table.str(token::EQUAL); ZeroEqZero->reference_count.resize(current_order+1,1); ZeroEqZero->idx = 3; diff --git a/parser.src/DynareBison.yy b/parser.src/DynareBison.yy index e79b88f0e..b7e97cc9b 100644 --- a/parser.src/DynareBison.yy +++ b/parser.src/DynareBison.yy @@ -331,11 +331,10 @@ typedef pair ExpObj; model : MODEL ';' equation_list END - {driver.check_model();} | MODEL '(' LINEAR ')' ';' {driver.option_num("linear","1");} - equation_list END {driver.check_model();} + equation_list END | MODEL '(' USE_DLL ')' ';' {driver.use_dll();} - equation_list END {driver.check_model();} + equation_list END ; equation_list @@ -349,7 +348,7 @@ typedef pair ExpObj; : hand_side EQUAL hand_side ';' {$$ = driver.add_model_equal($1, $3);} | hand_side ';' - {$$ = driver.add_model_equal($1);} + {$$ = driver.add_model_equal_with_zero_rhs($1);} ; hand_side diff --git a/parser.src/DynareFlex.ll b/parser.src/DynareFlex.ll index 495eea938..c2e1cac2b 100644 --- a/parser.src/DynareFlex.ll +++ b/parser.src/DynareFlex.ll @@ -258,7 +258,7 @@ int sigma_e = 0; otherwise it is a native statement until the end of the line */ [A-Za-z_][A-Za-z0-9_]* { - if (SymbolTable::getID(yytext) != -1) + if (driver.exists_symbol(yytext)) { BEGIN DYNARE_STATEMENT; yylval->string_val = new string(yytext); @@ -267,14 +267,14 @@ int sigma_e = 0; else { BEGIN NATIVE; - *(driver.output) << yytext; + driver.add_native(yytext); } } -. {BEGIN NATIVE; *(driver.output) << yytext;} +. {BEGIN NATIVE; driver.add_native(yytext); } /* NATIVE Block */ -.* {BEGIN INITIAL; *(driver.output) << yytext << endl;} +.* {BEGIN INITIAL; driver.add_native(yytext); driver.add_native("\n"); } <*>. {return yy::parser::token_type (yytext[0]);} diff --git a/parser.src/DynareMain.cc b/parser.src/DynareMain.cc index a90c206db..25cad9020 100644 --- a/parser.src/DynareMain.cc +++ b/parser.src/DynareMain.cc @@ -7,6 +7,7 @@ using namespace std; #include "ParsingDriver.hh" #include "OutputFile.hh" +#include "ModFile.hh" /*! \brief Main function of Dynare. @@ -48,7 +49,7 @@ main(int argc, char** argv) cout << "Parsing your model file ..." << endl; // Launch parsing - p.parse(argv[1]); + ModFile *mod_file = p.parse(argv[1]); // Execute final instructions p.finish(); @@ -56,9 +57,11 @@ main(int argc, char** argv) string name = argv[1]; name.erase(name.size() - 4,4); // Opening and init main Output file (.m or .sci file) - output_file.Open(name); + output_file.Open(name, mod_file); // Writing remaining string output to output file - output_file.Save(output); + output_file.Save(output, mod_file); + + delete mod_file; cout << "Parsing done" << endl; cout << "Starting Matlab computing ..." << endl; diff --git a/parser.src/Expression.cc b/parser.src/Expression.cc index 65d4157c4..e9f88d8e7 100644 --- a/parser.src/Expression.cc +++ b/parser.src/Expression.cc @@ -8,9 +8,7 @@ using namespace std; //------------------------------------------------------------------------------ #include "Expression.hh" -//------------------------------------------------------------------------------ -ostringstream Expression::output; -//------------------------------------------------------------------------------ + Expression::Expression() { // Empty @@ -22,7 +20,12 @@ Expression::~Expression() // Empty } -//------------------------------------------------------------------------------ +void +Expression::setNumericalConstants(NumericalConstants *num_constants_arg) +{ + num_constants = num_constants_arg; +} + int Expression::AddToken(int id1,Type type1,int id2,Type type2,int op_code) { Token token; @@ -261,13 +264,13 @@ string Expression::getArgument(Type type,int id) } else if (type == eNumericalConstant) { - argument << NumericalConstants::get(id); + argument << num_constants->get(id); } return argument.str(); } //------------------------------------------------------------------------------ -string Expression::get(void) +string Expression::get() { return output.str(); } diff --git a/parser.src/Makefile b/parser.src/Makefile index d49674774..11185979d 100644 --- a/parser.src/Makefile +++ b/parser.src/Makefile @@ -15,6 +15,8 @@ endif ifeq ($(CROSS_WIN32), yes) CPP = i586-mingw32msvc-g++ + # Detection of uninitialized variables is buggy in MinGW and generates spurious warnings + CPPFLAGS += -Wno-uninitialized DYNARE_M = dynare_m.exe DYNARE_S = dynare_s.exe endif @@ -48,7 +50,8 @@ COMMON_OBJ=\ TmpSymbolTable.o\ VariableTable.o\ ParsingDriver.o\ - DataTree.o + DataTree.o \ + ModFile.o MATLAB_OBJ = InterfaceMatlab.o diff --git a/parser.src/ModFile.cc b/parser.src/ModFile.cc new file mode 100644 index 000000000..4e8e6bff4 --- /dev/null +++ b/parser.src/ModFile.cc @@ -0,0 +1,9 @@ +#include "ModFile.hh" + +ModFile::ModFile() : symbol_table(model_parameters), + variable_table(symbol_table, model_parameters), + numerical_initialization(symbol_table, model_parameters), + computing_tasks(symbol_table), + model_tree(symbol_table, variable_table, model_parameters, num_constants) +{ +} diff --git a/parser.src/ModelParameters.cc b/parser.src/ModelParameters.cc index d35ed96b4..19d14cc11 100644 --- a/parser.src/ModelParameters.cc +++ b/parser.src/ModelParameters.cc @@ -3,41 +3,20 @@ \date 04/09/2004 \par This file implements the ModelParemeters class methodes. */ -//------------------------------------------------------------------------------ -#include + #include "ModelParameters.hh" -//------------------------------------------------------------------------------ -int ModelParameters::eq_nbr = 0; -int ModelParameters::exo_nbr = 0; -int ModelParameters::var_exo_nbr = 0; -int ModelParameters::exo_det_nbr = 0; -int ModelParameters::var_exo_det_nbr = 0; -int ModelParameters::endo_nbr = 0; -int ModelParameters::var_endo_nbr = 0; -int ModelParameters::parameter_nbr = 0; -int ModelParameters::local_parameter_nbr = 0; -int ModelParameters::recur_nbr = 0; -int ModelParameters::max_lag = 0; -int ModelParameters::max_lead = 0; -int ModelParameters::max_endo_lag = 0; -int ModelParameters::max_endo_lead = 0; -int ModelParameters::max_exo_lag = 0; -int ModelParameters::max_exo_lead = 0; -int ModelParameters::max_exo_det_lag = 0; -int ModelParameters::max_exo_det_lead = 0; -int ModelParameters::max_recur_lag = 0; -int ModelParameters::max_recur_lead = 0; -using namespace std; -//------------------------------------------------------------------------------ -ModelParameters::ModelParameters() + +ModelParameters::ModelParameters() : eq_nbr(0), + exo_nbr(0), var_exo_nbr(0), + exo_det_nbr(0), var_exo_det_nbr(0), + endo_nbr(0), var_endo_nbr(0), + parameter_nbr(0), local_parameter_nbr(0), + recur_nbr(0), + max_lag(0), max_lead(0), + max_endo_lag(0), max_endo_lead(0), + max_exo_lag(0), max_exo_lead(0), + max_exo_det_lag(0), max_exo_det_lead(0), + max_recur_lag(0), max_recur_lead(0) { // Empty } - -//------------------------------------------------------------------------------ -ModelParameters::~ModelParameters() -{ - // Empty -} - -//------------------------------------------------------------------------------ diff --git a/parser.src/ModelTree.cc b/parser.src/ModelTree.cc index 36f0fa342..5526ad3c9 100644 --- a/parser.src/ModelTree.cc +++ b/parser.src/ModelTree.cc @@ -20,24 +20,25 @@ using namespace std; #include "ModelTree.hh" #include "ModelParameters.hh" #include "Interface.hh" -//------------------------------------------------------------------------------ -ostringstream ModelTree::output; -//------------------------------------------------------------------------------ -inline NodeID MetaToken::getDerivativeAddress(int iVarID) +inline NodeID MetaToken::getDerivativeAddress(int iVarID, const ModelTree &model_tree) const { - std::map >::iterator iter = d1.find(iVarID); + std::map >::const_iterator iter = d1.find(iVarID); if (iter == d1.end()) // No entry in map, derivative is therefore null if (op_code == token::EQUAL) - return DataTree::ZeroEqZero; + return model_tree.ZeroEqZero; else - return DataTree::Zero; + return model_tree.Zero; else return iter->second; } -ModelTree::ModelTree() +ModelTree::ModelTree(SymbolTable &symbol_table_arg, VariableTable &variable_table_arg, + ModelParameters &mod_param_arg, const NumericalConstants &num_constants_arg) : + DataTree(symbol_table_arg, variable_table_arg), + mod_param(mod_param_arg), + num_constants(num_constants_arg) { computeJacobian = false; computeJacobianExo = false; @@ -199,7 +200,7 @@ void ModelTree::SaveCFiles() mStaticModelFile << " if (nlhs >= 1)\n"; mStaticModelFile << " {\n"; mStaticModelFile << " /* Set the output pointer to the output matrix residual. */\n"; - mStaticModelFile << " plhs[0] = mxCreateDoubleMatrix(" << ModelParameters::eq_nbr << ",1, mxREAL);\n"; + mStaticModelFile << " plhs[0] = mxCreateDoubleMatrix(" << mod_param.eq_nbr << ",1, mxREAL);\n"; mStaticModelFile << " /* Create a C pointer to a copy of the output matrix residual. */\n"; mStaticModelFile << " residual = mxGetPr(plhs[0]);\n"; mStaticModelFile << " }\n\n"; @@ -207,7 +208,7 @@ void ModelTree::SaveCFiles() mStaticModelFile << " if (nlhs >= 2)\n"; mStaticModelFile << " {\n"; mStaticModelFile << " /* Set the output pointer to the output matrix g1. */\n"; - mStaticModelFile << " plhs[1] = mxCreateDoubleMatrix(" << ModelParameters::eq_nbr << ", " << ModelParameters::endo_nbr << ", mxREAL);\n"; + mStaticModelFile << " plhs[1] = mxCreateDoubleMatrix(" << mod_param.eq_nbr << ", " << mod_param.endo_nbr << ", mxREAL);\n"; mStaticModelFile << " /* Create a C pointer to a copy of the output matrix g1. */\n"; mStaticModelFile << " g1 = mxGetPr(plhs[1]);\n"; mStaticModelFile << " }\n\n"; @@ -247,7 +248,7 @@ void ModelTree::SaveCFiles() mDynamicModelFile << " if (nlhs >= 1)\n"; mDynamicModelFile << " {\n"; mDynamicModelFile << " /* Set the output pointer to the output matrix residual. */\n"; - mDynamicModelFile << " plhs[0] = mxCreateDoubleMatrix(" << ModelParameters::eq_nbr << ",1, mxREAL);\n"; + mDynamicModelFile << " plhs[0] = mxCreateDoubleMatrix(" << mod_param.eq_nbr << ",1, mxREAL);\n"; mDynamicModelFile << " /* Create a C pointer to a copy of the output matrix residual. */\n"; mDynamicModelFile << " residual = mxGetPr(plhs[0]);\n"; mDynamicModelFile << " }\n\n"; @@ -256,9 +257,9 @@ void ModelTree::SaveCFiles() mDynamicModelFile << " {\n"; mDynamicModelFile << " /* Set the output pointer to the output matrix g1. */\n"; if (computeJacobianExo) - mDynamicModelFile << " plhs[1] = mxCreateDoubleMatrix(" << ModelParameters::eq_nbr << ", " << VariableTable::size() << ", mxREAL);\n"; + mDynamicModelFile << " plhs[1] = mxCreateDoubleMatrix(" << mod_param.eq_nbr << ", " << variable_table.size() << ", mxREAL);\n"; else if (computeJacobian) - mDynamicModelFile << " plhs[1] = mxCreateDoubleMatrix(" << ModelParameters::eq_nbr << ", " << ModelParameters::var_endo_nbr << ", mxREAL);\n"; + mDynamicModelFile << " plhs[1] = mxCreateDoubleMatrix(" << mod_param.eq_nbr << ", " << mod_param.var_endo_nbr << ", mxREAL);\n"; mDynamicModelFile << " /* Create a C pointer to a copy of the output matrix g1. */\n"; mDynamicModelFile << " g1 = mxGetPr(plhs[1]);\n"; mDynamicModelFile << " }\n\n"; @@ -266,7 +267,7 @@ void ModelTree::SaveCFiles() mDynamicModelFile << " if (nlhs >= 3)\n"; mDynamicModelFile << " {\n"; mDynamicModelFile << " /* Set the output pointer to the output matrix g2. */\n"; - mDynamicModelFile << " plhs[2] = mxCreateDoubleMatrix(" << ModelParameters::eq_nbr << ", " << VariableTable::size()*VariableTable::size() << ", mxREAL);\n"; + mDynamicModelFile << " plhs[2] = mxCreateDoubleMatrix(" << mod_param.eq_nbr << ", " << variable_table.size()*variable_table.size() << ", mxREAL);\n"; mDynamicModelFile << " /* Create a C pointer to a copy of the output matrix g1. */\n"; mDynamicModelFile << " g2 = mxGetPr(plhs[2]);\n"; mDynamicModelFile << " }\n\n"; @@ -552,21 +553,21 @@ void ModelTree::derive(int iOrder) // Filling mDerivativeIndex // Loop on variables of derivation, skipping symmetric elements - for (int var = 0; var < VariableTable::size(); var++) + for (int var = 0; var < variable_table.size(); var++) { - int starti = var*Order*(Order-1)*ModelParameters::eq_nbr/2; + int starti = var*Order*(Order-1)*mod_param.eq_nbr/2; for (unsigned int i = starti; i < EqualTokenIDs.size() ; i++ ) { - t1 = EqualTokenIDs[i]->getDerivativeAddress(var); + t1 = EqualTokenIDs[i]->getDerivativeAddress(var, *this); if (Order == 1) mDerivativeIndex[0].push_back(DerivativeIndex(t1, i-starti, var)); else if (Order == 2) { - int var1 = VariableTable::getSortID(i/ModelParameters::eq_nbr); - int var2 = VariableTable::getSortID(var); + int var1 = variable_table.getSortID(i/mod_param.eq_nbr); + int var2 = variable_table.getSortID(var); mDerivativeIndex[1].push_back(DerivativeIndex(t1, - i-ModelParameters::eq_nbr*(i/ModelParameters::eq_nbr), - var1*VariableTable::size()+var2)); + i-mod_param.eq_nbr*(i/mod_param.eq_nbr), + var1*variable_table.size()+var2)); } } } @@ -634,23 +635,13 @@ inline NodeID ModelTree::DeriveArgument(NodeID iArg, Type iType, int iVarID) switch(iType) { case eTempResult : - return iArg->getDerivativeAddress(iVarID); + return iArg->getDerivativeAddress(iVarID, *this); case eExogenous : case eExogenousDet : case eEndogenous : case eRecursiveVariable : if ((long int) iArg == iVarID) - //if ((VariableTable::getSymbolID(iArg) == VariableTable::getSymbolID(iVarID)) && - // (VariableTable::getType(iArg) == VariableTable::getType(iVarID))) - { - /* - cout << SymbolTable::getNameByID(iType, - VariableTable::getSymbolID(iArg)) << endl; - cout << SymbolTable::getNameByID(iType, - VariableTable::getSymbolID(iVarID)) << endl; - */ - return One; - } + return One; else { return Zero; @@ -684,7 +675,7 @@ string ModelTree::setStaticModel(void) int d = current_order; // Minimum number of times a temparary expression apears in equations int EquationNBR; // Number of model equations - EquationNBR = ModelParameters::eq_nbr; + EquationNBR = mod_param.eq_nbr; // Reference count of token "0=0" is set to 0 // Not to be printed as a temp expression fill(ZeroEqZero->reference_count.begin(), @@ -702,7 +693,7 @@ string ModelTree::setStaticModel(void) model_output << " = "; model_output << getExpression((*tree_it)->id2, eStaticEquations, lEquationNBR) << ";" << endl; } - else if (lEquationNBR < ModelParameters::eq_nbr) + else if (lEquationNBR < mod_param.eq_nbr) { model_output << "lhs ="; model_output << getExpression((*tree_it)->id1, eStaticEquations, lEquationNBR) << ";" << endl; @@ -750,7 +741,7 @@ string ModelTree::setStaticModel(void) lEquationNBR = 0; for (unsigned int i = 0; i < mDerivativeIndex[0].size(); i++) { - if (VariableTable::getType(mDerivativeIndex[0][i].derivators) == eEndogenous) + if (variable_table.getType(mDerivativeIndex[0][i].derivators) == eEndogenous) { NodeID startJacobian = mDerivativeIndex[0][i].token_id; if (startJacobian != ZeroEqZero) @@ -758,7 +749,7 @@ string ModelTree::setStaticModel(void) string exp = getExpression(startJacobian->id1, eStaticDerivatives); ostringstream g1; g1 << " g1" << lpar << mDerivativeIndex[0][i].equation_id+1 << ", " << - VariableTable::getSymbolID(mDerivativeIndex[0][i].derivators)+1 << rpar; + variable_table.getSymbolID(mDerivativeIndex[0][i].derivators)+1 << rpar; jacobian_output << g1.str() << "=" << g1.str() << "+" << exp << ";\n"; } } @@ -770,7 +761,7 @@ string ModelTree::setStaticModel(void) StaticOutput << "global M_ \n"; StaticOutput << "if M_.param_nbr > 0\n params = M_.params;\nend\n"; - StaticOutput << " residual = zeros( " << ModelParameters::eq_nbr << ", 1);\n"; + StaticOutput << " residual = zeros( " << mod_param.eq_nbr << ", 1);\n"; StaticOutput << "\n\t"+interfaces::comment()+"\n\t"+interfaces::comment(); StaticOutput << "Model equations\n\t"; StaticOutput << interfaces::comment() + "\n\n"; @@ -780,8 +771,8 @@ string ModelTree::setStaticModel(void) StaticOutput << "end\n"; StaticOutput << "if nargout >= 2,\n"; StaticOutput << " g1 = " << - "zeros(" << ModelParameters::eq_nbr << ", " << - ModelParameters::endo_nbr << ");\n" ; + "zeros(" << mod_param.eq_nbr << ", " << + mod_param.endo_nbr << ");\n" ; StaticOutput << "\n\t"+interfaces::comment()+"\n\t"+interfaces::comment(); StaticOutput << "Jacobian matrix\n\t"; StaticOutput << interfaces::comment() + "\n\n"; @@ -856,7 +847,7 @@ string ModelTree::setDynamicModel(void) model_output << " = "; model_output << getExpression((*tree_it)->id2, eStaticEquations, lEquationNBR) << ";" << endl; } - else if (lEquationNBR < ModelParameters::eq_nbr) + else if (lEquationNBR < mod_param.eq_nbr) { model_output << "lhs ="; model_output << getExpression(((*tree_it)->id1), eDynamicEquations, lEquationNBR) << ";" << endl; @@ -925,7 +916,7 @@ string ModelTree::setDynamicModel(void) lEquationNBR = 0; for (unsigned int i = 0; i < mDerivativeIndex[0].size(); i++) { - if (computeJacobianExo || VariableTable::getType(mDerivativeIndex[0][i].derivators) == eEndogenous) + if (computeJacobianExo || variable_table.getType(mDerivativeIndex[0][i].derivators) == eEndogenous) { NodeID startJacobian = mDerivativeIndex[0][i].token_id; if (startJacobian != ZeroEqZero) @@ -933,7 +924,7 @@ string ModelTree::setDynamicModel(void) string exp = getExpression(startJacobian->id1, eDynamicDerivatives); ostringstream g1; g1 << " g1" << lpar << mDerivativeIndex[0][i].equation_id+1 << ", " << - VariableTable::getSortID(mDerivativeIndex[0][i].derivators)+1 << rpar; + variable_table.getSortID(mDerivativeIndex[0][i].derivators)+1 << rpar; jacobian_output << g1.str() << "=" << g1.str() << "+" << exp << ";\n"; } } @@ -956,14 +947,14 @@ string ModelTree::setDynamicModel(void) { string exp = getExpression(startHessian->id1, eDynamicDerivatives); - int varID1 = mDerivativeIndex[1][i].derivators/VariableTable::size(); - int varID2 = mDerivativeIndex[1][i].derivators-varID1*VariableTable::size(); + int varID1 = mDerivativeIndex[1][i].derivators / variable_table.size(); + int varID2 = mDerivativeIndex[1][i].derivators - varID1 * variable_table.size(); hessian_output << " g2" << lpar << mDerivativeIndex[1][i].equation_id+1 << ", " << mDerivativeIndex[1][i].derivators+1 << rpar << " = " << exp << ";\n"; // Treating symetric elements if (varID1 != varID2) lsymetric << " g2" << lpar << mDerivativeIndex[1][i].equation_id+1 << ", " << - varID2*VariableTable::size()+varID1+1 << rpar << " = " << + varID2*variable_table.size()+varID1+1 << rpar << " = " << "g2" << lpar << mDerivativeIndex[1][i].equation_id+1 << ", " << mDerivativeIndex[1][i].derivators+1 << rpar << ";\n"; } @@ -971,8 +962,8 @@ string ModelTree::setDynamicModel(void) } cout << "done \n"; } - int nrows = ModelParameters::eq_nbr; - int nvars = ModelParameters::var_endo_nbr+ModelParameters::exo_nbr+ModelParameters::exo_det_nbr; + int nrows = mod_param.eq_nbr; + int nvars = mod_param.var_endo_nbr + mod_param.exo_nbr + mod_param.exo_det_nbr; if (offset == 1) { DynamicOutput << "global M_ it_\n"; @@ -1163,16 +1154,16 @@ inline string ModelTree::getArgument(NodeID id, Type type, EquationType iEquatio } else if (type == eLocalParameter) { - argument << SymbolTable::getNameByID(eLocalParameter,(long int)id); + argument << symbol_table.getNameByID(eLocalParameter, (long int) id); } else if (type == eNumericalConstant) { - argument << NumericalConstants::get((long int) id); + argument << num_constants.get((long int) id); } else if (type == eEndogenous || type == eExogenous || type == eExogenousDet) if (iEquationType == eStaticEquations || iEquationType == eStaticDerivatives) { - int idx = VariableTable::getSymbolID((long int) id)+offset; + int idx = variable_table.getSymbolID((long int) id)+offset; if (type == eEndogenous) { argument << "y" << lpar << idx << rpar; @@ -1183,7 +1174,7 @@ inline string ModelTree::getArgument(NodeID id, Type type, EquationType iEquatio } else if (type == eExogenousDet) { - idx += ModelParameters::exo_nbr; + idx += mod_param.exo_nbr; argument << "x" << lpar << idx << rpar; } } @@ -1191,13 +1182,13 @@ inline string ModelTree::getArgument(NodeID id, Type type, EquationType iEquatio { if (type == eEndogenous) { - int idx = VariableTable::getPrintIndex((long int) id)+offset; + int idx = variable_table.getPrintIndex((long int) id) + offset; argument << "y" << lpar << idx << rpar; } else if (type == eExogenous) { - int idx = VariableTable::getSymbolID((long int) id)+offset; - int lag = VariableTable::getLag((long int) id); + int idx = variable_table.getSymbolID((long int) id) + offset; + int lag = variable_table.getLag((long int) id); if (offset == 1) { if ( lag != 0) @@ -1225,8 +1216,8 @@ inline string ModelTree::getArgument(NodeID id, Type type, EquationType iEquatio } else if (type == eExogenousDet) { - int idx = VariableTable::getSymbolID((long int) id)+ModelParameters::exo_nbr+offset; - int lag = VariableTable::getLag((long int) id); + int idx = variable_table.getSymbolID((long int) id) + mod_param.exo_nbr + offset; + int lag = variable_table.getLag((long int) id); if (offset == 1) { if (lag != 0) @@ -1261,13 +1252,13 @@ inline string ModelTree::getArgument(NodeID id, Type type, EquationType iEquatio void ModelTree::ModelInitialization(void) { // Exit if there is no equation in model file*/ - if (ModelParameters::eq_nbr == 0) + if (mod_param.eq_nbr == 0) { (* error) ("no equations found in model file"); } - cout << ModelParameters::eq_nbr << " equation(s) found \n"; + cout << mod_param.eq_nbr << " equation(s) found \n"; // Sorting variable table - VariableTable::Sort(); + variable_table.Sort(); // Setting number of equations in ModelParameters class // Here no derivative are computed @@ -1298,25 +1289,25 @@ void ModelTree::ModelInitialization(void) output << "M_.lead_lag_incidence = ["; /* zeros(" << - ModelParameters::max_lag+ModelParameters::max_lead+1 << ", " << - ModelParameters::endo_nbr << ");\n"; + mod_param.max_lag+mod_param.max_lead+1 << ", " << + mod_param.endo_nbr << ");\n"; */ // Loop on endogenous variables - for (int endoID = 0; endoID < ModelParameters::endo_nbr; endoID++) + for (int endoID = 0; endoID < mod_param.endo_nbr; endoID++) { output << "\n\t"; // Loop on periods - for (int lag = -ModelParameters::max_endo_lag; lag <= ModelParameters::max_endo_lead; lag++) + for (int lag = -mod_param.max_endo_lag; lag <= mod_param.max_endo_lead; lag++) { // Getting name of symbol - string name = SymbolTable::getNameByID(eEndogenous, endoID); + string name = symbol_table.getNameByID(eEndogenous, endoID); // and its variableID if exists with current period - int varID = VariableTable::getID(name, lag); - //cout << name << " " << varID << " " << lag << " " << VariableTable::getPrintIndex(varID)+1 << " " << VariableTable::getSortID(varID)+1 << endl; + int varID = variable_table.getID(name, lag); + //cout << name << " " << varID << " " << lag << " " << variable_table.getPrintIndex(varID)+1 << " " << variable_table.getSortID(varID)+1 << endl; if (varID >=0) { - output << " " << VariableTable::getPrintIndex(varID)+1; + output << " " << variable_table.getPrintIndex(varID) + 1; } else { @@ -1328,36 +1319,36 @@ void ModelTree::ModelInitialization(void) output << "]';\n"; // Writing initialization for some other variables - output << "M_.exo_names_orig_ord = [1:" << ModelParameters::exo_nbr << "];\n"; - output << "M_.maximum_lag = " << ModelParameters::max_lag << ";\n"; - output << "M_.maximum_lead = " << ModelParameters::max_lead<< ";\n"; - if (ModelParameters::endo_nbr) + output << "M_.exo_names_orig_ord = [1:" << mod_param.exo_nbr << "];\n"; + output << "M_.maximum_lag = " << mod_param.max_lag << ";\n"; + output << "M_.maximum_lead = " << mod_param.max_lead << ";\n"; + if (mod_param.endo_nbr) { - output << "M_.maximum_endo_lag = " << ModelParameters::max_endo_lag << ";\n"; - output << "M_.maximum_endo_lead = " << ModelParameters::max_endo_lead<< ";\n"; - output << "oo_.steady_state = zeros(" << ModelParameters::endo_nbr << ", 1);\n"; + output << "M_.maximum_endo_lag = " << mod_param.max_endo_lag << ";\n"; + output << "M_.maximum_endo_lead = " << mod_param.max_endo_lead << ";\n"; + output << "oo_.steady_state = zeros(" << mod_param.endo_nbr << ", 1);\n"; } - if (ModelParameters::exo_nbr) + if (mod_param.exo_nbr) { - output << "M_.maximum_exo_lag = " << ModelParameters::max_exo_lag << ";\n"; - output << "M_.maximum_exo_lead = " << ModelParameters::max_exo_lead<< ";\n"; - output << "oo_.exo_steady_state = zeros(" << ModelParameters::exo_nbr << ", 1);\n"; + output << "M_.maximum_exo_lag = " << mod_param.max_exo_lag << ";\n"; + output << "M_.maximum_exo_lead = " << mod_param.max_exo_lead << ";\n"; + output << "oo_.exo_steady_state = zeros(" << mod_param.exo_nbr << ", 1);\n"; } - if (ModelParameters::exo_det_nbr) + if (mod_param.exo_det_nbr) { - output << "M_.maximum_exo_det_lag = " << ModelParameters::max_exo_det_lag << ";\n"; - output << "M_.maximum_exo_det_lead = " << ModelParameters::max_exo_det_lead<< ";\n"; - output << "oo_.exo_det_steady_state = zeros(" << ModelParameters::exo_det_nbr << ", 1);\n"; + output << "M_.maximum_exo_det_lag = " << mod_param.max_exo_det_lag << ";\n"; + output << "M_.maximum_exo_det_lead = " << mod_param.max_exo_det_lead << ";\n"; + output << "oo_.exo_det_steady_state = zeros(" << mod_param.exo_det_nbr << ", 1);\n"; } - if (ModelParameters::recur_nbr) + if (mod_param.recur_nbr) { - output << "M_.maximum_recur_lag = " << ModelParameters::max_recur_lag << ";\n"; - output << "M_.maximum_recur_lead = " << ModelParameters::max_recur_lead<< ";\n"; - output << "oo_.recur_steady_state = zeros(" << ModelParameters::recur_nbr << ", 1);\n"; + output << "M_.maximum_recur_lag = " << mod_param.max_recur_lag << ";\n"; + output << "M_.maximum_recur_lead = " << mod_param.max_recur_lead << ";\n"; + output << "oo_.recur_steady_state = zeros(" << mod_param.recur_nbr << ", 1);\n"; } - if (ModelParameters::parameter_nbr) + if (mod_param.parameter_nbr) { - output << "M_.params = zeros(" << ModelParameters::parameter_nbr << ", 1);\n"; + output << "M_.params = zeros(" << mod_param.parameter_nbr << ", 1);\n"; } } @@ -1398,89 +1389,3 @@ inline int ModelTree::optimize(NodeID node) node->tmp_status = 0; return tmp_status; } - -//------------------------------------------------------------------------------ -#ifdef TEST_MODELTREE -int main(void) -{ - SymbolTable st; - VariableTable vt; - NumericalConstants nc; - ModelTree model; - vector t(20); - - //Adding 2 different symbols with AddSymbolDeclar - SymbolTable::AddSymbolDeclar("c",eExogenous); - //SymbolTable::PrintSymbolTable(); - SymbolTable::AddSymbolDeclar("k",eEndogenous); - //SymbolTable::PrintSymbolTable(); - SymbolTable::AddSymbolDeclar("aa",eParameter); - //SymbolTable::PrintSymbolTable(); - SymbolTable::AddSymbolDeclar("x",eExogenous); - SymbolTable::AddSymbolDeclar("alph",eParameter); - SymbolTable::AddSymbolDeclar("delt",eParameter); - - VariableTable::AddVariable("k",0); - VariableTable::AddVariable("x",-1); - VariableTable::AddVariable("c",-1); - - SymbolTable::AddSymbolDeclar("x1",eEndogenous); - SymbolTable::AddSymbolDeclar("x2",eExogenousDet); - //SymbolTable::AddSymbolDeclar("x3",eExogenous); - - VariableTable::AddVariable("x1",-1); - VariableTable::AddVariable("x2",1); - //VariableTable::AddVariable("x3",-1); - //VariableTable::AddVariable("k",1); - //VariableTable::AddVariable("y",0); - - t[0] = model.AddToken("aa"); - t[1] = model.AddToken("x",-1); - t[2] = model.AddToken("k",0); - t[3] = model.AddToken(Argument(t[0], eTempResult), - Argument(t[1], eTempResult), TIMES); - t[4] = model.AddToken("alph"); - t[5] = model.AddToken(Argument(t[2], eTempResult), - Argument(t[4], eTempResult), POWER); - t[6] = model.AddToken(Argument(t[3], eTempResult), - Argument(t[5], eTempResult), TIMES); - - t[7] = model.AddToken("delt"); - //t[8] = model.AddToken("1"); - t[9] = model.AddToken(Argument(1, eTempResult), - Argument(t[7], eTempResult), MINUS); - t[10] = model.AddToken(Argument(t[9], eTempResult), - Argument(t[2], eTempResult), TIMES); - - t[11] = model.AddToken(Argument(t[2], eTempResult), - UMINUS); - - t[12] = model.AddToken(Argument(t[11], eTempResult), - Argument(t[6], eTempResult), PLUS); - t[13] = model.AddToken(Argument(t[12], eTempResult), - Argument(t[10], eTempResult), PLUS); - t[14] = model.AddToken(Argument(t[13], eTempResult), - Argument(t[10], eTempResult), PLUS); - t[15] = model.AddToken("c",-1); - t[16] = model.AddToken(Argument(t[15], eTempResult), - Argument(t[14], eTempResult), EQUAL); - //try - //{ - model.derive(2); - model.setStaticModel(); - model.setDynamicStochasticModel(); - model.Open("static_model.m", "dynamic_model.m"); - model.Save(); - //cout << model.getStaticModel(); - //} - //catch(Error err) - //{ - // cout << "error---------------------\n"; - // exit(-1); - //} - //cout << model.getDynamicDeterministicModel() << endl; - //cout << model.getDynamicStochasticModel() << endl; - //VariableTable::Sort(); -} -#endif -//------------------------------------------------------------------------------ diff --git a/parser.src/NumericalConstants.cc b/parser.src/NumericalConstants.cc index b964e6eb8..921fa6156 100644 --- a/parser.src/NumericalConstants.cc +++ b/parser.src/NumericalConstants.cc @@ -8,11 +8,7 @@ using namespace std; //------------------------------------------------------------------------------ #include "NumericalConstants.hh" -//------------------------------------------------------------------------------ -vector NumericalConstants::mNumericalConstants; -map > NumericalConstants::numConstantsIndex; -//------------------------------------------------------------------------------ NumericalConstants::NumericalConstants() { AddConstant("0.0"); @@ -40,7 +36,7 @@ int NumericalConstants::AddConstant(string iConst) } //------------------------------------------------------------------------------ -string NumericalConstants::get(int ID) +string NumericalConstants::get(int ID) const { if (ID < (int)mNumericalConstants.size()) { diff --git a/parser.src/NumericalInitialization.cc b/parser.src/NumericalInitialization.cc index f67e3866f..21648cdde 100644 --- a/parser.src/NumericalInitialization.cc +++ b/parser.src/NumericalInitialization.cc @@ -8,10 +8,11 @@ using namespace std; //------------------------------------------------------------------------------ #include "NumericalInitialization.hh" #include "Interface.hh" -//------------------------------------------------------------------------------ -//ostringstream NumericalInitialization::output; -//------------------------------------------------------------------------------ -NumericalInitialization::NumericalInitialization() + +NumericalInitialization::NumericalInitialization(const SymbolTable &symbol_table_arg, + const ModelParameters &mod_param_arg) : + symbol_table(symbol_table_arg), + mod_param(mod_param_arg) { //Empty } @@ -33,20 +34,20 @@ void NumericalInitialization::SetConstant (string name, string expression) { //Testing if symbol exists - if (!SymbolTable::Exist(name)) + if (!symbol_table.Exist(name)) { string msg = "Unknown parameter: " + name; (* error) (msg.c_str()); } // Testing symbol type - if (SymbolTable::getType(name) != eParameter) + if (symbol_table.getType(name) != eParameter) { string msg = "Non-parameter used as a parameter: " + name; (* error) (msg.c_str()); } // Writing expression - *output << "M_.params( " << SymbolTable::getID(name)+1 << " ) = " << expression << ";\n"; - *output << name << " = M_.params( " << SymbolTable::getID(name)+1 << " );\n"; + *output << "M_.params( " << symbol_table.getID(name)+1 << " ) = " << expression << ";\n"; + *output << name << " = M_.params( " << symbol_table.getID(name)+1 << " );\n"; // Deleting expression //TODO @@ -61,10 +62,9 @@ void NumericalInitialization::BeginInitval (void) << interfaces::comment() << "\n"; // Writing initval block to set initial values for variables *output << "options_.initval_file = 0;\nendval_=0;\n"; - if(ModelParameters::recur_nbr > 0) - { - *output << "recurs_ = zeros(" << ModelParameters::recur_nbr << ", 1);\n"; - } + + if (mod_param.recur_nbr > 0) + *output << "recurs_ = zeros(" << mod_param.recur_nbr << ", 1);\n"; } //------------------------------------------------------------------------------ @@ -72,13 +72,13 @@ void NumericalInitialization::SetInit (string name, string expression) { //Testing if symbol exists - if (!SymbolTable::Exist(name)) + if (!symbol_table.Exist(name)) { string msg = "Unknown variable: " + name; (* error) (msg.c_str()); } - Type type = SymbolTable::getType(name); - int id = SymbolTable::getID(name); + Type type = symbol_table.getType(name); + int id = symbol_table.getID(name); // Writing instrcuction that set initial or terminal value // for a variable if (type == eEndogenous) @@ -141,13 +141,13 @@ void NumericalInitialization::BeginHistval (void) void NumericalInitialization::SetHist (string name, int lag, string expression) { //Testing if symbol exists - if (!SymbolTable::Exist(name)) + if (!symbol_table.Exist(name)) { string msg = "Unknown parameter: " + name; (* error) (msg.c_str()); } - Type type = SymbolTable::getType(name); - int id = SymbolTable::getID(name); + Type type = symbol_table.getType(name); + int id = symbol_table.getID(name); // Testing symbol type if (type == eEndogenous) { diff --git a/parser.src/OutputFile.cc b/parser.src/OutputFile.cc index 12a458625..a6904f3e8 100644 --- a/parser.src/OutputFile.cc +++ b/parser.src/OutputFile.cc @@ -25,7 +25,7 @@ OutputFile::~OutputFile() } //------------------------------------------------------------------------------ -void OutputFile::Open(string iFileName) +void OutputFile::Open(string iFileName, ModFile *mod_file) { if (iFileName.size()) { @@ -67,7 +67,7 @@ void OutputFile::Open(string iFileName) mOutputFile << "warning on;\nwarning backtrace;\n"; mOutputFile << "logname_ = '" << iFileName << ".log';\n"; mOutputFile << "diary '" << iFileName << ".log';\n"; - if (ModelTree::offset == 0) + if (mod_file->model_tree.offset == 0) { mOutputFile << "if "; mOutputFile << interfaces::file_exist(iFileName + "_static.c)")+"\n"; @@ -89,10 +89,10 @@ void OutputFile::Open(string iFileName) } //------------------------------------------------------------------------------ -void OutputFile::Save(ostringstream& iOutput) +void OutputFile::Save(ostringstream& iOutput, ModFile *mod_file) { - mOutputFile << SymbolTable::get(); - mOutputFile << ModelTree::get(); + mOutputFile << mod_file->symbol_table.get(); + mOutputFile << mod_file->model_tree.get(); mOutputFile << iOutput.str(); mOutputFile << "\ndisp(['Total computing time : ' sec2hms(round(toc)) ]);\n"; mOutputFile.close(); diff --git a/parser.src/ParsingDriver.cc b/parser.src/ParsingDriver.cc index a79b3da6c..e053d5d77 100644 --- a/parser.src/ParsingDriver.cc +++ b/parser.src/ParsingDriver.cc @@ -2,25 +2,36 @@ ParsingDriver::ParsingDriver() : trace_scanning(false), trace_parsing(false) { - order = -1; - linear = -1; - model_tree.error = error; - symbol_table.error = error; - variable_table.error = error; - shocks.error = error; - numerical_initialization.error = error; - computing_tasks.error = error; + mod_file = new ModFile(); + mod_file->order = -1; + mod_file->linear = -1; + + mod_file->model_tree.error = error; + mod_file->symbol_table.error = error; + mod_file->variable_table.error = error; + mod_file->shocks.error = error; + mod_file->numerical_initialization.error = error; + mod_file->computing_tasks.error = error; tmp_symbol_table.error = error; + + tmp_symbol_table.setGlobalSymbolTable(&mod_file->symbol_table); + expression.setNumericalConstants(&mod_file->num_constants); } ParsingDriver::~ParsingDriver() { } +bool +ParsingDriver::exists_symbol(const char *s) +{ + return mod_file->symbol_table.Exist(s); +} + void ParsingDriver::check_symbol_existence(const string &name) { - if (!symbol_table.Exist(name)) + if (!mod_file->symbol_table.Exist(name)) error("Unknown symbol: " + name); } @@ -36,10 +47,10 @@ ParsingDriver::get_expression(ExpObj *exp) return sexp; } else - return Expression::getArgument(exp->second, exp->first); + return expression.getArgument(exp->second, exp->first); } -void +ModFile * ParsingDriver::parse(const string &f) { file = f; @@ -48,6 +59,7 @@ ParsingDriver::parse(const string &f) parser.set_debug_level(trace_parsing); parser.parse(); scan_end(); + return mod_file; } void @@ -60,8 +72,7 @@ ParsingDriver::error(const yy::parser::location_type &l, const string &m) void ParsingDriver::error(const string &m) { - extern int yylineno; - cerr << file << ":" << yylineno << ": " << m << endl; + cerr << file << ": " << m << endl; exit(-1); } @@ -69,16 +80,16 @@ void ParsingDriver::setoutput(ostringstream *ostr) { output = ostr; - numerical_initialization.setOutput(ostr); - shocks.setOutput(ostr); - sigmae.setOutput(ostr); - computing_tasks.setOutput(ostr); + mod_file->numerical_initialization.setOutput(ostr); + mod_file->shocks.setOutput(ostr); + mod_file->sigmae.setOutput(ostr); + mod_file->computing_tasks.setOutput(ostr); } void ParsingDriver::declare_endogenous(string *name, string *tex_name) { - symbol_table.AddSymbolDeclar(*name, eEndogenous, *tex_name); + mod_file->symbol_table.AddSymbolDeclar(*name, eEndogenous, *tex_name); delete name; delete tex_name; } @@ -86,7 +97,7 @@ ParsingDriver::declare_endogenous(string *name, string *tex_name) void ParsingDriver::declare_exogenous(string *name, string *tex_name) { - symbol_table.AddSymbolDeclar(*name, eExogenous, *tex_name); + mod_file->symbol_table.AddSymbolDeclar(*name, eExogenous, *tex_name); delete name; delete tex_name; } @@ -94,7 +105,7 @@ ParsingDriver::declare_exogenous(string *name, string *tex_name) void ParsingDriver::declare_exogenous_det(string *name, string *tex_name) { - symbol_table.AddSymbolDeclar(*name, eExogenousDet, *tex_name); + mod_file->symbol_table.AddSymbolDeclar(*name, eExogenousDet, *tex_name); delete name; delete tex_name; } @@ -102,7 +113,7 @@ ParsingDriver::declare_exogenous_det(string *name, string *tex_name) void ParsingDriver::declare_parameter(string *name, string *tex_name) { - symbol_table.AddSymbolDeclar(*name, eParameter, *tex_name); + mod_file->symbol_table.AddSymbolDeclar(*name, eParameter, *tex_name); delete name; delete tex_name; } @@ -110,7 +121,7 @@ ParsingDriver::declare_parameter(string *name, string *tex_name) ExpObj * ParsingDriver::add_expression_constant(string *constant) { - int id = num_constants.AddConstant(*constant); + int id = mod_file->num_constants.AddConstant(*constant); delete constant; return new ExpObj(id, eNumericalConstant); } @@ -118,23 +129,23 @@ ParsingDriver::add_expression_constant(string *constant) NodeID ParsingDriver::add_model_constant(string *constant) { - int id = num_constants.AddConstant(*constant); + int id = mod_file->num_constants.AddConstant(*constant); delete constant; - return model_tree.AddTerminal((NodeID) id, eNumericalConstant); + return mod_file->model_tree.AddTerminal((NodeID) id, eNumericalConstant); } NodeID ParsingDriver::add_model_variable(string *name) { check_symbol_existence(*name); - Type type = symbol_table.getType(*name); + Type type = mod_file->symbol_table.getType(*name); if ((type == eEndogenous) || (type == eExogenous) || (type == eExogenousDet)) - variable_table.AddVariable(*name, 0); + mod_file->variable_table.AddVariable(*name, 0); - NodeID id = model_tree.AddTerminal(*name); + NodeID id = mod_file->model_tree.AddTerminal(*name); delete name; return id; } @@ -143,7 +154,7 @@ NodeID ParsingDriver::add_model_variable(string *name, string *olag) { check_symbol_existence(*name); - Type type = symbol_table.getType(*name); + Type type = mod_file->symbol_table.getType(*name); int lag = atoi(olag->c_str()); if ((type == eExogenous) && lag != 0) @@ -154,9 +165,9 @@ ParsingDriver::add_model_variable(string *name, string *olag) } if ((type == eEndogenous) || (type == eExogenous)) - variable_table.AddVariable(*name, lag); + mod_file->variable_table.AddVariable(*name, lag); - NodeID id = model_tree.AddTerminal(*name, lag); + NodeID id = mod_file->model_tree.AddTerminal(*name, lag); delete name; delete olag; return id; @@ -166,8 +177,8 @@ ExpObj * ParsingDriver::add_expression_variable(string *name) { check_symbol_existence(*name); - int id = symbol_table.getID(*name); - Type type = symbol_table.getType(*name); + int id = mod_file->symbol_table.getID(*name); + Type type = mod_file->symbol_table.getType(*name); delete name; return new ExpObj(id, type); } @@ -203,7 +214,7 @@ ParsingDriver::add_expression_token(ExpObj *arg1, string *op_name) void ParsingDriver::init_param(string *name, ExpObj *rhs) { - numerical_initialization.SetConstant(*name, get_expression(rhs)); + mod_file->numerical_initialization.SetConstant(*name, get_expression(rhs)); delete name; delete rhs; } @@ -211,7 +222,7 @@ ParsingDriver::init_param(string *name, ExpObj *rhs) void ParsingDriver::init_val(string *name, ExpObj *rhs) { - numerical_initialization.SetInit(*name, get_expression(rhs)); + mod_file->numerical_initialization.SetInit(*name, get_expression(rhs)); delete name; delete rhs; } @@ -220,7 +231,7 @@ void ParsingDriver::hist_val(string *name, string *lag, ExpObj *rhs) { int ilag = atoi(lag->c_str()); - numerical_initialization.SetHist(*name, ilag, get_expression(rhs)); + mod_file->numerical_initialization.SetHist(*name, ilag, get_expression(rhs)); delete name; delete lag; delete rhs; @@ -230,14 +241,7 @@ void ParsingDriver::use_dll() { // Seetting variable momber offset to use C outputs - model_tree.offset = 0; -} - -void -ParsingDriver::check_model() -{ - // creates too many problems MJ 11/12/06 - // symbol_table.clean(); + mod_file->model_tree.offset = 0; } void @@ -246,42 +250,38 @@ ParsingDriver::finish() string model_file_name(file); // Setting flags to compute what is necessary - if (order == 1 || linear == 1) + if (mod_file->order == 1 || mod_file->linear == 1) { - model_tree.computeJacobianExo = true; - model_tree.computeJacobian = false; + mod_file->model_tree.computeJacobianExo = true; + mod_file->model_tree.computeJacobian = false; } - else if (order != -1 && linear != -1) + else if (mod_file->order != -1 && mod_file->linear != -1) { - model_tree.computeHessian = true; - model_tree.computeJacobianExo = true; + mod_file->model_tree.computeHessian = true; + mod_file->model_tree.computeJacobianExo = true; } // Removing extension chars model_file_name.erase(model_file_name.size()-4,4); - model_tree.ModelInitialization(); + mod_file->model_tree.ModelInitialization(); - if ( model_tree.computeHessian ) - { - model_tree.derive(2); - } + if (mod_file->model_tree.computeHessian ) + mod_file->model_tree.derive(2); else - { - model_tree.derive(1); - } + mod_file->model_tree.derive(1); cout << "Processing outputs ..." << endl; - model_tree.setStaticModel(); - model_tree.setDynamicModel(); + mod_file->model_tree.setStaticModel(); + mod_file->model_tree.setDynamicModel(); - if (model_tree.offset == 0) + if (mod_file->model_tree.offset == 0) { - model_tree.OpenCFiles(model_file_name+"_static", model_file_name+"_dynamic"); - model_tree.SaveCFiles(); + mod_file->model_tree.OpenCFiles(model_file_name+"_static", model_file_name+"_dynamic"); + mod_file->model_tree.SaveCFiles(); } else { - model_tree.OpenMFiles(model_file_name+"_static", model_file_name+"_dynamic"); - model_tree.SaveMFiles(); + mod_file->model_tree.OpenMFiles(model_file_name+"_static", model_file_name+"_dynamic"); + mod_file->model_tree.SaveMFiles(); } *output << "save('" << model_file_name << "_results', 'oo_');\n"; @@ -293,63 +293,63 @@ ParsingDriver::finish() void ParsingDriver::begin_initval() { - numerical_initialization.BeginInitval(); + mod_file->numerical_initialization.BeginInitval(); } void ParsingDriver::end_initval() { - numerical_initialization.EndInitval(); + mod_file->numerical_initialization.EndInitval(); } void ParsingDriver::begin_endval() { - numerical_initialization.BeginEndval(); + mod_file->numerical_initialization.BeginEndval(); } void ParsingDriver::end_endval() { - numerical_initialization.EndEndval(); + mod_file->numerical_initialization.EndEndval(); } void ParsingDriver::begin_histval() { - numerical_initialization.BeginHistval(); + mod_file->numerical_initialization.BeginHistval(); } void ParsingDriver::begin_shocks() { - shocks.BeginShocks(); + mod_file->shocks.BeginShocks(); } void ParsingDriver::begin_mshocks() { - shocks.BeginMShocks(); + mod_file->shocks.BeginMShocks(); } void ParsingDriver::end_shocks() { - shocks.EndShocks(); + mod_file->shocks.EndShocks(); } void ParsingDriver::add_det_shock(string *var) { check_symbol_existence(*var); - int id = symbol_table.getID(*var); - switch (symbol_table.getType(*var)) + int id = mod_file->symbol_table.getID(*var); + switch (mod_file->symbol_table.getType(*var)) { case eExogenous: - shocks.AddDetShockExo(id); + mod_file->shocks.AddDetShockExo(id); break; case eExogenousDet: - shocks.AddDetShockExoDet(id); + mod_file->shocks.AddDetShockExoDet(id); break; default: error("Shocks can only be applied to exogenous variables"); @@ -361,8 +361,8 @@ void ParsingDriver::add_stderr_shock(string *var, ExpObj *value) { check_symbol_existence(*var); - int id = symbol_table.getID(*var); - shocks.AddSTDShock(id, get_expression(value)); + int id = mod_file->symbol_table.getID(*var); + mod_file->shocks.AddSTDShock(id, get_expression(value)); delete var; delete value; } @@ -371,8 +371,8 @@ void ParsingDriver::add_var_shock(string *var, ExpObj *value) { check_symbol_existence(*var); - int id = symbol_table.getID(*var); - shocks.AddVARShock(id, get_expression(value)); + int id = mod_file->symbol_table.getID(*var); + mod_file->shocks.AddVARShock(id, get_expression(value)); delete var; delete value; } @@ -382,9 +382,9 @@ ParsingDriver::add_covar_shock(string *var1, string *var2, ExpObj *value) { check_symbol_existence(*var1); check_symbol_existence(*var2); - int id1 = symbol_table.getID(*var1); - int id2 = symbol_table.getID(*var2); - shocks.AddCOVAShock(id1, id2, get_expression(value)); + int id1 = mod_file->symbol_table.getID(*var1); + int id2 = mod_file->symbol_table.getID(*var2); + mod_file->shocks.AddCOVAShock(id1, id2, get_expression(value)); delete var1; delete var2; delete value; @@ -395,9 +395,9 @@ ParsingDriver::add_correl_shock(string *var1, string *var2, ExpObj *value) { check_symbol_existence(*var1); check_symbol_existence(*var2); - int id1 = symbol_table.getID(*var1); - int id2 = symbol_table.getID(*var2); - shocks.AddCORRShock(id1, id2, get_expression(value)); + int id1 = mod_file->symbol_table.getID(*var1); + int id2 = mod_file->symbol_table.getID(*var2); + mod_file->shocks.AddCORRShock(id1, id2, get_expression(value)); delete var1; delete var2; delete value; @@ -406,7 +406,7 @@ ParsingDriver::add_correl_shock(string *var1, string *var2, ExpObj *value) void ParsingDriver::add_period(string *p1, string *p2) { - shocks.AddPeriod(*p1, *p2); + mod_file->shocks.AddPeriod(*p1, *p2); delete p1; delete p2; } @@ -414,61 +414,61 @@ ParsingDriver::add_period(string *p1, string *p2) void ParsingDriver::add_period(string *p1) { - shocks.AddPeriod(*p1, *p1); + mod_file->shocks.AddPeriod(*p1, *p1); delete p1; } void ParsingDriver::add_value(string *value) { - shocks.AddValue(*value); + mod_file->shocks.AddValue(*value); delete value; } void ParsingDriver::add_value(ExpObj *value) { - shocks.AddValue(get_expression(value)); + mod_file->shocks.AddValue(get_expression(value)); delete value; } void ParsingDriver::do_sigma_e() { - sigmae.set(); + mod_file->sigmae.set(); } void ParsingDriver::end_of_row() { - sigmae.EndOfRow(); + mod_file->sigmae.EndOfRow(); } void ParsingDriver::add_to_row(string *s) { - sigmae.AddExpression(*s); + mod_file->sigmae.AddExpression(*s); delete s; } void ParsingDriver::add_to_row(ExpObj *v) { - sigmae.AddExpression(get_expression(v)); + mod_file->sigmae.AddExpression(get_expression(v)); delete v; } void ParsingDriver::steady() { - computing_tasks.setSteady(); - model_tree.computeJacobian = true; + mod_file->computing_tasks.setSteady(); + mod_file->model_tree.computeJacobian = true; } void ParsingDriver::option_num(const string &name_option, string *opt1, string *opt2) { - computing_tasks.setOption(name_option, *opt1, *opt2); + mod_file->computing_tasks.setOption(name_option, *opt1, *opt2); delete opt1; delete opt2; } @@ -483,11 +483,11 @@ ParsingDriver::option_num(const string &name_option, string *opt) void ParsingDriver::option_num(const string &name_option, const string &opt) { - computing_tasks.setOption(name_option, opt); + mod_file->computing_tasks.setOption(name_option, opt); if (name_option == "order") - order = atoi(opt.c_str()); + mod_file->order = atoi(opt.c_str()); else if (name_option == "linear") - linear = atoi(opt.c_str()); + mod_file->linear = atoi(opt.c_str()); } void @@ -500,7 +500,7 @@ ParsingDriver::option_str(const string &name_option, string *opt) void ParsingDriver::option_str(const string &name_option, const string &opt) { - computing_tasks.setOption(name_option, "'" + opt + "'"); + mod_file->computing_tasks.setOption(name_option, "'" + opt + "'"); } void @@ -522,64 +522,61 @@ void ParsingDriver::rplot() { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runRplot(tmp); + mod_file->computing_tasks.runRplot(tmp); } void ParsingDriver::stoch_simul() { // If order and linear not set, then set them to default values - if (order == -1) - { - order = 2; - } - if (linear == -1) - { - linear = 0; - } + if (mod_file->order == -1) + mod_file->order = 2; + + if (mod_file->linear == -1) + mod_file->linear = 0; tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.setStochSimul(tmp); + mod_file->computing_tasks.setStochSimul(tmp); } void ParsingDriver::simul() { - computing_tasks.setSimul(); - model_tree.computeJacobian = true; + mod_file->computing_tasks.setSimul(); + mod_file->model_tree.computeJacobian = true; } void ParsingDriver::check() { - computing_tasks.setCheck(); - model_tree.computeJacobian = true; + mod_file->computing_tasks.setCheck(); + mod_file->model_tree.computeJacobian = true; } void ParsingDriver::estimation_init() { - computing_tasks.EstimParams = &estim_params; - computing_tasks.setEstimationInit(); - model_tree.computeJacobianExo = true; + mod_file->computing_tasks.EstimParams = &estim_params; + mod_file->computing_tasks.setEstimationInit(); + mod_file->model_tree.computeJacobianExo = true; } void ParsingDriver::set_estimated_elements() { - computing_tasks.setEstimatedElements(); + mod_file->computing_tasks.setEstimatedElements(); } void ParsingDriver::set_estimated_init_elements() { - computing_tasks.setEstimatedInitElements(); + mod_file->computing_tasks.setEstimatedInitElements(); } void ParsingDriver::set_estimated_bounds_elements() { - computing_tasks.setEstimatedBoundsElements(); + mod_file->computing_tasks.setEstimatedBoundsElements(); } void @@ -594,7 +591,7 @@ ParsingDriver::run_estimation() { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runEstimation(tmp); + mod_file->computing_tasks.runEstimation(tmp); } void @@ -602,7 +599,7 @@ ParsingDriver::run_prior_analysis() { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runPriorAnalysis(tmp); + mod_file->computing_tasks.runPriorAnalysis(tmp); } void @@ -610,13 +607,13 @@ ParsingDriver::run_posterior_analysis() { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runPosteriorAnalysis(tmp); + mod_file->computing_tasks.runPosteriorAnalysis(tmp); } void ParsingDriver::optim_options(string *str1, string *str2, int task) { - computing_tasks.setOptimOptions(*str1, *str2, task); + mod_file->computing_tasks.setOptimOptions(*str1, *str2, task); delete str1; delete str2; } @@ -637,7 +634,7 @@ ParsingDriver::set_trend_init() void ParsingDriver::set_trend_element(string *arg1, ExpObj *arg2) { - computing_tasks.set_trend_element(*arg1, get_expression(arg2)); + mod_file->computing_tasks.set_trend_element(*arg1, get_expression(arg2)); delete arg1; delete arg2; } @@ -645,13 +642,13 @@ ParsingDriver::set_trend_element(string *arg1, ExpObj *arg2) void ParsingDriver::begin_optim_weights() { - computing_tasks.BeginOptimWeights(); + mod_file->computing_tasks.BeginOptimWeights(); } void ParsingDriver::set_optim_weights(string *arg1, ExpObj *arg2) { - computing_tasks.setOptimWeights(*arg1, get_expression(arg2)); + mod_file->computing_tasks.setOptimWeights(*arg1, get_expression(arg2)); delete arg1; delete arg2; } @@ -659,7 +656,7 @@ ParsingDriver::set_optim_weights(string *arg1, ExpObj *arg2) void ParsingDriver::set_optim_weights(string *arg1, string *arg2, ExpObj *arg3) { - computing_tasks.setOptimWeights(*arg1, *arg2, get_expression(arg3)); + mod_file->computing_tasks.setOptimWeights(*arg1, *arg2, get_expression(arg3)); delete arg1; delete arg2; delete arg3; @@ -670,7 +667,7 @@ ParsingDriver::set_osr_params() { tmp_symbol_table.set("osr_params_"); string tmp = tmp_symbol_table.get(); - computing_tasks.setOsrParams(tmp); + mod_file->computing_tasks.setOsrParams(tmp); } void @@ -678,8 +675,8 @@ ParsingDriver::run_osr() { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runOsr(tmp); - model_tree.computeJacobianExo = true; + mod_file->computing_tasks.runOsr(tmp); + mod_file->model_tree.computeJacobianExo = true; } void @@ -687,7 +684,7 @@ ParsingDriver::set_olr_inst() { tmp_symbol_table.set("options_.olr_inst"); string tmp = tmp_symbol_table.get(); - computing_tasks.setOlrInst(tmp); + mod_file->computing_tasks.setOlrInst(tmp); } void @@ -695,19 +692,19 @@ ParsingDriver::run_olr() { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runOlr(tmp); + mod_file->computing_tasks.runOlr(tmp); } void ParsingDriver::begin_calib_var() { - computing_tasks.BeginCalibVar(); + mod_file->computing_tasks.BeginCalibVar(); } void ParsingDriver::set_calib_var(string *name, string *weight, ExpObj *expression) { - computing_tasks.setCalibVar(*name, *weight, get_expression(expression)); + mod_file->computing_tasks.setCalibVar(*name, *weight, get_expression(expression)); delete name; delete weight; delete expression; @@ -717,7 +714,7 @@ void ParsingDriver::set_calib_var(string *name1, string *name2, string *weight, ExpObj *expression) { - computing_tasks.setCalibVar(*name1, *name2, *weight, get_expression(expression)); + mod_file->computing_tasks.setCalibVar(*name1, *name2, *weight, get_expression(expression)); delete name1; delete name2; delete weight; @@ -728,7 +725,7 @@ void ParsingDriver::set_calib_ac(string *name, string *ar, string *weight, ExpObj *expression) { - computing_tasks.setCalibAc(*name, *ar, *weight, get_expression(expression)); + mod_file->computing_tasks.setCalibAc(*name, *ar, *weight, get_expression(expression)); delete name; delete ar; delete weight; @@ -738,7 +735,7 @@ ParsingDriver::set_calib_ac(string *name, string *ar, void ParsingDriver::run_calib(int flag) { - computing_tasks.runCalib(flag); + mod_file->computing_tasks.runCalib(flag); } void @@ -746,7 +743,7 @@ ParsingDriver::run_dynatype(string *filename, string *ext) { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runDynatype(*filename, *ext, tmp); + mod_file->computing_tasks.runDynatype(*filename, *ext, tmp); delete filename; delete ext; } @@ -756,7 +753,7 @@ ParsingDriver::run_dynasave(string *filename, string *ext) { tmp_symbol_table.set("var_list_"); string tmp = tmp_symbol_table.get(); - computing_tasks.runDynasave(*filename, *ext, tmp); + mod_file->computing_tasks.runDynasave(*filename, *ext, tmp); delete filename; delete ext; } @@ -764,13 +761,13 @@ ParsingDriver::run_dynasave(string *filename, string *ext) void ParsingDriver::begin_model_comparison() { - computing_tasks.beginModelComparison(); + mod_file->computing_tasks.beginModelComparison(); } void ParsingDriver::add_mc_filename(string *filename, string *prior) { - computing_tasks.addMcFilename(*filename, *prior); + mod_file->computing_tasks.addMcFilename(*filename, *prior); delete filename; delete prior; } @@ -778,154 +775,166 @@ ParsingDriver::add_mc_filename(string *filename, string *prior) void ParsingDriver::run_model_comparison() { - computing_tasks.runModelComparison(); + mod_file->computing_tasks.runModelComparison(); } NodeID ParsingDriver::add_model_equal(NodeID arg1, NodeID arg2) { - NodeID id = model_tree.AddEqual(arg1, arg2); - model_parameters.eq_nbr++; + NodeID id = mod_file->model_tree.AddEqual(arg1, arg2); + mod_file->model_parameters.eq_nbr++; return id; } +NodeID +ParsingDriver::add_model_equal_with_zero_rhs(NodeID arg) +{ + return add_model_equal(arg, mod_file->model_tree.Zero); +} + void ParsingDriver::declare_and_init_local_parameter(string *name, NodeID rhs) { - symbol_table.AddSymbolDeclar(*name, eLocalParameter, *name); - NodeID id = model_tree.AddTerminal(*name); - model_tree.AddAssign(id, rhs); + mod_file->symbol_table.AddSymbolDeclar(*name, eLocalParameter, *name); + NodeID id = mod_file->model_tree.AddTerminal(*name); + mod_file->model_tree.AddAssign(id, rhs); delete name; } NodeID ParsingDriver::add_model_plus(NodeID arg1, NodeID arg2) { - return model_tree.AddPlus(arg1, arg2); + return mod_file->model_tree.AddPlus(arg1, arg2); } NodeID ParsingDriver::add_model_minus(NodeID arg1, NodeID arg2) { - return model_tree.AddMinus(arg1, arg2); + return mod_file->model_tree.AddMinus(arg1, arg2); } NodeID ParsingDriver::add_model_uminus(NodeID arg1) { - return model_tree.AddUMinus(arg1); + return mod_file->model_tree.AddUMinus(arg1); } NodeID ParsingDriver::add_model_times(NodeID arg1, NodeID arg2) { - return model_tree.AddTimes(arg1, arg2); + return mod_file->model_tree.AddTimes(arg1, arg2); } NodeID ParsingDriver::add_model_divide(NodeID arg1, NodeID arg2) { - return model_tree.AddDivide(arg1, arg2); + return mod_file->model_tree.AddDivide(arg1, arg2); } NodeID ParsingDriver::add_model_power(NodeID arg1, NodeID arg2) { - return model_tree.AddPower(arg1, arg2); + return mod_file->model_tree.AddPower(arg1, arg2); } NodeID ParsingDriver::add_model_exp(NodeID arg1) { - return model_tree.AddExp(arg1); + return mod_file->model_tree.AddExp(arg1); } NodeID ParsingDriver::add_model_log(NodeID arg1) { - return model_tree.AddLog(arg1); + return mod_file->model_tree.AddLog(arg1); } NodeID ParsingDriver::add_model_log10(NodeID arg1) { - return model_tree.AddLog10(arg1); + return mod_file->model_tree.AddLog10(arg1); } NodeID ParsingDriver::add_model_cos(NodeID arg1) { - return model_tree.AddCos(arg1); + return mod_file->model_tree.AddCos(arg1); } NodeID ParsingDriver::add_model_sin(NodeID arg1) { - return model_tree.AddSin(arg1); + return mod_file->model_tree.AddSin(arg1); } NodeID ParsingDriver::add_model_tan(NodeID arg1) { - return model_tree.AddTan(arg1); + return mod_file->model_tree.AddTan(arg1); } NodeID ParsingDriver::add_model_acos(NodeID arg1) { - return model_tree.AddACos(arg1); + return mod_file->model_tree.AddACos(arg1); } NodeID ParsingDriver::add_model_asin(NodeID arg1) { - return model_tree.AddASin(arg1); + return mod_file->model_tree.AddASin(arg1); } NodeID ParsingDriver::add_model_atan(NodeID arg1) { - return model_tree.AddATan(arg1); + return mod_file->model_tree.AddATan(arg1); } NodeID ParsingDriver::add_model_cosh(NodeID arg1) { - return model_tree.AddCosH(arg1); + return mod_file->model_tree.AddCosH(arg1); } NodeID ParsingDriver::add_model_sinh(NodeID arg1) { - return model_tree.AddSinH(arg1); + return mod_file->model_tree.AddSinH(arg1); } NodeID ParsingDriver::add_model_tanh(NodeID arg1) { - return model_tree.AddTanH(arg1); + return mod_file->model_tree.AddTanH(arg1); } NodeID ParsingDriver::add_model_acosh(NodeID arg1) { - return model_tree.AddACosH(arg1); + return mod_file->model_tree.AddACosH(arg1); } NodeID ParsingDriver::add_model_asinh(NodeID arg1) { - return model_tree.AddASinH(arg1); + return mod_file->model_tree.AddASinH(arg1); } NodeID ParsingDriver::add_model_atanh(NodeID arg1) { - return model_tree.AddATanH(arg1); + return mod_file->model_tree.AddATanH(arg1); } NodeID ParsingDriver::add_model_sqrt(NodeID arg1) { - return model_tree.AddSqRt(arg1); + return mod_file->model_tree.AddSqRt(arg1); +} + +void +ParsingDriver::add_native(const char *s) +{ + *output << s; } diff --git a/parser.src/Shocks.cc b/parser.src/Shocks.cc index 8b0f9f695..fa12940ea 100644 --- a/parser.src/Shocks.cc +++ b/parser.src/Shocks.cc @@ -11,13 +11,7 @@ using namespace std; #include "ModelParameters.hh" #include "Interface.hh" -static int mshock_flag = 0; -static int exo_det_length = 0; - -//------------------------------------------------------------------------------ -//ostringstream Shocks::output; -//------------------------------------------------------------------------------ -Shocks::Shocks() +Shocks::Shocks() : mshock_flag(0), exo_det_length(0) { // Empty } diff --git a/parser.src/SymbolTable.cc b/parser.src/SymbolTable.cc index 7a54132ea..66fcdedc5 100644 --- a/parser.src/SymbolTable.cc +++ b/parser.src/SymbolTable.cc @@ -3,34 +3,26 @@ \date 04/09/2004 \par This file implements the SymbolTable class methodes. */ -//------------------------------------------------------------------------------ + #include #include -//------------------------------------------------------------------------------ +#include + #include "SymbolTable.hh" #include "Interface.hh" using namespace std; -//------------------------------------------------------------------------------ -// = *(new symbolmap); -map > SymbolTable::symboltable; -vector< vector > SymbolTable::name_table; -vector< vector > SymbolTable::tex_name_table; -ostringstream SymbolTable::output; -void (* SymbolTable::error) (const char* ) = NULL; -//------------------------------------------------------------------------------ -SymbolTable::SymbolTable() + +SymbolTable::SymbolTable(ModelParameters &mod_param_arg) : mod_param(mod_param_arg) { name_table.resize(20); tex_name_table.resize(20); } -//------------------------------------------------------------------------------ SymbolTable::~SymbolTable() { // Empty } -//------------------------------------------------------------------------------ int SymbolTable::AddSymbol(string name,Type type, string tex_name) { symboltable[name].type = type; @@ -41,29 +33,23 @@ int SymbolTable::AddSymbol(string name,Type type, string tex_name) switch (type) { case eExogenous: - symboltable[name].id = ModelParameters::exo_nbr; - ModelParameters::exo_nbr++; - return ModelParameters::exo_nbr-1; + symboltable[name].id = mod_param.exo_nbr; + return mod_param.exo_nbr++; case eExogenousDet: - symboltable[name].id = ModelParameters::exo_det_nbr; - ModelParameters::exo_det_nbr++; - return ModelParameters::exo_det_nbr-1; + symboltable[name].id = mod_param.exo_det_nbr; + return mod_param.exo_det_nbr++; case eEndogenous: - symboltable[name].id = ModelParameters::endo_nbr; - ModelParameters::endo_nbr++; - return ModelParameters::endo_nbr-1; + symboltable[name].id = mod_param.endo_nbr; + return mod_param.endo_nbr++; case eParameter: - symboltable[name].id = ModelParameters::parameter_nbr; - ModelParameters::parameter_nbr++; - return ModelParameters::parameter_nbr-1; + symboltable[name].id = mod_param.parameter_nbr; + return mod_param.parameter_nbr++; case eRecursiveVariable: - symboltable[name].id = ModelParameters::recur_nbr; - ModelParameters::recur_nbr++; - return ModelParameters::recur_nbr-1; + symboltable[name].id = mod_param.recur_nbr; + return mod_param.recur_nbr++; case eLocalParameter: - symboltable[name].id = ModelParameters::local_parameter_nbr; - ModelParameters::local_parameter_nbr++; - return ModelParameters::local_parameter_nbr-1; + symboltable[name].id = mod_param.local_parameter_nbr; + return mod_param.local_parameter_nbr++; default: // should never happen return -1; @@ -71,7 +57,6 @@ int SymbolTable::AddSymbol(string name,Type type, string tex_name) } -//------------------------------------------------------------------------------ int SymbolTable::AddSymbolDeclar(string name,Type type, string tex_name) { //Testing if the symbol exist in the map @@ -98,45 +83,28 @@ int SymbolTable::AddSymbolDeclar(string name,Type type, string tex_name) } -//------------------------------------------------------------------------------ void SymbolTable::AddSymbolRange(string name,int nbr,Type type, string tex_name) { } -//------------------------------------------------------------------------------ -void SymbolTable::AddLag(string name,int lag) -{ - //Testing if the symbol exist in the map - if ( !Exist(name) ) - { - return; - } - Type type = symboltable[name].type; - if ((type == eEndogenous) || (type == eExogenous)) - { - symboltable[name].lags.push_back(lag); - } -} - -//------------------------------------------------------------------------------ void SymbolTable::ResetType(string name,Type new_type) { symboltable[name].type = new_type; } -//------------------------------------------------------------------------------ void SymbolTable::SetReferenced(string name) { symboltable[name].referenced = eReferenced; } -//------------------------------------------------------------------------------ -Reference SymbolTable::isReferenced(std::string name) +Reference SymbolTable::isReferenced(const std::string &name) const { - return symboltable[name].referenced; + symboltable_const_iterator iter = symboltable.find(name); + return iter->second.referenced; } -//------------------------------------------------------------------------------ +#if 0 // Commented out on 27/11/2006, SV + void SymbolTable::clean() { string unused; @@ -148,9 +116,9 @@ void SymbolTable::clean() types[1] = eExogenous; types[2] = eExogenousDet; - nb_type[0] = ModelParameters::endo_nbr; - nb_type[1] = ModelParameters::exo_nbr; - nb_type[2] = ModelParameters::exo_det_nbr; + nb_type[0] = mod_param.endo_nbr; + nb_type[1] = mod_param.exo_nbr; + nb_type[2] = mod_param.exo_det_nbr; // Removing unused variables for (int t = 0; t < 3; t++) @@ -190,9 +158,9 @@ void SymbolTable::clean() } } } - ModelParameters::endo_nbr = nb_type[0]; - ModelParameters::exo_nbr = nb_type[1]; - ModelParameters::exo_det_nbr = nb_type[2]; + mod_param.endo_nbr = nb_type[0]; + mod_param.exo_nbr = nb_type[1]; + mod_param.exo_det_nbr = nb_type[2]; /* // Checking if unused parameters for (int s1 = 0; s1 < ModelParameters::parameter_nbr; s1++) @@ -219,81 +187,69 @@ void SymbolTable::clean() } //PrintSymbolTable(); } +#endif // Comment string SymbolTable::get() { - if (ModelParameters::exo_nbr > 0) + ostringstream output; + + if (mod_param.exo_nbr > 0) { output << "M_.exo_names = '" << getNameByID(eExogenous, 0) << "';\n"; output << "M_.exo_names_tex = '" << getTexNameByID(eExogenous, 0) << "';\n"; - for (int id = 1; id < ModelParameters::exo_nbr; id++) + for (int id = 1; id < mod_param.exo_nbr; id++) { output << "M_.exo_names = " + interfaces::strvcat("M_.exo_names","'"+getNameByID(eExogenous, id)+"'") + ";\n"; output << "M_.exo_names_tex = " + interfaces::strvcat("M_.exo_names_tex","'"+getTexNameByID(eExogenous, id)+"'") + ";\n"; } } - if (ModelParameters::exo_det_nbr > 0) + if (mod_param.exo_det_nbr > 0) { output << "lgxdet_ = '" << getNameByID(eExogenousDet, 0) << "';\n"; output << "lgxdet_tex_ = '" << getTexNameByID(eExogenousDet, 0) << "';\n"; - for (int id = 1; id < ModelParameters::exo_det_nbr; id++) + for (int id = 1; id < mod_param.exo_det_nbr; id++) { output << "lgxdet_ = " + interfaces::strvcat("lgxdet_","'"+getNameByID(eExogenousDet, id)+"'") + ";\n"; output << "lgxdet_tex_ = " + interfaces::strvcat("lgxdet_tex_","'"+getTexNameByID(eExogenousDet, id)+"'") + ";\n"; } } - if (ModelParameters::endo_nbr > 0) + if (mod_param.endo_nbr > 0) { output << "M_.endo_names = '" << getNameByID(eEndogenous, 0) << "';\n"; output << "M_.endo_names_tex = '" << getTexNameByID(eEndogenous, 0) << "';\n"; - for (int id = 1; id < ModelParameters::endo_nbr; id++) + for (int id = 1; id < mod_param.endo_nbr; id++) { output << "M_.endo_names = " + interfaces::strvcat("M_.endo_names","'"+getNameByID(eEndogenous, id)+"'") + ";\n"; output << "M_.endo_names_tex = " + interfaces::strvcat("M_.endo_names_tex","'"+getTexNameByID(eEndogenous, id)+"'") + ";\n"; } } - if (ModelParameters::recur_nbr > 0) + if (mod_param.recur_nbr > 0) { output << "M_.recur_names = '" << getNameByID(eRecursiveVariable, 0) << "';\n"; output << "M_.recur_names_tex = '" << getTexNameByID(eRecursiveVariable, 0) << "';\n"; - for (int id = 1; id < ModelParameters::recur_nbr; id++) + for (int id = 1; id < mod_param.recur_nbr; id++) { output << "M_.recur_names = " + interfaces::strvcat("M_.recur_names","'"+getNameByID(eRecursiveVariable, id)+"'") + ";\n"; output << "M_.recur_names_tex = " + interfaces::strvcat("M_.recur_names_tex","'"+getTexNameByID(eRecursiveVariable, id)+"'") + ";\n"; } } - if (ModelParameters::parameter_nbr > 0) + if (mod_param.parameter_nbr > 0) { output << "M_.param_names = '" << getNameByID(eParameter, 0) << "';\n"; output << "M_.param_names_tex = '" << getTexNameByID(eParameter, 0) << "';\n"; - for (int id = 1; id < ModelParameters::parameter_nbr; id++) + for (int id = 1; id < mod_param.parameter_nbr; id++) { output << "M_.param_names = " + interfaces::strvcat("M_.param_names","'"+getNameByID(eParameter, id)+"'") + ";\n"; output << "M_.param_names_tex = " + interfaces::strvcat("M_.param_names_tex","'"+getTexNameByID(eParameter, id)+"'") + ";\n"; } } - output << "M_.exo_det_nbr = " << ModelParameters::exo_det_nbr << ";\n"; - output << "M_.exo_nbr = " << ModelParameters::exo_nbr << ";\n"; - output << "M_.Sigma_e = zeros(" << ModelParameters::exo_nbr - << ", " << ModelParameters::exo_nbr << ");\n"; - output << "M_.endo_nbr = " << ModelParameters::endo_nbr << ";\n"; - output << "M_.recur_nbr = " << ModelParameters::recur_nbr << ";\n"; - output << "M_.param_nbr = " << ModelParameters::parameter_nbr << ";\n"; + output << "M_.exo_det_nbr = " << mod_param.exo_det_nbr << ";\n"; + output << "M_.exo_nbr = " << mod_param.exo_nbr << ";\n"; + output << "M_.Sigma_e = zeros(" << mod_param.exo_nbr + << ", " << mod_param.exo_nbr << ");\n"; + output << "M_.endo_nbr = " << mod_param.endo_nbr << ";\n"; + output << "M_.recur_nbr = " << mod_param.recur_nbr << ";\n"; + output << "M_.param_nbr = " << mod_param.parameter_nbr << ";\n"; return output.str(); } - -//------------------------------------------------------------------------------ -void SymbolTable::erase_local_parameters(void) -{ - std::map >::iterator i = symboltable.begin(); - for(; i != symboltable.end(); ++i) - { - if ((i->second).type == eLocalParameter) - { - symboltable.erase(i); - } - } -} - -//------------------------------------------------------------------------------ diff --git a/parser.src/TmpSymbolTable.cc b/parser.src/TmpSymbolTable.cc index 3454d1ad5..2d1ecc9dd 100644 --- a/parser.src/TmpSymbolTable.cc +++ b/parser.src/TmpSymbolTable.cc @@ -15,23 +15,19 @@ TmpSymbolTable::TmpSymbolTable() // Empty } -//------------------------------------------------------------------------------ -TmpSymbolTable::TmpSymbolTable(const TmpSymbolTable &tst) -{ - tmpsymboltable = tst.tmpsymboltable; - output.str(tst.output.str()); -} - -//------------------------------------------------------------------------------ TmpSymbolTable::~TmpSymbolTable() { // Empty } -//------------------------------------------------------------------------------ +void TmpSymbolTable::setGlobalSymbolTable(SymbolTable *symbol_table_arg) +{ + symbol_table = symbol_table_arg; +} + void TmpSymbolTable::AddTempSymbol(string symbol) { - if (SymbolTable::Exist(symbol)) + if (symbol_table->Exist(symbol)) tmpsymboltable.push_back(symbol); else { @@ -43,7 +39,7 @@ void TmpSymbolTable::AddTempSymbol(string symbol) //------------------------------------------------------------------------------ void TmpSymbolTable::AddTempSymbol(string symbol1, string symbol2) { - if (SymbolTable::Exist(symbol1)) + if (symbol_table->Exist(symbol1)) tmpsymboltable.push_back(symbol1); else { @@ -51,7 +47,7 @@ void TmpSymbolTable::AddTempSymbol(string symbol1, string symbol2) error(msg.c_str()); } - if (SymbolTable::Exist(symbol2)) + if (symbol_table->Exist(symbol2)) NameTable.push_back(symbol2); else { @@ -68,7 +64,7 @@ void TmpSymbolTable::set(string varname) output << "\n" << varname << "=[];\n"; for (it = tmpsymboltable.begin(); it!= tmpsymboltable.end(); it++) { - if (SymbolTable::isReferenced(*it) == eReferenced) + if (symbol_table->isReferenced(*it) == eReferenced) { output << varname << " = "; output << interfaces::strvcat(varname,"'"+*it+"'")+";\n"; diff --git a/parser.src/VariableTable.cc b/parser.src/VariableTable.cc index 5c9375ea1..354cae099 100644 --- a/parser.src/VariableTable.cc +++ b/parser.src/VariableTable.cc @@ -10,14 +10,11 @@ using namespace std; //------------------------------------------------------------------------------ #include "VariableTable.hh" -//------------------------------------------------------------------------------ -map VariableTable::mVariableTable; -vector VariableTable::mVariableIndex; -vector VariableTable::mSortedVariableID; -vector VariableTable::mPrintFormatIndex; -void (* VariableTable::error) (const char* ) = NULL; -//------------------------------------------------------------------------------ -VariableTable::VariableTable() + +VariableTable::VariableTable(const SymbolTable &symbol_table_arg, + ModelParameters &mod_param_arg) : + symbol_table(symbol_table_arg), + mod_param(mod_param_arg) { // Empty } @@ -35,7 +32,7 @@ int VariableTable::AddVariable(string iName, int iLag) //Variable lVariable; varKey key; // Testing if symbol exists - if (!SymbolTable::Exist(iName)) + if (!symbol_table.Exist(iName)) { string msg = "unknown symbol: " + iName; (* error) (msg.c_str()); @@ -57,66 +54,45 @@ int VariableTable::AddVariable(string iName, int iLag) //mVariableTable[key] = lVariable; mVariableTable[key] = lVariableID; mVariableIndex.push_back(key); - // Setting lags field in symbol table - SymbolTable::AddLag(iName, iLag); // Setting variable numbers Type type = getType(lVariableID); if (type == eEndogenous) - ModelParameters::var_endo_nbr++; + mod_param.var_endo_nbr++; if (type == eExogenous) - ModelParameters::var_exo_nbr++; + mod_param.var_exo_nbr++; if (type == eExogenousDet) - ModelParameters::var_exo_det_nbr++; + mod_param.var_exo_det_nbr++; // Setting Maximum and minimum lags - if (ModelParameters::max_lead < iLag) - { - ModelParameters::max_lead = iLag; - } - else if (-ModelParameters::max_lag > iLag) - { - ModelParameters::max_lag = -iLag; - } + if (mod_param.max_lead < iLag) + mod_param.max_lead = iLag; + else if (-mod_param.max_lag > iLag) + mod_param.max_lag = -iLag; + switch(type) { case eEndogenous: - if (ModelParameters::max_endo_lead < iLag) - { - ModelParameters::max_endo_lead = iLag; - } - else if (-ModelParameters::max_endo_lag > iLag) - { - ModelParameters::max_endo_lag = -iLag; - } + if (mod_param.max_endo_lead < iLag) + mod_param.max_endo_lead = iLag; + else if (-mod_param.max_endo_lag > iLag) + mod_param.max_endo_lag = -iLag; break; case eExogenous: - if (ModelParameters::max_exo_lead < iLag) - { - ModelParameters::max_exo_lead = iLag; - } - else if (-ModelParameters::max_exo_lag > iLag) - { - ModelParameters::max_exo_lag = -iLag; - } + if (mod_param.max_exo_lead < iLag) + mod_param.max_exo_lead = iLag; + else if (-mod_param.max_exo_lag > iLag) + mod_param.max_exo_lag = -iLag; break; case eExogenousDet: - if (ModelParameters::max_exo_det_lead < iLag) - { - ModelParameters::max_exo_det_lead = iLag; - } - else if (-ModelParameters::max_exo_det_lag > iLag) - { - ModelParameters::max_exo_det_lag = -iLag; - } + if (mod_param.max_exo_det_lead < iLag) + mod_param.max_exo_det_lead = iLag; + else if (-mod_param.max_exo_det_lag > iLag) + mod_param.max_exo_det_lag = -iLag; break; case eRecursiveVariable: - if (ModelParameters::max_recur_lead < iLag) - { - ModelParameters::max_recur_lead = iLag; - } - else if (-ModelParameters::max_recur_lag > iLag) - { - ModelParameters::max_recur_lag = -iLag; - } + if (mod_param.max_recur_lead < iLag) + mod_param.max_recur_lead = iLag; + else if (-mod_param.max_recur_lag > iLag) + mod_param.max_recur_lag = -iLag; break; default: ; @@ -149,7 +125,7 @@ void VariableTable::decSymbolID(string iName, int id, int iLag, Type iType) } //------------------------------------------------------------------------------ -void VariableTable::Sort(void) +void VariableTable::Sort() { varKey key; int variable; @@ -175,7 +151,7 @@ void VariableTable::Sort(void) IDs.push_back(getSymbolID(variable)); Types.push_back(getType(variable)); Lags.push_back(key.second); - unsigned long long int lag = Lags[id]+ModelParameters::max_lag; + unsigned long long int lag = Lags[id]+mod_param.max_lag; lag = lag << (4*sizeof(int)); unsigned long long int type = Types[id]; type = type << 8*sizeof(int); diff --git a/parser.src/include/ComputingTasks.hh b/parser.src/include/ComputingTasks.hh index 73dfa08e8..a37826ccd 100644 --- a/parser.src/include/ComputingTasks.hh +++ b/parser.src/include/ComputingTasks.hh @@ -62,10 +62,12 @@ class ComputingTasks private : //! Output of this class std::ostringstream *output; + //! A reference to the symbol table + const SymbolTable &symbol_table; public : //! Constructor - ComputingTasks(); + ComputingTasks(const SymbolTable &symbol_table_arg); //! Destructor ~ComputingTasks(); /*! Pointer to error function of parser class */ @@ -144,7 +146,7 @@ public : void set(void); - static std::string get(void); + std::string get(void); }; //------------------------------------------------------------------------------ #endif diff --git a/parser.src/include/DataTree.hh b/parser.src/include/DataTree.hh index 8da9baf00..f32fd455f 100644 --- a/parser.src/include/DataTree.hh +++ b/parser.src/include/DataTree.hh @@ -32,6 +32,11 @@ typedef TreeList::iterator TreeIterator; class DataTree { protected : + //! A reference to the symbol table + SymbolTable &symbol_table; + //! A reference to the variable table + VariableTable &variable_table; + /*! A list of structures "token" */ TreeList mModelTree; /*! matches key with entry id in list of token */ @@ -52,14 +57,14 @@ protected : inline NodeID getIDOfToken(const MToken &iToken); public : /*! Flag for empty operator (final toekn) */ - static const int NoOpCode; - static const NodeID NullID; - static const NodeID Zero; - static const NodeID One; - static const NodeID MinusOne; - static const NodeID ZeroEqZero; + const int NoOpCode; + const NodeID NullID; + NodeID Zero; + NodeID One; + NodeID MinusOne; + NodeID ZeroEqZero; /*! Type of output 0 for C and 1 for Matlab (default) , also used as matrix index offset*/ - static int offset; + int offset; /*! Pointer to error function of parser class */ void (* error) (const char* m); /*! Increment reference count of given token */ @@ -118,7 +123,7 @@ public : inline NodeID AddAssign(NodeID iArg1, NodeID iArg2); public : /*! Constructor */ - DataTree(); + DataTree(SymbolTable &symbol_table_arg, VariableTable &variable_table_arg); /*! Destructor */ ~DataTree(); }; @@ -213,22 +218,22 @@ inline NodeID DataTree::AddTerminal(std::string iArgName, int iLag) int id; Type type; - if (!SymbolTable::Exist(iArgName)) + if (!symbol_table.Exist(iArgName)) { std::string msg = "unknown symbol: " + iArgName; (* error) (msg.c_str()); exit(-1); } - type = SymbolTable::getType(iArgName); + type = symbol_table.getType(iArgName); if (type != eUNDEF) { - SymbolTable::SetReferenced(iArgName); + symbol_table.SetReferenced(iArgName); if (type == eEndogenous || type == eExogenousDet || type == eExogenous || type == eRecursiveVariable) { - id = VariableTable::getID(iArgName,iLag); + id = variable_table.getID(iArgName,iLag); if (id == -1) { std::string msg = "unknown variable " + iArgName; @@ -237,7 +242,7 @@ inline NodeID DataTree::AddTerminal(std::string iArgName, int iLag) } } else - id = SymbolTable::getID(iArgName); + id = symbol_table.getID(iArgName); } else @@ -751,7 +756,7 @@ inline NodeID DataTree::AddSqRt(NodeID iArg1) } } -inline NodeID DataTree::AddEqual(NodeID iArg1, NodeID iArg2=Zero) +inline NodeID DataTree::AddEqual(NodeID iArg1, NodeID iArg2) { if (iArg1 == Zero && iArg2 == Zero) return ZeroEqZero; @@ -767,7 +772,7 @@ inline NodeID DataTree::AddEqual(NodeID iArg1, NodeID iArg2=Zero) } } -inline NodeID DataTree::AddAssign(NodeID iArg1, NodeID iArg2=Zero) +inline NodeID DataTree::AddAssign(NodeID iArg1, NodeID iArg2) { MToken lToken(iArg1, eTempResult, iArg2, token::ASSIGN); diff --git a/parser.src/include/Expression.hh b/parser.src/include/Expression.hh index 62d79a1d7..dfbd12639 100644 --- a/parser.src/include/Expression.hh +++ b/parser.src/include/Expression.hh @@ -49,13 +49,17 @@ private : /*! Operator table : names and precedences */ OperatorTable operator_table; /*! Output string of the class */ - static std::ostringstream output; + std::ostringstream output; + //! Pointer to numerical constants table + NumericalConstants *num_constants; public : /*! Constructor */ Expression(); /*! Destructor */ ~Expression(); + //! Set numerical constants pointer + void setNumericalConstants(NumericalConstants *num_constants_arg); /*! Adds binary token to expression list */ int AddToken(int id1,Type type1, int id2,Type type2,int op_code); /*! Adds unary token to expression list */ @@ -63,13 +67,13 @@ public : /*! Adds unkown function to expression list */ int AddToken(int id1,Type type1, std::string ufunction); /*! Returns output string */ - static std::string get(void); + std::string get(); /*! Clear expression list */ void clear(void); /*! Print expression to output string */ void set(void); /*! Gets output argument name */ - static std::string getArgument(Type type,int id); + std::string getArgument(Type type, int id); }; //------------------------------------------------------------------------------ #endif diff --git a/parser.src/include/ModFile.hh b/parser.src/include/ModFile.hh new file mode 100644 index 000000000..1c989857e --- /dev/null +++ b/parser.src/include/ModFile.hh @@ -0,0 +1,44 @@ +#ifndef _MOD_FILE_HH +#define _MOD_FILE_HH + +#include "ModelParameters.hh" +#include "SymbolTable.hh" +#include "NumericalConstants.hh" +#include "NumericalInitialization.hh" +#include "Shocks.hh" +#include "SigmaeInitialization.hh" +#include "ComputingTasks.hh" +#include "ModelTree.hh" +#include "VariableTable.hh" + +//! The abstract representation of a "mod" file +class ModFile +{ +public: + //! Constructor + ModFile(); + //! Model parameters + ModelParameters model_parameters; + //! Symbol table + SymbolTable symbol_table; + //! Variable table + VariableTable variable_table; + //! Numerical constants + NumericalConstants num_constants; + //! Numerical initalisations + NumericalInitialization numerical_initialization; + //! Shocks instructions + Shocks shocks; + //! Sigma_e instructions + SigmaeInitialization sigmae; + //! Computing tasks instructions + ComputingTasks computing_tasks; + //! Model equations and their derivatives + ModelTree model_tree; + //! Option order + int order; + //! Option linear + int linear; +}; + +#endif // ! MOD_FILE_HH diff --git a/parser.src/include/ModelParameters.hh b/parser.src/include/ModelParameters.hh index dbcbbf95a..3ef12e910 100644 --- a/parser.src/include/ModelParameters.hh +++ b/parser.src/include/ModelParameters.hh @@ -14,40 +14,38 @@ class ModelParameters { public : - /*! Constructor */ + //! Constructor ModelParameters(); - /*! Destructor */ - ~ModelParameters(); /*! Number of equations*/ - static int eq_nbr; + int eq_nbr; /*! Number of declared Exogenous variables */ - static int exo_nbr; + int exo_nbr; /*! Number of Exogenous variables that apear in model equations*/ - static int var_exo_nbr; + int var_exo_nbr; /*! Number of deterministic Exogenous variables */ - static int exo_det_nbr; - static int var_exo_det_nbr; + int exo_det_nbr; + int var_exo_det_nbr; /*! Number of declared Endogenous variables */ - static int endo_nbr; + int endo_nbr; /*! Number of Endogenous variables that apear in model equations*/ - static int var_endo_nbr; + int var_endo_nbr; /*! Number of parameters */ - static int parameter_nbr; + int parameter_nbr; /*! Number of local parameters */ - static int local_parameter_nbr; + int local_parameter_nbr; /*! Number of recursive variables */ - static int recur_nbr; + int recur_nbr; - static int max_lag; - static int max_lead; - static int max_endo_lag; - static int max_endo_lead; - static int max_exo_lag; - static int max_exo_lead; - static int max_exo_det_lag; - static int max_exo_det_lead; - static int max_recur_lag; - static int max_recur_lead; + int max_lag; + int max_lead; + int max_endo_lag; + int max_endo_lead; + int max_exo_lag; + int max_exo_lead; + int max_exo_det_lag; + int max_exo_det_lead; + int max_recur_lag; + int max_recur_lead; }; //------------------------------------------------------------------------------ #endif diff --git a/parser.src/include/ModelTree.hh b/parser.src/include/ModelTree.hh index 8890f2f89..ba5a40e27 100644 --- a/parser.src/include/ModelTree.hh +++ b/parser.src/include/ModelTree.hh @@ -35,7 +35,7 @@ private : /*! Output for dynamic model */ std::ostringstream DynamicOutput; /*! Output for main file */ - static std::ostringstream output; + std::ostringstream output; /*! Output file stream for static model */ std::ofstream mStaticModelFile; /*! Output file stream for dynamic model */ @@ -49,6 +49,10 @@ private : char lpar, rpar; /*! Name of parameter variables ("params" for C output, and M_.params for Matlab) */ std::string param_name; + //! Reference to model parameters + ModelParameters &mod_param; + //! Reference to numerical constants table + const NumericalConstants &num_constants; private : /*! Computes argument derivative */ @@ -66,7 +70,7 @@ public : /*! When Hessian is writen this flag is set to true */ bool computeHessian; /*! Constructor */ - ModelTree(); + ModelTree(SymbolTable &symbol_table_arg, VariableTable &variable_table_arg, ModelParameters &mod_param_arg, const NumericalConstants &num_constants); /*! Destructor */ ~ModelTree(); /*! Opens output M files (1st and 2nd derivatives) */ @@ -94,7 +98,7 @@ public : /*! Writes initialization of various Matlab variables */ void ModelInitialization(void); /*! Returns string output for main file */ - static std::string get(); + std::string get(); }; //------------------------------------------------------------------------------ #endif diff --git a/parser.src/include/ModelTypes.hh b/parser.src/include/ModelTypes.hh index 11f7d87d7..d7efbcd5d 100644 --- a/parser.src/include/ModelTypes.hh +++ b/parser.src/include/ModelTypes.hh @@ -89,7 +89,9 @@ struct MTokenLess } }; -//------------------------------------------------------------------------------ +// For MetaToken::getDerivativeAddress() +class ModelTree; + /*! \struct MetaToken \brief Meta token structure @@ -205,11 +207,15 @@ public : d1[iVarID] = iDerivative; } - /*! Get derivative with respect to iVarID. - Defined in ModelTree.cc because it needs DataTree::Zero and DataTree::ZeroEqZero + //! Get derivative with respect to iVarID. + /* + Defined in ModelTree.cc because it needs a reference to the enclosing ModelTree, and is only used in that source file. + + \param iVarID variable with respect to get derivative + \param model_tree enclosing ModelTree */ - inline NodeID getDerivativeAddress(int iVarID); + inline NodeID getDerivativeAddress(int iVarID, const ModelTree &model_tree) const; }; //------------------------------------------------------------------------------ /*! Equation type enum */ diff --git a/parser.src/include/NumericalConstants.hh b/parser.src/include/NumericalConstants.hh index 7fcb1b3b8..4610f7ef6 100644 --- a/parser.src/include/NumericalConstants.hh +++ b/parser.src/include/NumericalConstants.hh @@ -19,18 +19,18 @@ class NumericalConstants { private : /*! Vector of numerical constants */ - static std::vector mNumericalConstants; + std::vector mNumericalConstants; //! Map matching constants to their id - static std::map > numConstantsIndex; + std::map > numConstantsIndex; public : /*! Construcor */ NumericalConstants(); /*! Destructor */ ~NumericalConstants(); /*! Adds a constant to mNumericalConstants */ - static int AddConstant(std::string iConst); + int AddConstant(std::string iConst); /*! Gets a constant form mNumericalConstants */ - static std::string get(int iID); + std::string get(int iID) const; }; //------------------------------------------------------------------------------ #endif diff --git a/parser.src/include/NumericalInitialization.hh b/parser.src/include/NumericalInitialization.hh index 7873031ce..241fa1484 100644 --- a/parser.src/include/NumericalInitialization.hh +++ b/parser.src/include/NumericalInitialization.hh @@ -21,9 +21,13 @@ class NumericalInitialization private : /*! Output of this class */ std::ostringstream *output; + //! Reference to symbol table + const SymbolTable &symbol_table; + //! Reference to model parameters + const ModelParameters &mod_param; public : /*! Constructor */ - NumericalInitialization(); + NumericalInitialization(const SymbolTable &symbol_table_arg, const ModelParameters &mod_param_arg); /*! Destrcutor */ ~NumericalInitialization(); /*! Pointer to error function of parser class */ diff --git a/parser.src/include/OutputFile.hh b/parser.src/include/OutputFile.hh index d4829ad74..a837e531b 100644 --- a/parser.src/include/OutputFile.hh +++ b/parser.src/include/OutputFile.hh @@ -9,6 +9,8 @@ //------------------------------------------------------------------------------ #include #include + +#include "ModFile.hh" //------------------------------------------------------------------------------ /*! \class OutputFile @@ -28,9 +30,9 @@ public : /*! Destructor */ ~OutputFile(); /*! Opens a given file and writes some initialization */ - void Open(std::string iFileName); + void Open(std::string iFileName, ModFile *mod_file); /*! Writes output data from SymbolTable and passed strings to output file */ - void Save(std::ostringstream& iOutput); + void Save(std::ostringstream& iOutput, ModFile *mod_file); }; //------------------------------------------------------------------------------ #endif diff --git a/parser.src/include/ParsingDriver.hh b/parser.src/include/ParsingDriver.hh index 99a382de5..8b3e93346 100644 --- a/parser.src/include/ParsingDriver.hh +++ b/parser.src/include/ParsingDriver.hh @@ -1,20 +1,13 @@ #ifndef _PARSING_DRIVER_HH #define _PARSING_DRIVER_HH -#include #include -#include "ModelParameters.hh" -#include "SymbolTable.hh" +#include "ModFile.hh" #include "Expression.hh" -#include "NumericalInitialization.hh" -#include "ModelTree.hh" -#include "VariableTable.hh" -#include "Shocks.hh" -#include "SigmaeInitialization.hh" -#include "ComputingTasks.hh" #include "TmpSymbolTable.hh" #include "DynareBison.hh" +#include "ComputingTasks.hh" using namespace std; @@ -46,49 +39,31 @@ private: //! Checks that a given symbol exists, and stops with an error message if it doesn't void check_symbol_existence(const string &name); - //! Stores model parameters - ModelParameters model_parameters; - //! Stores symbol table - SymbolTable symbol_table; //! Stores expressions Expression expression; - //! Stores numerical constants - NumericalConstants num_constants; - //! Handles numerical initalisations - NumericalInitialization numerical_initialization; - //! Handles shock command - Shocks shocks; - //! Handles sigma_e command - SigmaeInitialization sigmae; - //! Handles computing tasks commands - ComputingTasks computing_tasks; //! Stores temporary symbol table TmpSymbolTable tmp_symbol_table; - //! Stores model tree - ModelTree model_tree; - //! Stores variable table - VariableTable variable_table; //! Stores operator table OperatorTable op_table; - //! Value of option order - int order; - //! Value of option linear - int linear; -public: + //! The mod file representation constructed by this ParsingDriver + ModFile *mod_file; + //! Reference to output string ostringstream *output; - //! Estimation parameters - EstimationParams estim_params; +public: //! Constructor ParsingDriver(); //! Destructor virtual ~ParsingDriver(); - //! Starts parsing - /*! \param f Name of file to parse */ - void parse(const string &f); + //! Starts parsing, and constructs the MOD file representation + /*! \param f Name of file to parse + + The returned pointer should be deleted after use. + */ + ModFile *parse(const string &f); //! Name of file being parsed string file; @@ -102,6 +77,9 @@ public: /*! If set to true before calling parse(), the bison parser will dump debugging information. Defaults to false. */ bool trace_parsing; + //! Estimation parameters + EstimationParams estim_params; + //! Error handler with location void error(const yy::parser::location_type &l, const string &m); //! Error handler without location @@ -118,10 +96,10 @@ public: //! Sets reference to output string void setoutput(ostringstream *ostr); - //! Remove unused symbol from symbol table - void check_model(); //! Executes final instructions void finish(); + //! Check if a given symbol exists in the parsing context + bool exists_symbol(const char *s); //! Sets variable offset of ModelTree class to use C output void use_dll(); //! Declares an endogenous variable by adding it to SymbolTable @@ -257,7 +235,9 @@ public: void add_mc_filename(string *filename, string *prior = new string("1")); void run_model_comparison(); //! Writes token "arg1=arg2" to model tree - NodeID add_model_equal(NodeID arg1, NodeID arg2 = ModelTree::Zero); + NodeID add_model_equal(NodeID arg1, NodeID arg2); + //! Writes token "arg=0" to model tree + NodeID add_model_equal_with_zero_rhs(NodeID arg); //! Writes token "arg1+arg2" to model tree NodeID add_model_plus(NodeID arg1, NodeID arg2); //! Writes token "arg1-arg2" to model tree @@ -302,6 +282,8 @@ public: NodeID add_model_atanh(NodeID arg1); //! Writes token "sqrt(arg1)" to model tree NodeID add_model_sqrt(NodeID arg1); + //! Adds a native statement + void add_native(const char *s); }; #endif // ! PARSING_DRIVER_HH diff --git a/parser.src/include/Shocks.hh b/parser.src/include/Shocks.hh index 9890cf923..1f760004e 100644 --- a/parser.src/include/Shocks.hh +++ b/parser.src/include/Shocks.hh @@ -21,6 +21,7 @@ class Shocks { private : int mshock_flag; + int exo_det_length; /*! \class ShockElement \brief Shock element strcuture diff --git a/parser.src/include/SymbolTable.hh b/parser.src/include/SymbolTable.hh index b6014e1df..2a158c3ae 100644 --- a/parser.src/include/SymbolTable.hh +++ b/parser.src/include/SymbolTable.hh @@ -10,7 +10,6 @@ #include #include #include -#include //------------------------------------------------------------------------------ #include "ModelParameters.hh" #include "SymbolTableTypes.hh" @@ -19,12 +18,11 @@ \class SymbolTable \brief This class keeps track of symbols */ - class SymbolTable { - -private : - static std::ostringstream output; +private: + //! A reference to the model parameters + ModelParameters &mod_param; /*! Adds symbol into symbol table \param name a string. \param type a Type struct. @@ -35,64 +33,60 @@ private : - set Name and Type - increase corresponding counter in ModelParameters class */ - static int AddSymbol(std::string name,Type type, std::string tex_name); -protected : + int AddSymbol(std::string name, Type type, std::string tex_name); /*! Symbol table map */ - static std::map > symboltable; + std::map > symboltable; + //! Typedef for const iterator on symboltable map + typedef std::map >::const_iterator symboltable_const_iterator; /*! Symbol name table indexed by type and ID */ - static std::vector< std::vector > name_table; - static std::vector< std::vector > tex_name_table; -protected : + std::vector< std::vector > name_table; + std::vector< std::vector > tex_name_table; /*! Changes type of a symbol */ - static void ResetType(std::string name,Type new_type); + void ResetType(std::string name, Type new_type); public : /*! Constructor */ - SymbolTable(); + SymbolTable(ModelParameters &mod_param_arg); /*! Destructor*/ ~SymbolTable(); /*! Pointer to error function of parser class */ - static void (* error) (const char* m); + void (* error) (const char* m); /*! Adds a symbol apearing in declaration - warning if symbol is already set with same type - error if symbol is already set with different type - set name, type - increase corresponding counter in ModelParameters */ - static int AddSymbolDeclar(std::string name,Type type, std::string tex_name); + int AddSymbolDeclar(std::string name, Type type, std::string tex_name); /*! Adds symbol range */ - static void AddSymbolRange(std::string name,int nbr,Type type, std::string tex_name); - /*! Adds a lag to field lags */ - static void AddLag(std::string name,int lag); + void AddSymbolRange(std::string name, int nbr, Type type, std::string tex_name); /*! Sets a symbol as referenced */ - static void SetReferenced(std::string name); + void SetReferenced(std::string name); /*! Return eReferenced if symbol is referenced eNotReferenced otherwise*/ - static Reference isReferenced(std::string name); + Reference isReferenced(const std::string &name) const; /*! Tests if symbol exists in symbol table \return true if exists, false outherwise */ - inline static bool Exist(std::string name); + inline bool Exist(const std::string &name) const; /*! Gets name by type and ID */ - inline static std::string getNameByID(Type type,int id); + inline std::string getNameByID(Type type, int id); /*! Gets tex name by type and ID */ - inline static std::string getTexNameByID(Type type,int id); + inline std::string getTexNameByID(Type type, int id); /*! Gets type by name */ - inline static Type getType(std::string name); + inline Type getType(const std::string &name) const; /*! Gets ID by name */ - inline static int getID(std::string name); + inline int getID(const std::string &name) const; /*! Gets output string of this class */ - static std::string get(); + std::string get(); +#if 0 // Commented out on 27/11/2006, SV /*! Checks if symbols are used in model equations, removes unused symbol */ void clean(); - void erase_local_parameters(); +#endif // Comment }; -inline bool SymbolTable::Exist(std::string name) -{ - std::map >::iterator iter; - iter = symboltable.find(name); - //Testing if symbol exists - if (iter == symboltable.end()) return false; - else return true; +inline bool SymbolTable::Exist(const std::string &name) const +{ + symboltable_const_iterator iter = symboltable.find(name); + return (iter != symboltable.end()); } //------------------------------------------------------------------------------ @@ -112,21 +106,23 @@ inline std::string SymbolTable::getTexNameByID(Type type,int id) } //------------------------------------------------------------------------------ -inline Type SymbolTable::getType(std::string name) +inline Type SymbolTable::getType(const std::string &name) const { - if (Exist(name)) - return(symboltable[name].type); - else + symboltable_const_iterator iter = symboltable.find(name); + if (iter == symboltable.end()) return eUNDEF; + else + return iter->second.type; } //------------------------------------------------------------------------------ -inline int SymbolTable::getID(std::string name) +inline int SymbolTable::getID(const std::string &name) const { - if (Exist(name)) - return(symboltable[name].id); - else + symboltable_const_iterator iter = symboltable.find(name); + if (iter == symboltable.end()) return -1; + else + return(iter->second.id); } //------------------------------------------------------------------------------ diff --git a/parser.src/include/SymbolTableTypes.hh b/parser.src/include/SymbolTableTypes.hh index f3e29c069..c24454367 100644 --- a/parser.src/include/SymbolTableTypes.hh +++ b/parser.src/include/SymbolTableTypes.hh @@ -40,8 +40,7 @@ struct Symbol int id; /*! Symbol reference flag */ Reference referenced; - /*! Lags of symbol if it is a variable */ - std::vector lags; + Symbol() { type = eUNDEF; diff --git a/parser.src/include/TmpSymbolTable.hh b/parser.src/include/TmpSymbolTable.hh index 8e235c47d..8b2fbaec1 100644 --- a/parser.src/include/TmpSymbolTable.hh +++ b/parser.src/include/TmpSymbolTable.hh @@ -9,7 +9,9 @@ //------------------------------------------------------------------------------ #include #include -//------------------------------------------------------------------------------ + +#include "SymbolTable.hh" + /*! \class TmpSymbolTable \brief Defines temparary symbol table used with computing tasks @@ -23,13 +25,15 @@ private : std::list NameTable; /*! Output of this class */ std::ostringstream output; + //! Pointer to global symbol table + SymbolTable *symbol_table; public : /*! Constrcutor */ TmpSymbolTable(); - /*! Copy constructor */ - TmpSymbolTable(const TmpSymbolTable &tst); /*! Destructor*/ ~TmpSymbolTable(); + //! Sets global symbol table pointer + void setGlobalSymbolTable(SymbolTable *symbol_table_arg); /*! Pointer to error function of parser class */ void (* error) (const char* m); /*! Adds a temp symbol */ diff --git a/parser.src/include/VariableTable.hh b/parser.src/include/VariableTable.hh index 9dcb18c98..b2294d491 100644 --- a/parser.src/include/VariableTable.hh +++ b/parser.src/include/VariableTable.hh @@ -37,18 +37,21 @@ typedef std::pair varKey; class VariableTable { private : + //! A reference to the symbol table + const SymbolTable &symbol_table; + //! A reference to model parameters + ModelParameters &mod_param; /*! Variable table data */ - //static std::map mVariableTable; - static std::map mVariableTable; + std::map mVariableTable; /*! Index (IDs) of variables in variable table */ - static std::vector mVariableIndex; + std::vector mVariableIndex; /*! Variable IDs of sorted variable table */ - static std::vector mSortedVariableID; + std::vector mSortedVariableID; /*! Output index for variable table */ - static std::vector mPrintFormatIndex; + std::vector mPrintFormatIndex; public : /*! */ - VariableTable(); + VariableTable(const SymbolTable &symbol_table_arg, ModelParameters &mod_param_arg); /*! */ ~VariableTable(); /*! Find type and ID in SymbolTable @@ -56,27 +59,27 @@ public : - Make variable - Push variable on variabletable */ - static int AddVariable(std::string iName, int iLag); + int AddVariable(std::string iName, int iLag); /*! Pointer to error function of parser class */ - static void (* error) (const char* m); + void (* error) (const char* m); /*! Decremente a symbol id of a variable */ - static void decSymbolID(std::string iName, int id, int iLag, Type iType); + void decSymbolID(std::string iName, int id, int iLag, Type iType); /*! Return VariableTable[name,lag].variable_id */ - inline static int getID(std::string iName, int iLag); + inline int getID(std::string iName, int iLag); /*! Return lag of variable */ - inline static int getLag(int iID); + inline int getLag(int iID); /*! Return symbol ID of variable */ - inline static int getSymbolID(int ivarID); + inline int getSymbolID(int ivarID); /*! Gets varibale type */ - inline static Type getType(int ivarID); + inline Type getType(int ivarID); /*! Gets nomber of variables in mVariableTable */ - inline static int size(void); + inline int size(); /*! Gets variable ID of sorted variable table */ - inline static int getSortID(int); + inline int getSortID(int); /*! Return variable index to print in format : y(index) or oo_.y_simul(index) ... */ - inline static int getPrintIndex(int iVarID); + inline int getPrintIndex(int iVarID); /*! Sorts variable table */ - static void Sort(void); + void Sort(); }; inline int VariableTable::getSortID(int iVarID) { @@ -107,7 +110,7 @@ inline Type VariableTable::getType(int ivarID) { varKey key = mVariableIndex[ivarID]; //return mVariableTable[key].type; - return SymbolTable::getType(key.first); + return symbol_table.getType(key.first); } //------------------------------------------------------------------------------ @@ -115,7 +118,7 @@ inline int VariableTable::getSymbolID(int ivarID) { varKey key = mVariableIndex[ivarID]; //return mVariableTable[key].symbol_id; - return SymbolTable::getID(key.first); + return symbol_table.getID(key.first); } //------------------------------------------------------------------------------ @@ -125,12 +128,9 @@ inline int VariableTable::getLag(int iID) } //------------------------------------------------------------------------------ -inline int VariableTable::size(void) +inline int VariableTable::size() { return mVariableTable.size(); } -//------------------------------------------------------------------------------ - -//------------------------------------------------------------------------------ #endif