/*
* Copyright (C) 2007-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 .
*/
#ifndef _CODEINTERPRETER_HH
#define _CODEINTERPRETER_HH
//#define DEBUGL
#include
#include
#include
#include
#include
#ifdef LINBCG
# include "linbcg.hh"
#endif
#ifdef BYTE_CODE
#ifndef DEBUG_EX
#include "mex.h"
#else
#include "mex_interface.hh"
#endif
#endif
using namespace std;
/**
* \enum Tags
* \brief The differents flags of the bytecode
*/
enum Tags
{
FLDZ, //!< Stores zero in the stack - 0
FLDC, //!< Stores a constant term in the stack - 1
FDIMT, //!< Defines the number of temporary terms - dynamic context (the period has to be indicated) - 2
FDIMST, //!< Defines the number of temporary terms - static context (the period hasn't to be indicated) - 3
FLDT, //!< Stores a temporary term in the stack - dynamic context (the period has to be indicated) - 4
FLDST, //!< Stores a temporary term in the stack - static context (the period hasn't to be indicated) - 5
FSTPT, //!< Loads a temporary term from the stack - dynamic context (the period has to be indicated) - 6
FSTPST, //!< Loads a temporary term from the stack - static context (the period hasn't to be indicated) - 7
FLDU, //!< Stores an element of the vector U in the stack - dynamic context (the period has to be indicated) - 8
FLDSU, //!< Stores an element of the vector U in the stack - static context (the period hasn't to be indicated) - 9
FSTPU, //!< Loads an element of the vector U from the stack - dynamic context (the period has to be indicated) - A
FSTPSU, //!< Loads an element of the vector U from the stack - static context (the period hasn't to be indicated) - B
FLDV, //!< Stores a variable (described in SymbolType) in the stack - dynamic context (the period has to be indicated) - C
FLDSV, //!< Stores a variable (described in SymbolType) in the stack - static context (the period hasn't to be indicated) - D
FLDVS, //!< Stores a variable (described in SymbolType) in the stack - dynamic context but inside the STEADYSTATE function (the period hasn't to be indicated) - E
FSTPV, //!< Loads a variable (described in SymbolType) from the stack - dynamic context (the period has to be indicated) - F
FSTPSV, //!< Loads a variable (described in SymbolType) from the stack - static context (the period hasn't to be indicated) - 10
FLDR, //!< Stores a residual in the stack - 11
FSTPR, //!< Loads a residual from the stack - 12
FSTPG, //!< Loads a derivative from the stack - 13
FUNARY, //!< A Unary operator - 14
FBINARY, //!< A binary operator - 15
FCUML, //!< Cumulates the result - 16
FBEGINBLOCK, //!< Defines the begining of a model block - 17
FENDBLOCK, //!< Defines the end of a model block - 18
FENDEQU, //!< Defines the last equation of the block. For block that has to be solved, the derivatives appear just after this flag - 19
FEND, //!< Defines the end of the model code - 1A
FOK //!< Used for debugging purpose - 1B
};
enum BlockType
{
SIMULTANS = 0, //!< Simultaneous time separable block
PROLOGUE = 1, //!< Prologue block (one equation at the beginning, later merged)
EPILOGUE = 2, //!< Epilogue block (one equation at the beginning, later merged)
SIMULTAN = 3 //!< Simultaneous time unseparable block
};
enum EquationType
{
E_UNKNOWN, //!< Unknown equation type
E_EVALUATE, //!< Simple evaluation, normalized variable on left-hand side
E_EVALUATE_S, //!< Simple evaluation, normalize using the first order derivative
E_SOLVE //!< No simple evaluation of the equation, it has to be solved
};
enum BlockSimulationType
{
UNKNOWN, //!< Unknown simulation type
EVALUATE_FORWARD, //!< Simple evaluation, normalized variable on left-hand side, forward
EVALUATE_BACKWARD, //!< Simple evaluation, normalized variable on left-hand side, backward
SOLVE_FORWARD_SIMPLE, //!< Block of one equation, newton solver needed, forward
SOLVE_BACKWARD_SIMPLE, //!< Block of one equation, newton solver needed, backward
SOLVE_TWO_BOUNDARIES_SIMPLE, //!< Block of one equation, newton solver needed, forward & ackward
SOLVE_FORWARD_COMPLETE, //!< Block of several equations, newton solver needed, forward
SOLVE_BACKWARD_COMPLETE, //!< Block of several equations, newton solver needed, backward
SOLVE_TWO_BOUNDARIES_COMPLETE,//!< Block of several equations, newton solver needed, forward and backwar
};
//! Enumeration of possible symbol types
/*! Warning: do not to change existing values for 0 to 4: the values matter for homotopy_setup command */
enum SymbolType
{
eEndogenous = 0, //!< Endogenous
eExogenous = 1, //!< Exogenous
eExogenousDet = 2, //!< Exogenous deterministic
eParameter = 4, //!< Parameter
eModelLocalVariable = 10, //!< Local variable whose scope is model (pound expression)
eModFileLocalVariable = 11, //!< Local variable whose scope is mod file (model excluded)
eUnknownFunction = 12 //!< Function unknown to the preprocessor
};
enum UnaryOpcode
{
oUminus,
oExp,
oLog,
oLog10,
oCos,
oSin,
oTan,
oAcos,
oAsin,
oAtan,
oCosh,
oSinh,
oTanh,
oAcosh,
oAsinh,
oAtanh,
oSqrt,
oSteadyState
};
enum BinaryOpcode
{
oPlus,
oMinus,
oTimes,
oDivide,
oPower,
oEqual,
oMax,
oMin,
oLess,
oGreater,
oLessEqual,
oGreaterEqual,
oEqualEqual,
oDifferent,
oExpectation
};
enum TrinaryOpcode
{
oNormcdf
};
struct Block_contain_type
{
int Equation, Variable, Own_Derivative;
};
#pragma pack(push, 1)
class TagWithoutArgument
{
protected:
uint8_t op_code;
public:
inline TagWithoutArgument(uint8_t op_code_arg) : op_code(op_code_arg) {};
inline void write(ostream &CompileCode) {CompileCode.write(reinterpret_cast(this), sizeof(*this)); };
};
template < class T1 >
class TagWithOneArgument
{
protected:
uint8_t op_code;
T1 arg1;
public:
inline TagWithOneArgument(uint8_t op_code_arg) : op_code(op_code_arg) {};
inline TagWithOneArgument(uint8_t op_code_arg, T1 arg_arg1) : op_code(op_code_arg), arg1(arg_arg1) {};
inline void write(ostream &CompileCode) {CompileCode.write(reinterpret_cast(this), sizeof(TagWithOneArgument)); };
};
template < class T1, class T2 >
class TagWithTwoArguments
{
protected:
uint8_t op_code;
T1 arg1;
T2 arg2;
public:
inline TagWithTwoArguments(uint8_t op_code_arg) : op_code(op_code_arg) {};
inline TagWithTwoArguments(uint8_t op_code_arg, T1 arg_arg1, T2 arg_arg2) : op_code(op_code_arg), arg1(arg_arg1), arg2(arg_arg2) {};
inline void write(ostream &CompileCode) {CompileCode.write(reinterpret_cast(this), sizeof(*this)); };
};
template < class T1, class T2, class T3 >
class TagWithThreeArguments
{
protected:
uint8_t op_code;
T1 arg1;
T2 arg2;
T3 arg3;
public:
inline TagWithThreeArguments(uint8_t op_code_arg) : op_code(op_code_arg) {};
inline TagWithThreeArguments(uint8_t op_code_arg, T1 arg_arg1, T2 arg_arg2, T3 arg_arg3) : op_code(op_code_arg), arg1(arg_arg1), arg2(arg_arg2), arg3(arg_arg3) {};
inline void write(ostream &CompileCode) {CompileCode.write(reinterpret_cast(this), sizeof(*this)); };
};
class FLDZ_ : public TagWithoutArgument
{
public:
inline FLDZ_() : TagWithoutArgument(FLDZ) {};
};
class FEND_ : public TagWithoutArgument
{
public:
inline FEND_() : TagWithoutArgument(FEND) {};
};
class FENDBLOCK_ : public TagWithoutArgument
{
public:
inline FENDBLOCK_() : TagWithoutArgument(FENDBLOCK) {};
};
class FENDEQU_ : public TagWithoutArgument
{
public:
inline FENDEQU_() : TagWithoutArgument(FENDEQU) {};
};
class FCUML_ : public TagWithoutArgument
{
public:
inline FCUML_() : TagWithoutArgument(FCUML) {};
};
class FDIMT_ : public TagWithOneArgument
{
public:
inline FDIMT_() : TagWithOneArgument::TagWithOneArgument(FDIMT) {};
inline FDIMT_(unsigned int size_arg) : TagWithOneArgument::TagWithOneArgument(FDIMT,size_arg) {};
inline unsigned int get_size() {return arg1;};
};
class FDIMST_ : public TagWithOneArgument
{
public:
inline FDIMST_() : TagWithOneArgument::TagWithOneArgument(FDIMST) {};
inline FDIMST_(const unsigned int size_arg) : TagWithOneArgument::TagWithOneArgument(FDIMST,size_arg) {};
inline unsigned int get_size() {return arg1;};
};
class FLDC_ : public TagWithOneArgument
{
public:
inline FLDC_() : TagWithOneArgument::TagWithOneArgument(FLDC) {};
inline FLDC_(const double value_arg) : TagWithOneArgument::TagWithOneArgument(FLDC,value_arg) {};
inline double get_value() {return arg1;};
};
class FLDU_ : public TagWithOneArgument
{
public:
inline FLDU_() : TagWithOneArgument::TagWithOneArgument(FLDU) {};
inline FLDU_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FLDU,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FLDSU_ : public TagWithOneArgument
{
public:
inline FLDSU_() : TagWithOneArgument::TagWithOneArgument(FLDSU) {};
inline FLDSU_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FLDSU,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FLDR_ : public TagWithOneArgument
{
public:
inline FLDR_() : TagWithOneArgument::TagWithOneArgument(FLDR) {};
inline FLDR_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FLDR,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FLDT_ : public TagWithOneArgument
{
public:
inline FLDT_() : TagWithOneArgument::TagWithOneArgument(FLDT) {};
inline FLDT_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FLDT,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FLDST_ : public TagWithOneArgument
{
public:
inline FLDST_() : TagWithOneArgument::TagWithOneArgument(FLDST) {};
inline FLDST_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FLDST,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FSTPT_ : public TagWithOneArgument
{
public:
inline FSTPT_() : TagWithOneArgument::TagWithOneArgument(FSTPT) {};
inline FSTPT_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FSTPT,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FSTPST_ : public TagWithOneArgument
{
public:
inline FSTPST_() : TagWithOneArgument::TagWithOneArgument(FSTPST) {};
inline FSTPST_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FSTPST,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FSTPR_ : public TagWithOneArgument
{
public:
inline FSTPR_() : TagWithOneArgument::TagWithOneArgument(FSTPR) {};
inline FSTPR_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FSTPR,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FSTPU_ : public TagWithOneArgument
{
public:
inline FSTPU_() : TagWithOneArgument::TagWithOneArgument(FSTPU) {};
inline FSTPU_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FSTPU,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FSTPSU_ : public TagWithOneArgument
{
public:
inline FSTPSU_() : TagWithOneArgument::TagWithOneArgument(FSTPSU) {};
inline FSTPSU_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FSTPSU,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FSTPG_ : public TagWithOneArgument
{
public:
inline FSTPG_() : TagWithOneArgument::TagWithOneArgument(FSTPG,0) {};
inline FSTPG_(const unsigned int pos_arg) : TagWithOneArgument::TagWithOneArgument(FSTPG,pos_arg) {};
inline unsigned int get_pos() {return arg1;};
};
class FUNARY_ : public TagWithOneArgument
{
public:
inline FUNARY_() : TagWithOneArgument::TagWithOneArgument(FUNARY) {};
inline FUNARY_(uint8_t op_type_arg) : TagWithOneArgument::TagWithOneArgument(FUNARY,op_type_arg) {};
inline uint8_t get_op_type() {return arg1;};
};
class FBINARY_ : public TagWithOneArgument
{
public:
inline FBINARY_() : TagWithOneArgument::TagWithOneArgument(FBINARY) {};
inline FBINARY_(const int op_type_arg) : TagWithOneArgument::TagWithOneArgument(FBINARY,op_type_arg) {};
inline uint8_t get_op_type() {return arg1;};
};
class FOK_ : public TagWithOneArgument
{
public:
inline FOK_() : TagWithOneArgument::TagWithOneArgument(FOK) {};
inline FOK_(const int arg_arg) : TagWithOneArgument::TagWithOneArgument(FOK,arg_arg) {};
inline int get_arg() {return arg1;};
};
class FLDVS_ : public TagWithTwoArguments
{
public:
inline FLDVS_() : TagWithTwoArguments::TagWithTwoArguments(FLDVS) {};
inline FLDVS_(uint8_t type_arg, const unsigned int pos_arg) : TagWithTwoArguments::TagWithTwoArguments(FLDVS, type_arg, pos_arg) {};
inline uint8_t get_type() {return arg1;};
inline unsigned int get_pos() {return arg2;};
};
class FLDSV_ : public TagWithTwoArguments
{
public:
inline FLDSV_() : TagWithTwoArguments::TagWithTwoArguments(FLDSV) {};
inline FLDSV_(const uint8_t type_arg, const unsigned int pos_arg) :
TagWithTwoArguments::TagWithTwoArguments(FLDSV, type_arg, pos_arg) {};
inline uint8_t get_type() {return arg1;};
inline unsigned int get_pos() {return arg2;};
};
class FSTPSV_ : public TagWithTwoArguments
{
public:
inline FSTPSV_() : TagWithTwoArguments::TagWithTwoArguments(FSTPSV) {};
inline FSTPSV_(const uint8_t type_arg, const unsigned int pos_arg) :
TagWithTwoArguments::TagWithTwoArguments(FSTPSV, type_arg, pos_arg) {};
inline uint8_t get_type() {return arg1;};
inline unsigned int get_pos() {return arg2;};
};
class FLDV_ : public TagWithThreeArguments
{
public:
inline FLDV_() : TagWithThreeArguments::TagWithThreeArguments(FLDV) {};
inline FLDV_(const int type_arg, const unsigned int pos_arg) :
TagWithThreeArguments::TagWithThreeArguments(FLDV, type_arg, pos_arg, 0) {};
inline FLDV_(const int type_arg, const unsigned int pos_arg, const int lead_lag_arg) :
TagWithThreeArguments::TagWithThreeArguments(FLDV, type_arg, pos_arg, lead_lag_arg) {};
inline uint8_t get_type() {return arg1;};
inline unsigned int get_pos() {return arg2;};
inline int get_lead_lag() {return arg3;};
};
class FSTPV_ : public TagWithThreeArguments
{
public:
inline FSTPV_() : TagWithThreeArguments::TagWithThreeArguments(FSTPV) {};
inline FSTPV_(const int type_arg, const unsigned int pos_arg) :
TagWithThreeArguments::TagWithThreeArguments(FSTPV, type_arg, pos_arg, 0) {};
inline FSTPV_(const int type_arg, const unsigned int pos_arg, const int lead_lag_arg) :
TagWithThreeArguments::TagWithThreeArguments(FSTPV, type_arg, pos_arg, lead_lag_arg) {};
inline uint8_t get_type() {return arg1;};
inline unsigned int get_pos() {return arg2;};
inline int get_lead_lag() {return arg3;};
};
class FBEGINBLOCK_
{
private:
uint8_t op_code;
int size;
uint8_t type;
int *variable;
int *equation;
int *own_derivatives;
bool is_linear;
vector Block_Contain_;
int endo_nbr;
int Max_Lag;
int Max_Lead;
int u_count_int;
public:
inline FBEGINBLOCK_(){ op_code = FBEGINBLOCK; size = 0; type = UNKNOWN; variable = NULL; equation = NULL; own_derivatives = NULL;
is_linear = false; endo_nbr = 0; Max_Lag = 0; Max_Lead = 0; u_count_int = 0;};
inline FBEGINBLOCK_(const int size_arg, const BlockSimulationType type_arg, int *variable_arg, int *equation_arg, int *own_derivatives_arg,
bool is_linear_arg, int endo_nbr_arg, int Max_Lag_arg, int Max_Lead_arg, int u_count_int_arg)
{ op_code = FBEGINBLOCK; size = size_arg; type = type_arg; variable = variable_arg; equation = equation_arg; own_derivatives = own_derivatives_arg;
is_linear = is_linear_arg; endo_nbr = endo_nbr_arg; Max_Lag = Max_Lag_arg; Max_Lead = Max_Lead_arg; u_count_int = u_count_int_arg;/*Block_Contain.clear();*/};
inline unsigned int get_size() { return size;};
inline uint8_t get_type() { return type;};
inline bool get_is_linear() { return is_linear;};
inline int get_endo_nbr() { return endo_nbr;};
inline int get_Max_Lag() { return Max_Lag;};
inline int get_Max_Lead() { return Max_Lead;};
inline int get_u_count_int() { return u_count_int;};
inline vector get_Block_Contain() {return Block_Contain_;};
inline void write(ostream &CompileCode)
{
CompileCode.write(reinterpret_cast(&op_code), sizeof(op_code));
CompileCode.write(reinterpret_cast(&size), sizeof(size));
CompileCode.write(reinterpret_cast(&type), sizeof(type));
for(int i = 0; i(&variable[i]), sizeof(variable[0]));
CompileCode.write(reinterpret_cast(&equation[i]), sizeof(equation[0]));
CompileCode.write(reinterpret_cast(&own_derivatives[i]), sizeof(own_derivatives[0]));
}
if (type==SOLVE_TWO_BOUNDARIES_SIMPLE || type==SOLVE_TWO_BOUNDARIES_COMPLETE ||
type==SOLVE_BACKWARD_COMPLETE || type==SOLVE_FORWARD_COMPLETE)
{
CompileCode.write(reinterpret_cast(&is_linear), sizeof(is_linear));
CompileCode.write(reinterpret_cast(&endo_nbr), sizeof(endo_nbr));
CompileCode.write(reinterpret_cast(&Max_Lag), sizeof(Max_Lag));
CompileCode.write(reinterpret_cast(&Max_Lead), sizeof(Max_Lead));
CompileCode.write(reinterpret_cast(&u_count_int), sizeof(u_count_int));
}
};
#ifdef BYTE_CODE
inline uint8_t* load(uint8_t *code)
{
op_code = FBEGINBLOCK; code += sizeof(op_code);
memcpy(&size, code, sizeof(size)); code += sizeof(size);
memcpy(&type, code, sizeof(type)); code += sizeof(type);
for(int i = 0; i > tags_liste_type;
class CodeLoad
{
private:
uint8_t *code;
public:
inline void* get_current_code() {return code;};
inline tags_liste_type get_op_code(string file_name)
{
tags_liste_type tags_liste;
ifstream CompiledCode;
streamoff Code_Size;
CompiledCode.open((file_name + ".cod").c_str(),std::ios::in | std::ios::binary| std::ios::ate);
if (!CompiledCode.is_open())
{
return tags_liste;
}
Code_Size=CompiledCode.tellg();
CompiledCode.seekg(std::ios::beg);
code=(uint8_t*)mxMalloc(Code_Size);
CompiledCode.seekg(0);
CompiledCode.read(reinterpret_cast(code), Code_Size);
CompiledCode.close();
bool done = false;
while(!done)
{
switch (*code)
{
case FLDZ:
#ifdef DEBUGL
mexPrintf("FLDZ = %d size = %d\n",FLDZ, sizeof(FLDZ_));
#endif
tags_liste.push_back(make_pair(FLDZ, code));
code += sizeof(FLDZ_);
break;
case FEND:
#ifdef DEBUGL
mexPrintf("FEND\n");
#endif
tags_liste.push_back(make_pair(FEND, code));
code += sizeof(FEND_);
done = true;
break;
case FENDBLOCK:
#ifdef DEBUGL
mexPrintf("FENDBLOCK\n");
#endif
tags_liste.push_back(make_pair(FENDBLOCK, code));
code += sizeof(FENDBLOCK_);
break;
case FENDEQU:
#ifdef DEBUGL
mexPrintf("FENDEQU\n");
#endif
tags_liste.push_back(make_pair(FENDEQU, code));
code += sizeof(FENDEQU_);
break;
case FCUML:
#ifdef DEBUGL
mexPrintf("FCUML\n");
#endif
tags_liste.push_back(make_pair(FCUML, code));
code += sizeof(FCUML_);
break;
case FDIMT:
#ifdef DEBUGL
mexPrintf("FDIMT = %d size = %d\n",FDIMT, sizeof(FDIMT_));
#endif
tags_liste.push_back(make_pair(FDIMT, code));
code += sizeof(FDIMT_);
break;
case FDIMST:
#ifdef DEBUGL
mexPrintf("FDIMST\n");
#endif
tags_liste.push_back(make_pair(FDIMST, code));
code += sizeof(FDIMST_);
break;
case FLDC:
#ifdef DEBUGL
mexPrintf("FLDC\n");
#endif
tags_liste.push_back(make_pair(FLDC, code));
code += sizeof(FLDC_);
break;
case FLDU:
#ifdef DEBUGL
mexPrintf("FLDU\n");
#endif
tags_liste.push_back(make_pair(FLDU, code));
code += sizeof(FLDU_);
break;
case FLDSU:
#ifdef DEBUGL
mexPrintf("FLDSU\n");
#endif
tags_liste.push_back(make_pair(FLDSU, code));
code += sizeof(FLDSU_);
break;
case FLDR:
#ifdef DEBUGL
mexPrintf("FLDR\n");
#endif
tags_liste.push_back(make_pair(FLDR, code));
code += sizeof(FLDR_);
break;
case FLDT:
#ifdef DEBUGL
mexPrintf("FLDT\n");
#endif
tags_liste.push_back(make_pair(FLDT, code));
code += sizeof(FLDT_);
break;
case FLDST:
#ifdef DEBUGL
mexPrintf("FLDST\n");
#endif
tags_liste.push_back(make_pair(FLDST, code));
code += sizeof(FLDST_);
break;
case FSTPT:
#ifdef DEBUGL
mexPrintf("FSTPT = %d size = %d\n",FSTPT, sizeof(FSTPT_));
#endif
tags_liste.push_back(make_pair(FSTPT, code));
code += sizeof(FSTPT_);
break;
case FSTPST:
#ifdef DEBUGL
mexPrintf("FSTPST\n");
#endif
tags_liste.push_back(make_pair(FSTPST, code));
code += sizeof(FSTPST_);
break;
case FSTPR:
#ifdef DEBUGL
mexPrintf("FSTPR\n");
#endif
tags_liste.push_back(make_pair(FSTPR, code));
code += sizeof(FSTPR_);
break;
case FSTPU:
#ifdef DEBUGL
mexPrintf("FSTPU\n");
#endif
tags_liste.push_back(make_pair(FSTPU, code));
code += sizeof(FSTPU_);
break;
case FSTPSU:
#ifdef DEBUGL
mexPrintf("FSTPSU\n");
#endif
tags_liste.push_back(make_pair(FSTPSU, code));
code += sizeof(FSTPSU_);
break;
case FSTPG:
#ifdef DEBUGL
mexPrintf("FSTPG\n");
#endif
tags_liste.push_back(make_pair(FSTPG, code));
code += sizeof(FSTPG_);
break;
case FUNARY:
#ifdef DEBUGL
mexPrintf("FUNARY\n");
#endif
tags_liste.push_back(make_pair(FUNARY, code));
code += sizeof(FUNARY_);
break;
case FBINARY:
#ifdef DEBUGL
mexPrintf("FBINARY\n");
#endif
tags_liste.push_back(make_pair(FBINARY, code));
code += sizeof(FBINARY_);
break;
case FOK:
#ifdef DEBUGL
mexPrintf("FOK\n");
#endif
tags_liste.push_back(make_pair(FOK, code));
code += sizeof(FOK_);
break;
case FLDVS:
#ifdef DEBUGL
mexPrintf("FLDVS\n");
#endif
tags_liste.push_back(make_pair(FLDVS, code));
code += sizeof(FLDVS_);
break;
case FLDSV:
#ifdef DEBUGL
mexPrintf("FLDSV\n");
#endif
tags_liste.push_back(make_pair(FLDSV, code));
code += sizeof(FLDSV_);
break;
case FSTPSV:
#ifdef DEBUGL
mexPrintf("FSTPSV\n");
#endif
tags_liste.push_back(make_pair(FSTPSV, code));
code += sizeof(FSTPSV_);
break;
case FLDV:
#ifdef DEBUGL
mexPrintf("FLDV\n");
#endif
tags_liste.push_back(make_pair(FLDV, code));
code += sizeof(FLDV_);
break;
case FSTPV:
#ifdef DEBUGL
mexPrintf("FSTPV\n");
#endif
tags_liste.push_back(make_pair(FSTPV, code));
code += sizeof(FSTPV_);
break;
case FBEGINBLOCK:
#ifdef DEBUGL
mexPrintf("FBEGINBLOCK\n");
#endif
{
FBEGINBLOCK_ *fbegin_block = new FBEGINBLOCK_;
code = fbegin_block->load(code);
tags_liste.push_back(make_pair(FBEGINBLOCK, fbegin_block));
}
break;
default:
mexPrintf("Unknown Tag value=%d code=%x\n",*code, code);
done = true;
}
}
return tags_liste;
};
};
#endif
#pragma pack(pop)
#endif