/*
* Copyright (C) 2003-2009 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 .
*/
%{
using namespace std;
#include "ParsingDriver.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); }
[^\"]* {
filename = string(yytext);
BEGIN(LINE2);
}
\" BEGIN(LINE3);
[0-9]+ {
yylloc->begin.line = yylloc->end.line = atoi(yytext) - 1;
BEGIN(line_caller);
}
/* spaces, tabs and carriage returns are ignored */
<*>[ \t\r\f]+ { yylloc->step(); }
<*>[\n]+ { yylloc->lines(yyleng); yylloc->step(); }
/* Comments */
["%"].*
["/"]["/"].*
"/*" {comment_caller = YY_START; BEGIN COMMENT;}
"*/" {BEGIN comment_caller;}
.
/* Begin of a Dynare statement */
var {BEGIN DYNARE_STATEMENT; return token::VAR;}
varexo {BEGIN DYNARE_STATEMENT; return token::VAREXO;}
varexo_det {BEGIN DYNARE_STATEMENT; return token::VAREXO_DET;}
parameters {BEGIN DYNARE_STATEMENT; return token::PARAMETERS;}
periods {BEGIN DYNARE_STATEMENT; return token::PERIODS;}
cutoff {BEGIN DYNARE_STATEMENT; return token::CUTOFF;}
markowitz {BEGIN DYNARE_STATEMENT; return token::MARKOWITZ;}
model_info {BEGIN DYNARE_STATEMENT; return token::MODEL_INFO;}
estimation {BEGIN DYNARE_STATEMENT; return token::ESTIMATION;}
prior_analysis {BEGIN DYNARE_STATEMENT; return token::PRIOR_ANALYSIS;}
posterior_analysis {BEGIN DYNARE_STATEMENT; return token::POSTERIOR_ANALYSIS;}
varobs {BEGIN DYNARE_STATEMENT; return token::VAROBS;}
unit_root_vars {BEGIN DYNARE_STATEMENT; return token::UNIT_ROOT_VARS;}
rplot {BEGIN DYNARE_STATEMENT; return token::RPLOT;}
osr_params {BEGIN DYNARE_STATEMENT; return token::OSR_PARAMS;}
osr {BEGIN DYNARE_STATEMENT; return token::OSR;}
dynatype {BEGIN DYNARE_STATEMENT; return token::DYNATYPE;}
dynasave {BEGIN DYNARE_STATEMENT; return token::DYNASAVE;}
model_comparison {BEGIN DYNARE_STATEMENT; return token::MODEL_COMPARISON;}
change_type {BEGIN DYNARE_STATEMENT; return token::CHANGE_TYPE;}
load_params_and_steady_state {BEGIN DYNARE_STATEMENT; return token::LOAD_PARAMS_AND_STEADY_STATE;}
save_params_and_steady_state {BEGIN DYNARE_STATEMENT; return token::SAVE_PARAMS_AND_STEADY_STATE;}
steady {BEGIN DYNARE_STATEMENT; return token::STEADY;}
check {BEGIN DYNARE_STATEMENT; return token::CHECK;}
simul {BEGIN DYNARE_STATEMENT; return token::SIMUL;}
stoch_simul {BEGIN DYNARE_STATEMENT; return token::STOCH_SIMUL;}
dsample {BEGIN DYNARE_STATEMENT; return token::DSAMPLE;}
Sigma_e {BEGIN DYNARE_STATEMENT; sigma_e = 1; return token::SIGMA_E;}
calib {BEGIN DYNARE_STATEMENT; return token::CALIB;}
planner_objective {BEGIN DYNARE_STATEMENT; return token::PLANNER_OBJECTIVE;}
ramsey_policy {BEGIN DYNARE_STATEMENT; return token::RAMSEY_POLICY;}
identification {BEGIN DYNARE_STATEMENT; return token::IDENTIFICATION;}
bvar_density {BEGIN DYNARE_STATEMENT; return token::BVAR_DENSITY; }
bvar_forecast {BEGIN DYNARE_STATEMENT; return token::BVAR_FORECAST; }
dynare_sensitivity {BEGIN DYNARE_STATEMENT; return token::DYNARE_SENSITIVITY;}
initval_file {BEGIN DYNARE_STATEMENT; return token::INITVAL_FILE;}
forecast {BEGIN DYNARE_STATEMENT; return token::FORECAST;}
/* End of a Dynare statement */
; {
if (!sigma_e)
BEGIN INITIAL;
return Dynare::parser::token_type (yytext[0]);
}
/* Begin of a Dynare block */
model {BEGIN DYNARE_BLOCK; return token::MODEL;}
initval {BEGIN DYNARE_BLOCK; return token::INITVAL;}
endval {BEGIN DYNARE_BLOCK; return token::ENDVAL;}
histval {BEGIN DYNARE_BLOCK; return token::HISTVAL;}
shocks {BEGIN DYNARE_BLOCK; return token::SHOCKS;}
estimated_params {BEGIN DYNARE_BLOCK; return token::ESTIMATED_PARAMS;}
/* priors is an alias for estimated_params */
priors {BEGIN DYNARE_BLOCK;return token::ESTIMATED_PARAMS;}
estimated_params_init {BEGIN DYNARE_BLOCK; return token::ESTIMATED_PARAMS_INIT;}
estimated_params_bounds {BEGIN DYNARE_BLOCK; return token::ESTIMATED_PARAMS_BOUNDS;}
observation_trends {BEGIN DYNARE_BLOCK; return token::OBSERVATION_TRENDS;}
optim_weights {BEGIN DYNARE_BLOCK; return token::OPTIM_WEIGHTS;}
calib_var {BEGIN DYNARE_BLOCK; return token::CALIB_VAR;}
homotopy_setup {BEGIN DYNARE_BLOCK; return token::HOMOTOPY_SETUP;}
/* End of a Dynare block */
end[ \t\n]*; {BEGIN INITIAL; return token::END;}
/* Inside of a Dynare statement */
datafile {return token::DATAFILE;}
method {return token::METHOD;}
nobs {return token::NOBS;}
first_obs {return token::FIRST_OBS;}
prefilter {return token::PREFILTER;}
presample {return token::PRESAMPLE;}
lik_algo {return token::LIK_ALGO;}
lik_init {return token::LIK_INIT;}
graph {return token::GRAPH;}
nograph {return token::NOGRAPH;}
print {return token::PRINT;}
noprint {return token::NOPRINT;}
conf_sig {return token::CONF_SIG;}
mh_replic {return token::MH_REPLIC;}
mh_drop {return token::MH_DROP;}
mh_jscale {return token::MH_JSCALE;}
mh_init_scale {return token::MH_INIT_SCALE;}
mode_file {return token::MODE_FILE;}
mode_compute {return token::MODE_COMPUTE;}
mode_check {return token::MODE_CHECK;}
prior_trunc {return token::PRIOR_TRUNC;}
mh_mode {return token::MH_MODE;}
mh_nblocks {return token::MH_NBLOCKS;}
load_mh_file {return token::LOAD_MH_FILE;}
loglinear {return token::LOGLINEAR;}
nodiagnostic {return token::NODIAGNOSTIC;}
kalman_algo {return token::KALMAN_ALGO;}
kalman_tol {return token::KALMAN_TOL;}
forecast {return token::FORECAST;}
smoother {return token::SMOOTHER;}
bayesian_irf {return token::BAYESIAN_IRF;}
moments_varendo {return token::MOMENTS_VARENDO;}
filtered_vars {return token::FILTERED_VARS;}
filter_step_ahead {return token::FILTER_STEP_AHEAD;}
relative_irf {return token::RELATIVE_IRF;}
tex {return token::TEX;}
nomoments {return token::NOMOMENTS;}
corr {return token::CORR;}
nocorr {return token::NOCORR;}
optim {return token::OPTIM;}
periods {return token::PERIODS;}
cutoff {return token::CUTOFF;}
markowitz {return token::MARKOWITZ;}
marginal_density {return token::MARGINAL_DENSITY;}
laplace {return token::LAPLACE;}
modifiedharmonicmean {return token::MODIFIEDHARMONICMEAN;}
constant {return token::CONSTANT;}
noconstant {return token::NOCONSTANT;}
covar {return token::COVAR;}
filename {return token::FILENAME;}
diffuse_filter {return token::DIFFUSE_FILTER;}
plot_priors {return token::PLOT_PRIORS;}
/* These four (var, varexo, varexo_det, parameters) are for change_type */
var { return token::VAR; }
varexo { return token::VAREXO; }
varexo_det { return token::VAREXO_DET; }
parameters { return token::PARAMETERS; }
bvar_prior_tau { return token::BVAR_PRIOR_TAU; }
bvar_prior_decay { return token::BVAR_PRIOR_DECAY; }
bvar_prior_lambda { return token::BVAR_PRIOR_LAMBDA; }
bvar_prior_mu { return token::BVAR_PRIOR_MU; }
bvar_prior_omega { return token::BVAR_PRIOR_OMEGA; }
bvar_prior_flat { return token::BVAR_PRIOR_FLAT; }
bvar_prior_train { return token::BVAR_PRIOR_TRAIN; }
bvar_replic { return token::BVAR_REPLIC; }
homotopy_mode {return token::HOMOTOPY_MODE; }
homotopy_steps {return token::HOMOTOPY_STEPS; }
[\$][^$]*[\$] {
strtok(yytext+1, "$");
yylval->string_val = new string(yytext + 1);
return token::TEX_NAME;
}
/* Inside a Dynare block */
var {return token::VAR;}
stderr {return token::STDERR;}
values {return token::VALUES;}
corr {return token::CORR;}
periods {return token::PERIODS;}
cutoff {return token::CUTOFF;}
markowitz {return token::MARKOWITZ;}
gamma_pdf {return token::GAMMA_PDF;}
beta_pdf {return token::BETA_PDF;}
normal_pdf {return token::NORMAL_PDF;}
inv_gamma_pdf {return token::INV_GAMMA_PDF;}
inv_gamma1_pdf {return token::INV_GAMMA1_PDF;}
inv_gamma2_pdf {return token::INV_GAMMA2_PDF;}
uniform_pdf {return token::UNIFORM_PDF;}
; {return Dynare::parser::token_type (yytext[0]);}
# {return Dynare::parser::token_type (yytext[0]);}
autocorr {return token::AUTOCORR;}
/* Inside Dynare statement */
solve_algo {return token::SOLVE_ALGO;}
dr_algo {return token::DR_ALGO;}
simul_algo {return token::SIMUL_ALGO;}
drop {return token::DROP;}
order {return token::ORDER;}
replic {return token::REPLIC;}
ar {return token::AR;}
nofunctions {return token::NOFUNCTIONS;}
irf {return token::IRF;}
hp_filter {return token::HP_FILTER;}
hp_ngrid {return token::HP_NGRID;}
simul_seed {return token::SIMUL_SEED;}
qz_criterium {return token::QZ_CRITERIUM;}
simul {return token::SIMUL;}
xls_sheet {return token::XLS_SHEET;}
xls_range {return token::XLS_RANGE;}
mh_recover {return token::MH_RECOVER;}
planner_discount {return token::PLANNER_DISCOUNT;}
[\.] {return Dynare::parser::token_type (yytext[0]);}
[\\] {return Dynare::parser::token_type (yytext[0]);}
[\'] {return Dynare::parser::token_type (yytext[0]);}
use_dll {return token::USE_DLL;}
lu {return token::LU;}
gaussian_elimination {return token::GAUSSIAN_ELIMINATION;}
gmres {return token::GMRES;}
bicgstab {return token::BICGSTAB;}
sparse {return token::SPARSE;}
sparse_dll {return token::SPARSE_DLL;}
linear {return token::LINEAR;}
[,] {return token::COMMA;}
[:] {return Dynare::parser::token_type (yytext[0]);}
[\(\)] {return Dynare::parser::token_type (yytext[0]);}
[\[] {return Dynare::parser::token_type (yytext[0]);}
[\]] {
if (sigma_e)
sigma_e = 0;
return Dynare::parser::token_type (yytext[0]);
}
[+] {return token::PLUS;}
[-] {return token::MINUS;}
[*] {return token::TIMES;}
[/] {return token::DIVIDE;}
[=] {return token::EQUAL;}
[<] {return token::LESS;}
[>] {return token::GREATER;}
">=" {return token::GREATER_EQUAL;}
"<=" {return token::LESS_EQUAL;}
"==" {return token::EQUAL_EQUAL;}
"!=" {return token::EXCLAMATION_EQUAL;}
[\^] {return token::POWER;}
exp {return token::EXP;}
log {return token::LOG;}
log10 {return token::LOG10;}
ln {return token::LN;}
sin {return token::SIN;}
cos {return token::COS;}
tan {return token::TAN;}
asin {return token::ASIN;}
acos {return token::ACOS;}
atan {return token::ATAN;}
sinh {return token::SINH;}
cosh {return token::COSH;}
tanh {return token::TANH;}
asinh {return token::ASINH;}
acosh {return token::ACOSH;}
atanh {return token::ATANH;}
sqrt {return token::SQRT;}
max {return token::MAX;}
min {return token::MIN;}
normcdf {return token::NORMCDF;}
nan {return token::NAN_CONSTANT;}
inf {return token::INF_CONSTANT;}
/* options for GSA module by Marco Ratto */
identification {return token::IDENTIFICATION;}
morris {return token::MORRIS;}
stab {return token::STAB;}
redform {return token::REDFORM;}
pprior {return token::PPRIOR;}
prior_range {return token::PRIOR_RANGE;}
ppost {return token::PPOST;}
ilptau {return token::ILPTAU;}
glue {return token::GLUE;}
morris_nliv {return token::MORRIS_NLIV;}
morris_ntra {return token::MORRIS_NTRA;}
Nsam {return token::NSAM;}
load_redform {return token::LOAD_REDFORM;}
load_rmse {return token::LOAD_RMSE;}
load_stab {return token::LOAD_STAB;}
alpha2_stab {return token::ALPHA2_STAB;}
ksstat {return token::KSSTAT;}
logtrans_redform {return token::LOGTRANS_REDFORM;}
threshold_redform {return token::THRESHOLD_REDFORM;}
ksstat_redform {return token::KSSTAT_REDFORM;}
alpha2_redform {return token::ALPHA2_REDFORM;}
namendo {return token::NAMENDO;}
namlagendo {return token::NAMLAGENDO;}
namexo {return token::NAMEXO;}
rmse {return token::RMSE;}
lik_only {return token::LIK_ONLY;}
var_rmse {return token::VAR_RMSE;}
pfilt_rmse {return token::PFILT_RMSE;}
istart_rmse {return token::ISTART_RMSE;}
alpha_rmse {return token::ALPHA_RMSE;}
alpha2_rmse {return token::ALPHA2_RMSE;}
trans_ident {return token::TRANS_IDENT;}
/* end of GSA options */
[A-Za-z_][A-Za-z0-9_]* {
yylval->string_val = new string(yytext);
return token::NAME;
}
((([0-9]*\.[0-9]+)|([0-9]+\.))([edED][-+]?[0-9]+)?)|([0-9]+[edED][-+]?[0-9]+) {
yylval->string_val = new string(yytext);
return token::FLOAT_NUMBER;
}
[0-9]+ {
yylval->string_val = new string(yytext);
return token::INT_NUMBER;
}
\'[^\']+\' {
yylval->string_val = new string(yytext + 1);
yylval->string_val->resize(yylval->string_val->length() - 1);
return token::QUOTED_STRING;
}
/* An instruction starting with a recognized symbol (which is not a modfile local
or an unknown function) is passed as NAME, otherwise it is a native statement
until the end of the line.
We exclude modfile local vars because the user may want to modify their value
using a Matlab assignment statement.
We also exclude unknown functions because the user may have used a Matlab matrix
element in initval (in which case Dynare recognizes the matrix name as an unknown
function symbol), and may want to modify the matrix later with Matlab statements.
*/
[A-Za-z_][A-Za-z0-9_]* {
if (driver.symbol_exists_and_is_not_modfile_local_or_unknown_function(yytext))
{
BEGIN DYNARE_STATEMENT;
yylval->string_val = new string(yytext);
return token::NAME;
}
else
{
/* Enter a native block */
BEGIN NATIVE;
yyless(0);
}
}
/* Enter a native block */
. { BEGIN NATIVE; yyless(0); }
/* Add the native statement */
.* { driver.add_native(yytext); BEGIN INITIAL; }
<*><> { yyterminate(); }
<*>. { driver.error(*yylloc, "character unrecognized by lexer"); }
%%
DynareFlex::DynareFlex(istream* in, ostream* out)
: DynareFlexLexer(in, out)
{
}
/* This implementation of DynareFlexLexer::yylex() is required to fill the
* vtable of the class DynareFlexLexer. We define the scanner's main yylex
* function via YY_DECL to reside in the DynareFlex class instead. */
#ifdef yylex
# undef yylex
#endif
int
DynareFlexLexer::yylex()
{
cerr << "DynareFlexLexer::yylex() has been called, that should never happen!" << endl;
exit(EXIT_FAILURE);
}
/*
Local variables:
mode: C++
End:
*/