v4: changing name of preprocessor directory

git-svn-id: https://www.dynare.org/svn/dynare/dynare_v4@1686 ac1d8469-bf42-47a9-8791-bf33cf982152

DataTree.cc

+/*
+ * Copyright (C) 2003-2008 Dynare Team
+ *
+ * This file is part of Dynare.
+ *
+ * Dynare is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Dynare is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+
+#include "DataTree.hh"
+
+DataTree::DataTree(SymbolTable &symbol_table_arg, NumericalConstants &num_constants_arg) :
+  symbol_table(symbol_table_arg),
+  num_constants(num_constants_arg),
+  node_counter(0),
+  variable_table(symbol_table_arg)
+{
+  Zero = AddNumConstant("0");
+  One = AddNumConstant("1");
+
+  MinusOne = AddUMinus(One);
+}
+
+DataTree::~DataTree()
+{
+  for (node_list_type::iterator it = node_list.begin(); it != node_list.end(); it++)
+    delete *it;
+}
+
+NodeID
+DataTree::AddNumConstant(const string &value)
+{
+  int id = num_constants.AddConstant(value);
+
+  num_const_node_map_type::iterator it = num_const_node_map.find(id);
+  if (it != num_const_node_map.end())
+    return it->second;
+  else
+    return new NumConstNode(*this, id);
+}
+
+NodeID
+DataTree::AddVariable(const string &name, int lag)
+{
+  int symb_id = symbol_table.getID(name);
+  Type type = symbol_table.getType(name);
+
+  variable_node_map_type::iterator it = variable_node_map.find(make_pair(make_pair(symb_id, type), lag));
+  if (it != variable_node_map.end())
+    return it->second;
+  else
+    return new VariableNode(*this, symb_id, type, lag);
+}
+
+NodeID
+DataTree::AddPlus(NodeID iArg1, NodeID iArg2)
+{
+  if (iArg1 != Zero && iArg2 != Zero)
+    {
+      // Simplify x+(-y) in x-y
+      UnaryOpNode *uarg2 = dynamic_cast<UnaryOpNode *>(iArg2);
+      if (uarg2 != NULL && uarg2->op_code == oUminus)
+        return AddMinus(iArg1, uarg2->arg);
+
+      // To treat commutativity of "+"
+      // Nodes iArg1 and iArg2 are sorted by index
+      if (iArg1->idx > iArg2->idx)
+        {
+          NodeID tmp = iArg1;
+          iArg1 = iArg2;
+          iArg2 = tmp;
+        }
+      return AddBinaryOp(iArg1, oPlus, iArg2);
+    }
+  else if (iArg1 != Zero)
+    return iArg1;
+  else if (iArg2 != Zero)
+    return iArg2;
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddMinus(NodeID iArg1, NodeID iArg2)
+{
+  if (iArg1 != Zero && iArg2 != Zero)
+    return AddBinaryOp(iArg1, oMinus, iArg2);
+  else if (iArg1 != Zero)
+    return iArg1;
+  else if (iArg2 != Zero)
+    return AddUMinus(iArg2);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddUMinus(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    {
+      // Simplify -(-x) in x
+      UnaryOpNode *uarg = dynamic_cast<UnaryOpNode *>(iArg1);
+      if (uarg != NULL && uarg->op_code == oUminus)
+        return uarg->arg;
+
+      return AddUnaryOp(oUminus, iArg1);
+    }
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddTimes(NodeID iArg1, NodeID iArg2)
+{
+  if (iArg1 == MinusOne)
+    return AddUMinus(iArg2);
+  else if (iArg2 == MinusOne)
+    return AddUMinus(iArg1);
+  else if (iArg1 != Zero && iArg1 != One && iArg2 != Zero && iArg2 != One)
+    {
+      // To treat commutativity of "*"
+      // Nodes iArg1 and iArg2 are sorted by index
+      if (iArg1->idx > iArg2->idx)
+        {
+          NodeID tmp = iArg1;
+          iArg1 = iArg2;
+          iArg2 = tmp;
+        }
+      return AddBinaryOp(iArg1, oTimes, iArg2);
+    }
+  else if (iArg1 != Zero && iArg1 != One && iArg2 == One)
+    return iArg1;
+  else if (iArg2 != Zero && iArg2 != One && iArg1 == One)
+    return iArg2;
+  else if (iArg2 == One && iArg1 == One)
+    return One;
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddDivide(NodeID iArg1, NodeID iArg2)
+{
+  if (iArg1 != Zero && iArg2 != Zero && iArg2 != One)
+    return AddBinaryOp(iArg1, oDivide, iArg2);
+  else if (iArg2 == One)
+    return iArg1;
+  else if (iArg1 == Zero && iArg2 != Zero)
+    return Zero;
+  else
+    {
+      cerr << "Division by zero!" << endl;
+      exit(-1);
+    }
+}
+
+NodeID
+DataTree::AddLess(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oLess, iArg2);
+}
+
+NodeID
+DataTree::AddGreater(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oGreater, iArg2);
+}
+
+NodeID
+DataTree::AddLessEqual(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oLessEqual, iArg2);
+}
+
+NodeID
+DataTree::AddGreaterEqual(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oGreaterEqual, iArg2);
+}
+
+NodeID
+DataTree::AddEqualEqual(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oEqualEqual, iArg2);
+}
+
+NodeID
+DataTree::AddDifferent(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oDifferent, iArg2);
+}
+
+NodeID
+DataTree::AddPower(NodeID iArg1, NodeID iArg2)
+{
+  if (iArg1 != Zero && iArg2 != Zero && iArg2 != One)
+    return AddBinaryOp(iArg1, oPower, iArg2);
+  else if (iArg2 == One)
+    return iArg1;
+  else if (iArg2 == Zero)
+    return One;
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddExp(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oExp, iArg1);
+  else
+    return One;
+}
+
+NodeID
+DataTree::AddLog(NodeID iArg1)
+{
+  if (iArg1 != Zero && iArg1 != One)
+    return AddUnaryOp(oLog, iArg1);
+  else if (iArg1 == One)
+    return Zero;
+  else
+    {
+      cerr << "log(0) isn't available" << endl;
+      exit(-1);
+    }
+}
+
+NodeID DataTree::AddLog10(NodeID iArg1)
+{
+  if (iArg1 != Zero && iArg1 != One)
+    return AddUnaryOp(oLog10, iArg1);
+  else if (iArg1 == One)
+    return Zero;
+  else
+    {
+      cerr << "log10(0) isn't available" << endl;
+      exit(-1);
+    }
+}
+
+NodeID
+DataTree::AddCos(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oCos, iArg1);
+  else
+    return One;
+}
+
+NodeID
+DataTree::AddSin(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oSin, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddTan(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oTan, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddACos(NodeID iArg1)
+{
+  if (iArg1 != One)
+    return AddUnaryOp(oAcos, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddASin(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oAsin, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddATan(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oAtan, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddCosH(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oCosh, iArg1);
+  else
+    return One;
+}
+
+NodeID
+DataTree::AddSinH(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oSinh, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddTanH(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oTanh, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddACosH(NodeID iArg1)
+{
+  if (iArg1 != One)
+    return AddUnaryOp(oAcosh, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddASinH(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oAsinh, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddATanH(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oAtanh, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddSqRt(NodeID iArg1)
+{
+  if (iArg1 != Zero)
+    return AddUnaryOp(oSqrt, iArg1);
+  else
+    return Zero;
+}
+
+NodeID
+DataTree::AddMaX(NodeID iArg1, NodeID iArg2)
+{
+    return AddBinaryOp(iArg1, oMax, iArg2);
+}
+
+NodeID
+DataTree::AddMin(NodeID iArg1, NodeID iArg2)
+{
+    return AddBinaryOp(iArg1, oMin, iArg2);
+}
+
+NodeID
+DataTree::AddNormcdf(NodeID iArg1, NodeID iArg2, NodeID iArg3)
+{
+  return AddTrinaryOp(iArg1, oNormcdf, iArg2, iArg3);
+}
+
+NodeID
+DataTree::AddEqual(NodeID iArg1, NodeID iArg2)
+{
+  return AddBinaryOp(iArg1, oEqual, iArg2);
+}
+
+void
+DataTree::AddLocalParameter(const string &name, NodeID value) throw (LocalParameterException)
+{
+  int id = symbol_table.getID(name);
+
+  // Throw an exception if symbol already declared
+  map<int, NodeID>::iterator it = local_variables_table.find(id);
+  if (it != local_variables_table.end())
+    throw LocalParameterException(name);
+
+  local_variables_table[id] = value;
+}
+
+NodeID
+DataTree::AddUnknownFunction(const string &function_name, const vector<NodeID> &arguments)
+{
+  if (symbol_table.getType(function_name) != eUnknownFunction)
+    {
+      cerr << "Symbol " << function_name << " is not a function name!";
+      exit(-1);
+    }
+
+  int id = symbol_table.getID(function_name);
+
+  return new UnknownFunctionNode(*this, id, arguments);
+}

DynareFlex.ll

+/*
+ * Copyright (C) 2003-2008 Dynare Team
+ *
+ * This file is part of Dynare.
+ *
+ * Dynare is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Dynare is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+%{
+using namespace std;
+
+#include "ParsingDriver.hh"
+#include "DynareBison.hh"
+
+// Announce to Flex the prototype we want for lexing function
+#define YY_DECL                                                \
+  Dynare::parser::token_type                                   \
+    DynareFlex::lex(Dynare::parser::semantic_type *yylval,     \
+                    Dynare::parser::location_type *yylloc,     \
+                    ParsingDriver &driver)
+ 
+// Shortcut to access tokens defined by Bison
+typedef Dynare::parser::token token;
+
+/* By default yylex returns int, we use token_type.
+   Unfortunately yyterminate by default returns 0, which is
+   not of token_type.  */
+#define yyterminate() return Dynare::parser::token_type (0);
+
+int comment_caller, line_caller;
+/* Particular value : when sigma_e command is found
+ this flag is set to 1, when command finished it is set to 0
+ */
+int sigma_e = 0;
+%}
+
+%option c++
+
+%option prefix="Dynare"
+
+%option case-insensitive noyywrap nounput batch debug never-interactive
+
+%x COMMENT
+%x DYNARE_STATEMENT
+%x DYNARE_BLOCK
+%x NATIVE
+%x LINE1
+%x LINE2
+%x LINE3
+
+%{
+// Increments location counter for every token read
+#define YY_USER_ACTION yylloc->columns(yyleng);
+%}
+%%
+ /* Code put at the beginning of yylex() */
+%{
+  // Reset location before reading token
+  yylloc->step();
+%}
+
+ /* Rules for matching @line directives */
+<*>^@line\ \"   { line_caller = YYSTATE; BEGIN(LINE1); }
+<LINE1>[^\"\n]* {
+                  if (yylloc->begin.filename)
+                    delete yylloc->begin.filename;
+                  yylloc->begin.filename = yylloc->end.filename = new string(yytext);
+                  BEGIN(LINE2);
+                }
+<LINE2>\"       BEGIN(LINE3);
+<LINE3>[0-9]+   {
+                  yylloc->begin.line = yylloc->end.line = atoi(yytext) - 1;
+                  BEGIN(line_caller);
+                }
+
+ /* spaces, tabs and EOL are ignored */
+<*>[ \t\r\f]+  { yylloc->step(); }
+<*>[\n]+       { yylloc->lines(yyleng); yylloc->step(); }
+
+ /* Comments */
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK>["%"].*
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK>["/"]["/"].*
+<INITIAL,DYNARE_STATEMENT,DYNARE_BLOCK>"/*"   {comment_caller = YY_START; BEGIN COMMENT;}
+
+<COMMENT>[^*\n]*
+<COMMENT>"*"+[^/\n]
+<COMMENT>"*"+"/"        {BEGIN comment_caller;}
+
+ /* Begin of a Dynare statement */
+<INITIAL>var {BEGIN DYNARE_STATEMENT; return token::VAR;}
+<INITIAL>varexo {BEGIN DYNARE_STATEMENT; return token::VAREXO;}
+<INITIAL>varexo_det {BEGIN DYNARE_STATEMENT; return token::VAREXO_DET;}
+<INITIAL>parameters {BEGIN DYNARE_STATEMENT; return token::PARAMETERS;}
+<INITIAL>periods 	{BEGIN DYNARE_STATEMENT; return token::PERIODS;}
+<INITIAL>cutoff 	{BEGIN DYNARE_STATEMENT; return token::CUTOFF;}
+<INITIAL>markowitz 	{BEGIN DYNARE_STATEMENT; return token::MARKOWITZ;}
+<INITIAL>estimation {BEGIN DYNARE_STATEMENT; return token::ESTIMATION;}
+<INITIAL>prior_analysis {BEGIN DYNARE_STATEMENT; return token::PRIOR_ANALYSIS;}
+<INITIAL>posterior_analysis {BEGIN DYNARE_STATEMENT; return token::POSTERIOR_ANALYSIS;}
+<INITIAL>varobs 	{BEGIN DYNARE_STATEMENT; return token::VAROBS;}
+<INITIAL>unit_root_vars	{BEGIN DYNARE_STATEMENT; return token::UNIT_ROOT_VARS;}
+<INITIAL>rplot	 	{BEGIN DYNARE_STATEMENT; return token::RPLOT;}
+<INITIAL>osr_params 	{BEGIN DYNARE_STATEMENT; return token::OSR_PARAMS;}
+<INITIAL>osr	 	{BEGIN DYNARE_STATEMENT; return token::OSR;}
+<INITIAL>dynatype	{BEGIN DYNARE_STATEMENT; return token::DYNATYPE;}
+<INITIAL>dynasave 	{BEGIN DYNARE_STATEMENT; return token::DYNASAVE;}
+<INITIAL>model_comparison 	{BEGIN DYNARE_STATEMENT; return token::MODEL_COMPARISON;}
+
+<INITIAL>steady {BEGIN DYNARE_STATEMENT; return token::STEADY;}
+<INITIAL>check {BEGIN DYNARE_STATEMENT; return token::CHECK;}
+<INITIAL>simul {BEGIN DYNARE_STATEMENT; return token::SIMUL;}
+<INITIAL>stoch_simul {BEGIN DYNARE_STATEMENT; return token::STOCH_SIMUL;}
+<INITIAL>dsample {BEGIN DYNARE_STATEMENT; return token::DSAMPLE;}
+<INITIAL>Sigma_e {BEGIN DYNARE_STATEMENT; sigma_e = 1; return token::SIGMA_E;}
+<INITIAL>calib {BEGIN DYNARE_STATEMENT; return token::CALIB;}
+<INITIAL>planner_objective {BEGIN DYNARE_STATEMENT; return token::PLANNER_OBJECTIVE;}
+<INITIAL>ramsey_policy {BEGIN DYNARE_STATEMENT; return token::RAMSEY_POLICY;}
+
+<INITIAL>bvar_density {BEGIN DYNARE_STATEMENT; return token::BVAR_DENSITY; }
+<INITIAL>bvar_forecast {BEGIN DYNARE_STATEMENT; return token::BVAR_FORECAST; }
+<INITIAL>dynare_sensitivity {BEGIN DYNARE_STATEMENT; return token::DYNARE_SENSITIVITY;}
+ /* End of a Dynare statement */
+
+<DYNARE_STATEMENT>; {
+  if (!sigma_e)
+    BEGIN INITIAL;
+  return Dynare::parser::token_type (yytext[0]);
+}
+
+
+ /* Begin of a Dynare block */
+<INITIAL>model {BEGIN DYNARE_BLOCK; return token::MODEL;}
+<INITIAL>initval {BEGIN DYNARE_BLOCK; return token::INITVAL;}
+<INITIAL>endval {BEGIN DYNARE_BLOCK; return token::ENDVAL;}
+<INITIAL>histval {BEGIN DYNARE_BLOCK; return token::HISTVAL;}
+<INITIAL>shocks {BEGIN DYNARE_BLOCK; return token::SHOCKS;}
+<INITIAL>estimated_params {BEGIN DYNARE_BLOCK; return token::ESTIMATED_PARAMS;}
+ /* priors is an alias for estimated_params */
+<INITIAL>priors {BEGIN DYNARE_BLOCK;return token::ESTIMATED_PARAMS;}
+<INITIAL>estimated_params_init 		{BEGIN DYNARE_BLOCK; return token::ESTIMATED_PARAMS_INIT;}
+<INITIAL>estimated_params_bounds 	{BEGIN DYNARE_BLOCK; return token::ESTIMATED_PARAMS_BOUNDS;}
+<INITIAL>observation_trends {BEGIN DYNARE_BLOCK; return token::OBSERVATION_TRENDS;}
+<INITIAL>optim_weights {BEGIN DYNARE_BLOCK; return token::OPTIM_WEIGHTS;}
+<INITIAL>calib_var 	{BEGIN DYNARE_BLOCK; return token::CALIB_VAR;}
+<INITIAL>homotopy_setup {BEGIN DYNARE_BLOCK; return token::HOMOTOPY_SETUP;}
+
+ /* End of a Dynare block */
+<DYNARE_BLOCK>end[ \t\n]*; 	{BEGIN INITIAL; return token::END;}
+
+ /* Inside  of a Dynare statement */
+<DYNARE_STATEMENT>datafile 		{return token::DATAFILE;}
+<DYNARE_STATEMENT>method    {return token::METHOD;}
+<DYNARE_STATEMENT>nobs 			{return token::NOBS;}
+<DYNARE_STATEMENT>first_obs 		{return token::FIRST_OBS;}
+<DYNARE_STATEMENT>prefilter 		{return token::PREFILTER;}
+<DYNARE_STATEMENT>presample 		{return token::PRESAMPLE;}
+<DYNARE_STATEMENT>lik_algo  		{return token::LIK_ALGO;}
+<DYNARE_STATEMENT>lik_init  		{return token::LIK_INIT;}
+<DYNARE_STATEMENT>graph   		{return token::GRAPH;}
+<DYNARE_STATEMENT>nograph   		{return token::NOGRAPH;}
+<DYNARE_STATEMENT>print   		{return token::PRINT;}
+<DYNARE_STATEMENT>noprint   		{return token::NOPRINT;}
+<DYNARE_STATEMENT>conf_sig  		{return token::CONF_SIG;}
+<DYNARE_STATEMENT>mh_replic 		{return token::MH_REPLIC;}
+<DYNARE_STATEMENT>mh_drop   		{return token::MH_DROP;}
+<DYNARE_STATEMENT>mh_jscale   		{return token::MH_JSCALE;}
+<DYNARE_STATEMENT>mh_init_scale 	{return token::MH_INIT_SCALE;}
+<DYNARE_STATEMENT>mode_file 		{return token::MODE_FILE;}
+<DYNARE_STATEMENT>mode_compute 	{return token::MODE_COMPUTE;}
+<DYNARE_STATEMENT>mode_check 		{return token::MODE_CHECK;}
+<DYNARE_STATEMENT>prior_trunc 	{return token::PRIOR_TRUNC;}
+<DYNARE_STATEMENT>mh_mode 		{return token::MH_MODE;}
+<DYNARE_STATEMENT>mh_nblocks 		{return token::MH_NBLOCKS;}
+<DYNARE_STATEMENT>load_mh_file 	{return token::LOAD_MH_FILE;}
+<DYNARE_STATEMENT>loglinear 		{return token::LOGLINEAR;}
+<DYNARE_STATEMENT>nodiagnostic 	{return token::NODIAGNOSTIC;}
+<DYNARE_STATEMENT>kalman_algo 	{return token::KALMAN_ALGO;}
+<DYNARE_STATEMENT>kalman_tol 	{return token::KALMAN_TOL;}
+<DYNARE_STATEMENT>forecast 	{return token::FORECAST;}
+<DYNARE_STATEMENT>smoother 	{return token::SMOOTHER;}
+<DYNARE_STATEMENT>bayesian_irf 	{return token::BAYESIAN_IRF;}
+<DYNARE_STATEMENT>moments_varendo {return token::MOMENTS_VARENDO;}
+<DYNARE_STATEMENT>filtered_vars	{return token::FILTERED_VARS;}
+<DYNARE_STATEMENT>filter_step_ahead	{return token::FILTER_STEP_AHEAD;}
+<DYNARE_STATEMENT>relative_irf 	{return token::RELATIVE_IRF;}
+<DYNARE_STATEMENT>tex		{return token::TEX;}
+<DYNARE_STATEMENT>nomoments	{return token::NOMOMENTS;}
+<DYNARE_STATEMENT>corr		{return token::CORR;}
+<DYNARE_STATEMENT>nocorr	{return token::NOCORR;}
+<DYNARE_STATEMENT>optim		{return token::OPTIM;}