Index: tol/contrib/cint/tolCint.cpp =================================================================== --- tol/contrib/cint/tolCint.cpp (revision a29d86c40f5ed9bc0daa581054b24415dbeb331a) +++ tol/contrib/cint/tolCint.cpp (revision 297c5f5a849ef82b8dd68ef3287d14ebc813f007) @@ -31,7 +31,8 @@ #include #include +#include //#pragma pack(16) -//#include +#include #include //#pragma pack(4) @@ -69,18 +70,94 @@ } - -//-------------------------------------------------------------------- -int Cint_initialize() -//-------------------------------------------------------------------- -{ - int G__init_cint_ = G__init_cint("cint"); - G__set_errmsgcallback(reinterpret_cast(Cint_errmsgcallback)); - G__setautoconsole(1); - return(G__init_cint_); -} - -//-------------------------------------------------------------------- -static int G__init_cint__ = Cint_initialize(); -//-------------------------------------------------------------------- +//-------------------------------------------------------------------- +int& Cint_is_initialized() +//-------------------------------------------------------------------- +{ + static int _Cint__initialized_ = false; + return(_Cint__initialized_); +} + +//-------------------------------------------------------------------- +int Cint_initialize(const BText& filePath) +//-------------------------------------------------------------------- +{ + if(Cint_is_initialized()) + { + return(G__INIT_CINT_SUCCESS); + } + else + { + Cint_is_initialized() = true; + BText order = "cint"; + if(filePath.HasName()) { order += BText(" ")+filePath; } + int G__init_cint_ = G__init_cint(order); + switch(G__init_cint_) { + case G__INIT_CINT_SUCCESS_MAIN: + Error("Cint called out of main should never happen G__INIT_CINT_SUCCESS_MAIN.\n"); + /* Should never happen */ + break; + case G__INIT_CINT_SUCCESS: + Std("\nCint has been succesfully initialized.\n"); + break; + case G__INIT_CINT_FAILURE: + default: + Error("Cint initialization failed G__INIT_CINT_FAILURE.\n"); + } + G__set_errmsgcallback(Cint_errmsgcallback); + return(G__init_cint_); + } +} + +//-------------------------------------------------------------------- +int Cint_scratch_all() +//-------------------------------------------------------------------- +{ + if(Cint_is_initialized()) + { + return(false); + } + else + { + Cint_is_initialized() = false; + return(Cint_scratch_all()); + } +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatCint_initialize); + DefExtOpr(1, BDatCint_initialize, "Cint.initialize", 1, 1, "Text", + "(Text filePath)", + I2("Initializes the CINT environment with an optional C/C++ file.", + "Inicilaliza el entorno de CINT con un fichero C/C++ opcional.")+ + cint_url_link(), + BOperClassify::Conversion_); + void BDatCint_initialize::CalcContens() +//-------------------------------------------------------------------- +{ + if(CheckNonDeclarativeAction("Cint.initialize")) { return; } + BText& filePath = Text(Arg(1)); + contens_ = Cint_initialize(filePath); +} + + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatCint_scratch_all); + DefExtOpr(1, BDatCint_scratch_all, "Cint.scratch_all", 1, 1, "Real", + "(Real unused)", + I2("Terminates the interpreter and frees heap memory used by it." + "The interpreter should not be used after call this function." + "To resume the interpreter, user needs to call function Cint.initialize.", + "Termina el intérprete y libera memoria heap usada por él." + "El intérprete no debe utilizarse después de llamar a esta función." + "Para continuar con el intérprete, el usuario debe llamar a la " + "función Cint.initialize.")+ + cint_url_link(), + BOperClassify::Conversion_); + void BDatCint_scratch_all::CalcContens() +//-------------------------------------------------------------------- +{ + if(CheckNonDeclarativeAction("Cint.scratch_all")) { return; } + contens_ = Cint_scratch_all(); +} @@ -121,5 +198,31 @@ //-------------------------------------------------------------------- DeclareContensClass(BDat, BDatTemporary, BDatCINT_exec_tempfile); - DefExtOpr(1, BDatCINT_exec_tempfile, "Cint.exec_text", 1, 1, "Text", + DefExtOpr(1, BDatCINT_exec_tempfile, "Cint.exec_tempfile", 1, 1, "Text", + "(Text filePath)", + I2("Opens temporary source file and execute it in the current context. " + "The tempfile can contain variable declaration, struct, union, " + "enum definitions, conditional expressions, loop and control " + "statements but cannot contain function nor class definitions, " + "wich can be loaded just calling Cint.loadfile", + "Abre un archivo temporal de código fuente, que se ejecuta en el " + "contexto actual. El archivo temporal puede contener declaración " + "de variables, definiones de struct, union, enum, expresiones " + "condicionales, órdenes de control y bucles, pero no puede " + "contener definiciones de función ni de clase, las cuales " + "sólo pueden cargarse con Cint.loadfile"), + BOperClassify::Conversion_); + void BDatCINT_exec_tempfile::CalcContens() +//-------------------------------------------------------------------- +{ + if(CheckNonDeclarativeAction("Cint.exec_tempfile")) { return; } + BText& filePath = Text(Arg(1)); + G__exec_tempfile(filePath.String()); + contens_ = true; +} + + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatCINT_exec_text); + DefExtOpr(1, BDatCINT_exec_text, "Cint.exec_text", 1, 1, "Text", "(Text expression)", I2("Executes any C/C++ expression or set of expressions.\n" @@ -136,5 +239,5 @@ cint_url_link(), BOperClassify::Conversion_); - void BDatCINT_exec_tempfile::CalcContens() + void BDatCINT_exec_text::CalcContens() //-------------------------------------------------------------------- { @@ -166,27 +269,29 @@ if(CheckNonDeclarativeAction("Cint.calc")) { return; } BText& expression = Text(Arg(1)); - G__value g = G__calc(expression.String()); + contens_ = G__double(G__calc(expression)); +/* + G__value g = G__calc(expression); switch (g.type) { case 100: contens_ = g.obj.d; break; case 105: contens_ = g.obj.i; break; - default: Error(I2("Unknown CINT type ", - "Tipo CINT desconocido ")<Grammar(); + BSet& arg = Set(Arg(1)); + BText prefix_ = ""; + BText sufix_ = ""; + BText namespace_ = ""; + if(Arg(2)) { prefix_ = Text(Arg(2)); } + if(Arg(3)) { sufix_ = Text(Arg(3)); } + if(Arg(4)) { namespace_ = Text(Arg(4)); } + BText expression = ""; + if(namespace_.HasName()) + { + expression = BText("namespace ") + namespace_ + " {\n"; + }; + int c = arg.Card(); + contens_.PrepareStore(c); + for(numArg = 1; numArg<=c; numArg++) + { + var = arg[numArg]; + if(!var) { continue; } + gra = var->Grammar(); + BText pns = prefix_+var->Name()+sufix_; if(gra==GraReal()) { @@ -227,8 +360,7 @@ double* ptr = (double*)(&dat); int ptrNum = (int)ptr; - BText expression = BText("double& ")+var->Name()+" = *((double *)("<Name()+" ( "<< + expression += BText("Matrix ")+pns+" ( "<< mat.Rows()<<","<< mat.Columns()<<","<< - " ((double *)("<Name()+" ( "<< + expression += BText("Text ")+pns+" ( "<< txt.Length()<<","<< - " ((char *)("<Name()); - } - } -} - + I2("Cannot import TOL variable ", + "No se puede importar la variable TOL ")<< + gra->Name()+" "+var->Name()); + } + } + if(namespace_.HasName()) + { + expression += "\n};"; + }; +//Std(BText("\nTRACE [Cint.import_from_tol] expression=[\n")+expression+"\n]\n"); + G__exec_text(expression); +} + + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatCINT_delete_variables); + DefExtOpr(1, BDatCINT_delete_variables, + "Cint.delete_variables", 1, 3, + "Set Text Text", + "(Set varNames [, Text prefix=\"\", Text suffix=\"\"] )", + I2("Deletes from CINT global scope the variables which names are in " + "specified set varNames.\n" + "Returns the number of deleted variables.\n", + "Borra del ámbito global de CINT las variables cuyos nombres se " + "especifican en el conjunto varNames\n" + "Devuelve el número total de variables realmente borradas.\n")+ + I2("If argument prefix is not empty then it will added before each TOL name to " + "create transformed CINT names.\n", + "Si el argumento prefix no es vacío se añadirá por delante de cada nombre TOL " + "para crear los nombres CINT transformados.\n")+ + I2("If argument suffix is not empty then it will added after each TOL name to " + "create transformed CINT names.\n", + "Si el argumento suffix no es vacío se añadirá por detrás de cada nombre TOL " + "para crear los nombres CINT transformados.\n") + + cint_url_link(), + BOperClassify::Conversion_); + void BDatCINT_delete_variables::CalcContens() +//-------------------------------------------------------------------- +{ + if(CheckNonDeclarativeAction("Cint.delete_variables")) { return; } + + BSyntaxObject* var = NULL; + BGrammar* gra = NULL; + int numArg; + contens_ = 0; + BSet& arg = Set(Arg(1)); + BText prefix_ = ""; + BText sufix_ = ""; + if(Arg(2)) { prefix_ = Text(Arg(2)); } + if(Arg(3)) { sufix_ = Text(Arg(3)); } + + for(numArg = 1; numArg<=arg.Card(); numArg++) + { + var = arg[numArg]; + if(!var) { continue; } + gra = var->Grammar(); + if(gra==GraText()) + { + BText pns = prefix_+var->Name()+sufix_; + contens_ += G__deletevariable(pns); + } + } +} +