stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

v4 parser: created ModFile class, which is the abstract representation of a mod file; removed all static variables 

git-svn-id: https://www.dynare.org/svn/dynare/dynare_v4@1110 ac1d8469-bf42-47a9-8791-bf33cf982152
time-shift
sebastien 2006-11-28 11:56:02 +00:00
parent 442bf232b0
commit d5ac5b1fbd
34 changed files with 711 additions and 836 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
parser.src/ComputingTasks.cc
View File

@ -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";
}

24
parser.src/DataTree.cc
View File

@ -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 <NodeID> (0), eNumericalConstant, NULL, -1);
const NodeID DataTree::One = new MetaToken(reinterpret_cast <NodeID> (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 <NodeID> (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 <NodeID> (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;

7
parser.src/DynareBison.yy
View File

@ -331,11 +331,10 @@ typedef pair<int, Type> 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<int, Type> 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

8
parser.src/DynareFlex.ll
View File

@ -258,7 +258,7 @@ int sigma_e = 0;
otherwise it is a native statement until the end of the line
*/
<INITIAL>[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);
}
}
<INITIAL>. {BEGIN NATIVE; *(driver.output) << yytext;}
<INITIAL>. {BEGIN NATIVE; driver.add_native(yytext); }
/* NATIVE Block */
<NATIVE>.* {BEGIN INITIAL; *(driver.output) << yytext << endl;}
<NATIVE>.* {BEGIN INITIAL; driver.add_native(yytext); driver.add_native("\n"); }
<*>. {return yy::parser::token_type (yytext[0]);}

9
parser.src/DynareMain.cc
View File

@ -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;

15
parser.src/Expression.cc
View File

@ -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();
}

5
parser.src/Makefile
View File

@ -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

9
parser.src/ModFile.cc Normal file
View File

@ -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)
{
}

47
parser.src/ModelParameters.cc
View File

@ -3,41 +3,20 @@
\date 04/09/2004
\par This file implements the ModelParemeters class methodes.
*/
//------------------------------------------------------------------------------
#include <iostream>
#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
}
//------------------------------------------------------------------------------

255
parser.src/ModelTree.cc
View File

@ -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<int, NodeID, std::less<int> >::iterator iter = d1.find(iVarID);
std::map<int, NodeID, std::less<int> >::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<int> 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
//------------------------------------------------------------------------------

6
parser.src/NumericalConstants.cc
View File

@ -8,11 +8,7 @@
using namespace std;
//------------------------------------------------------------------------------
#include "NumericalConstants.hh"
//------------------------------------------------------------------------------
vector<string> NumericalConstants::mNumericalConstants;
map<string, int, less<string> > 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())
{

36
parser.src/NumericalInitialization.cc
View File

@ -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)
{

10
parser.src/OutputFile.cc
View File

@ -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();

351
parser.src/ParsingDriver.cc
View File

@ -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;
}

8
parser.src/Shocks.cc
View File

@ -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
}

140
parser.src/SymbolTable.cc
View File

@ -3,34 +3,26 @@
\date 04/09/2004
\par This file implements the SymbolTable class methodes.
*/
//------------------------------------------------------------------------------
#include <iostream>
#include <algorithm>
//------------------------------------------------------------------------------
#include <sstream>
#include "SymbolTable.hh"
#include "Interface.hh"
using namespace std;
//------------------------------------------------------------------------------
// = *(new symbolmap);
map<string, Symbol, less<string> > SymbolTable::symboltable;
vector< vector<string> > SymbolTable::name_table;
vector< vector<string> > 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<std::string, Symbol, std::less<std::string> >::iterator i = symboltable.begin();
for(; i != symboltable.end(); ++i)
{
if ((i->second).type == eLocalParameter)
{
symboltable.erase(i);
}
}
}
//------------------------------------------------------------------------------

22
parser.src/TmpSymbolTable.cc
View File

@ -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";

88
parser.src/VariableTable.cc
View File

@ -10,14 +10,11 @@
using namespace std;
//------------------------------------------------------------------------------
#include "VariableTable.hh"
//------------------------------------------------------------------------------
map<varKey,int> VariableTable::mVariableTable;
vector<varKey> VariableTable::mVariableIndex;
vector<int> VariableTable::mSortedVariableID;
vector<int> 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);

6
parser.src/include/ComputingTasks.hh
View File

@ -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

35
parser.src/include/DataTree.hh
View File

@ -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);

10
parser.src/include/Expression.hh
View File

@ -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

44
parser.src/include/ModFile.hh Normal file
View File

@ -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

44
parser.src/include/ModelParameters.hh
View File

@ -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

10
parser.src/include/ModelTree.hh
View File

@ -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

14
parser.src/include/ModelTypes.hh
View File

@ -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 */

8
parser.src/include/NumericalConstants.hh
View File

@ -19,18 +19,18 @@ class NumericalConstants
{
private :
/*! Vector of numerical constants */
static std::vector<std::string> mNumericalConstants;
std::vector<std::string> mNumericalConstants;
//! Map matching constants to their id
static std::map<std::string, int, std::less<std::string> > numConstantsIndex;
std::map<std::string, int, std::less<std::string> > 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

6
parser.src/include/NumericalInitialization.hh
View File

@ -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 */

6
parser.src/include/OutputFile.hh
View File

@ -9,6 +9,8 @@
//------------------------------------------------------------------------------
#include <fstream>
#include <string>
#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

62
parser.src/include/ParsingDriver.hh
View File

@ -1,20 +1,13 @@
#ifndef _PARSING_DRIVER_HH
#define _PARSING_DRIVER_HH
#include <sstream>
#include <iostream>
#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

1
parser.src/include/Shocks.hh
View File

@ -21,6 +21,7 @@ class Shocks
{
private :
int mshock_flag;
int exo_det_length;
/*!
\class ShockElement
\brief Shock element strcuture

80
parser.src/include/SymbolTable.hh
View File

@ -10,7 +10,6 @@
#include <map>
#include <string>
#include <vector>
#include <sstream>
//------------------------------------------------------------------------------
#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<std::string, Symbol, std::less<std::string> > symboltable;
std::map<std::string, Symbol, std::less<std::string> > symboltable;
//! Typedef for const iterator on symboltable map
typedef std::map<std::string, Symbol, std::less<std::string> >::const_iterator symboltable_const_iterator;
/*! Symbol name table indexed by type and ID */
static std::vector< std::vector<std::string> > name_table;
static std::vector< std::vector<std::string> > tex_name_table;
protected :
std::vector< std::vector<std::string> > name_table;
std::vector< std::vector<std::string> > 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<std::string, Symbol, std::less<std::string> >::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);
}
//------------------------------------------------------------------------------

3
parser.src/include/SymbolTableTypes.hh
View File

@ -40,8 +40,7 @@ struct Symbol
int id;
/*! Symbol reference flag */
Reference referenced;
/*! Lags of symbol if it is a variable */
std::vector<int> lags;
Symbol()
{
type = eUNDEF;

10
parser.src/include/TmpSymbolTable.hh
View File

@ -9,7 +9,9 @@
//------------------------------------------------------------------------------
#include <list>
#include <sstream>
//------------------------------------------------------------------------------
#include "SymbolTable.hh"
/*!
\class TmpSymbolTable
\brief Defines temparary symbol table used with computing tasks
@ -23,13 +25,15 @@ private :
std::list<std::string> 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 */

46
parser.src/include/VariableTable.hh
View File

@ -37,18 +37,21 @@ typedef std::pair<std::string, int> 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<varKey,Variable> mVariableTable;
static std::map<varKey,int> mVariableTable;
std::map<varKey,int> mVariableTable;
/*! Index (IDs) of variables in variable table */
static std::vector<varKey> mVariableIndex;
std::vector<varKey> mVariableIndex;
/*! Variable IDs of sorted variable table */
static std::vector<int> mSortedVariableID;
std::vector<int> mSortedVariableID;
/*! Output index for variable table */
static std::vector<int> mPrintFormatIndex;
std::vector<int> 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