Changeset 4412

Show
Ignore:
Timestamp:
03/21/12 20:55:07 (6 years ago)
Author:
hacarralero
Message:

Añadidos a la clase TOLMachine todos los métodos que interactúan con el intérprete de TOL.

Location:
tolgrid/tolmachine/trunk/TOLGrid-TOLMACHINE
Files:
3 modified

Legend:

Unmodified
Added
Removed
  • tolgrid/tolmachine/trunk/TOLGrid-TOLMACHINE/tolgrid.h

    r4410 r4412  
    4949#define ERROR_FILE_IO                       206   //ERROR: File I/O error 
    5050 
     51//Errores generados por TOLMachine 
     52#define ERROR_TM_VARIABLE_NOT_FOUND     2       // Se intenta acceder a una variable TOL con un nombre no encontrado 
     53#define ERROR_TM_VARIABLE_NULL          3       // Se intenta acceder a una variable TOL con nombre NULO o VACÍO 
     54#define ERROR_TM_EXECUTE                4       // No se pudo ejecutar correctamente el código TOL 
     55#define ERROR_TM_INVALID_DATE           5       // Se intenta usar una fecha no válida para la operación 
     56#define ERROR_TM_INVALID_INDEX          6       // Se intenta usar un elemento de un conjunto con indice fuera de rango 
     57#define ERROR_TM_INVALID_TYPE           7       // Se intenta asignar a una variable un valor de un tipo distinto al de la variable 
     58#define ERROR_TM_INVALID_ID             8       // Se intenta establecer una conexión enviando un id que no corresponde al asignado a la tolmachine 
     59#define ERROR_TM_INTERNAL_FILE_ERROR    9       // Se intenta realizar una operación sobre un fichero y falla 
     60#define ERROR_TM_INVALID_COMMAND        10      // Se ha enviado un comando inválido o desconocido 
     61 
     62/* Tipos de mensajes: ERROR, WARNING, OUTPUT, TOLGRID */ 
     63#define MSG_TYPE_TOL_ERROR          1 
     64#define MSG_TYPE_TOL_WARNING        2 
     65#define MSG_TYPE_TOL_OUTPUT         3 
     66#define MSG_TYPE_TOLGRID            4 
     67 
    5168typedef struct { 
    5269    int nm; /* Número de mensajes*/ 
     
    184201} TOLNAMEBLOCK; 
    185202 
     203 
    186204class TOLGridStream { 
    187205private: 
  • tolgrid/tolmachine/trunk/TOLGrid-TOLMACHINE/tolmachine.cpp

    r4410 r4412  
    3131#endif 
    3232 
    33 #include <vector> 
    3433 
    3534#include <tol/tol_init.h> 
     
    8382static pthread_mutex_t server_info_mutex = PTHREAD_MUTEX_INITIALIZER; 
    8483 
    85 /*Información sobre este servidor (tolserver)*/ 
    86 static TOLMachine *tma; 
    87  
    8884/*Código del último error ocurrido*/ 
    89 static int errorTM = ERROR_TM_NOERROR; 
     85static int errorTM = ERROR_NOT_ERROR; 
    9086 
    9187/*Semáforo para sincronizar el acceso al código del último error (errorTM)*/ 
    9288static pthread_mutex_t errorTM_mutex = PTHREAD_MUTEX_INITIALIZER; 
    9389 
    94 /*Vector de mensajes generados por TOL/TOLGrid que son maneados por el cliente*/ 
    95 static vector<char *> messagesTM; 
    96  
    97 /*Vector de mensajes generados por TOL/TOLGrid que son almacenados por TOLMachine hasta el fin de su ejecución*/ 
    98 static vector<char *> messagesTMP; 
    99  
    10090/*Semáforo para sincronizar el acceso a los mensajes de error (Messages)*/ 
    10191static pthread_mutex_t messagesTM_mutex = PTHREAD_MUTEX_INITIALIZER; 
     
    10999/**/ 
    110100static long confirm_port = 2002; 
     101 
     102//Puntero global a la TOLMachine activa 
     103static TOLMachine *curTMA= NULL; 
    111104 
    112105TOLMachine::TOLMachine(double ident, int service_port, int control_port, int confirm_port) { 
     
    260253} 
    261254 
     255void TOLMachine::clearMessages(void) { 
     256    int t = this->messages.size(); 
     257    for (int i = 0; i < t; ++i) { 
     258        char *mensaje = this->messages[i]; 
     259        free(mensaje); 
     260    } 
     261    this->messages.clear(); 
     262} 
     263 
    262264/*Función utilitaria para borrar todos los mensajes almacenados*/ 
    263265void clearMessages(void) { 
    264266    /* Se activa el semáforo para que desde otro hilo no se acceda a Messages en este momento*/ 
    265267    pthread_mutex_lock(&messagesTM_mutex); 
    266     int t = messagesTM.size(); 
    267     for (int i = 0; i < t; ++i) { 
    268         char *mensaje = messagesTM[i]; 
    269         free(mensaje); 
    270     } 
    271     messagesTM.clear(); 
     268    if (curTMA!=NULL) { 
     269        curTMA->clearMessages(); 
     270    } 
    272271    /* Se desactiva el semáforo para que otro hilo pueda acceder a Messages a partir de este momento*/ 
    273272    pthread_mutex_unlock(&messagesTM_mutex); 
    274273} 
     274 
    275275FILE *f; 
    276276 
    277 /*Función utilitaria para obtener mensajes del intérprete de TOL*/ 
    278 static void saveMessage(const BText &message) { 
    279     /* Se activa el semáforo para que desde otro hilo no se acceda a Messages en este momento*/ 
    280     pthread_mutex_lock(&messagesTM_mutex); 
     277void TOLMachine::saveMessage(const BText &message) { 
    281278    time_t date = time(0); 
    282279    struct tm *tlocal = localtime(&date); 
     
    301298                strcat(cmsg, "</O>"); 
    302299            } 
    303             messagesTM.push_back(cmsg); 
     300            messages.push_back(cmsg); 
    304301        } 
    305302        cmsgp = (char *) malloc(l + 1); 
    306303        if (cmsgp != NULL) { 
    307304            strcpy(cmsgp, cmsg); 
    308             messagesTMP.push_back(cmsgp); 
    309         } 
    310     } 
    311     /* Se desactiva el semáforo para que otro hilo pueda acceder a Messages a partir de este momento*/ 
    312     pthread_mutex_unlock(&messagesTM_mutex); 
    313     /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
    314     pthread_mutex_lock(&server_info_mutex); 
    315     /* Se está procesando un comando */ 
    316     char send_log = tma.send_log; 
    317     /* Se desactiva el semáforo para que el otro hilo pueda acceder a server_info a partir de este momento*/ 
    318     pthread_mutex_unlock(&server_info_mutex); 
    319     if (send_log == 'Y' && cmsg != NULL && client_socket != -1) { 
     305            messagesP.push_back(cmsgp); 
     306        } 
     307    } 
     308    if (this->sendLog == 'Y' && cmsg != NULL ) { 
    320309        short msgType; 
    321310        switch (cmsg[16]) { 
     
    333322                break; 
    334323        } 
    335         writeShort(client_socket, msgType); 
    336         /*Se chequea si hubo error de comunicación*/ 
    337         if (getError() != ERRORCOM_NOTERROR) { 
    338             /*Se ha producido un error de comunicación con el cliente de TOLMachine*/ 
    339             printf("\nERROR15: CAN'T WRITE TO CLIENT\n"); 
    340             /* Se activa el semáforo para que ningún hilo acceda a server_info en este momento*/ 
    341             pthread_mutex_lock(&server_info_mutex); 
    342             /* EL status del servidor pasa a DEAD por el error de comunicación producido */ 
    343             tma.status = DEAD; 
    344             /* Se desactiva el semáforo para que cualquier hilo pueda acceder a server_info a partir de este momento*/ 
    345             pthread_mutex_unlock(&server_info_mutex); 
    346         } else { 
    347             writeString(client_socket, cmsg); 
    348             if (getError() != ERRORCOM_NOTERROR) { 
    349                 /*Se ha producido un error de comunicación con el cliente de TOLMachine*/ 
    350                 printf("\nERROR15: CAN'T WRITE TO CLIENT\n"); 
    351                 /* Se activa el semáforo para que ningún hilo acceda a server_info en este momento*/ 
    352                 pthread_mutex_lock(&server_info_mutex); 
    353                 /* EL status del servidor pasa a DEAD por el error de comunicación producido */ 
    354                 tma.status = DEAD; 
    355                 /* Se desactiva el semáforo para que cualquier hilo pueda acceder a server_info a partir de este momento*/ 
    356                 pthread_mutex_unlock(&server_info_mutex); 
     324        TOLGridStream tgs(this->ssService); 
     325        this->error= tgs.getError(); 
     326        if (this->error==ERROR_NOT_ERROR) { 
     327            tgs.writeShort(msgType); 
     328            this->error= tgs.getError(); 
     329            if (this->error==ERROR_NOT_ERROR) { 
     330                tgs.writeString(cmsg); 
     331                this->error= tgs.getError(); 
    357332            } 
    358333        } 
    359334    } 
     335    if (this->error==ERROR_NOT_ERROR) { 
     336        this->status= DEAD; 
     337    } 
    360338} 
    361  
    362 /*Retorna todos los mensajes generados por la última ejecución de código TOL*/ 
    363 TOLMESSAGES *getMessages(void) { 
     339/*Función utilitaria para obtener mensajes del intérprete de TOL*/ 
     340static void saveMessage(const BText &message) { 
    364341    /* Se activa el semáforo para que desde otro hilo no se acceda a Messages en este momento*/ 
    365342    pthread_mutex_lock(&messagesTM_mutex); 
    366     int error = ERROR_TM_NOERROR; 
     343    if (curTMA!=NULL) { 
     344        curTMA->saveMessage(message); 
     345    } 
     346    /* Se desactiva el semáforo para que otro hilo pueda acceder a Messages a partir de este momento*/ 
     347    pthread_mutex_unlock(&messagesTM_mutex); 
     348} 
     349 
     350/*Retorna todos los mensajes generados por la última ejecución de código TOL*/ 
     351TOLMESSAGES *TOLMachine::getMessages(void) { 
     352    /* Se activa el semáforo para que desde otro hilo no se acceda a Messages en este momento*/ 
     353    pthread_mutex_lock(&messagesTM_mutex); 
     354    this->error = ERROR_NOT_ERROR; 
    367355    TOLMESSAGES *tm = (TOLMESSAGES *) malloc(sizeof (TOLMESSAGES)); 
    368356    if (tm == NULL) { 
    369         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     357        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    370358    } else { 
    371         tm->nm = messagesTM.size(); 
     359        tm->nm = messages.size(); 
    372360        if (tm->nm == 0) { 
    373361            tm->messages = NULL; 
     
    376364            if (tm->messages == NULL) { 
    377365                free(tm); 
    378                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     366                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    379367            } else { 
    380368                for (int i = 0; i < tm->nm; ++i) { 
    381                     char *message = messagesTM[i]; 
     369                    char *message = messages[i]; 
    382370                    if (message == NULL) { 
    383371                        tm->messages[i] = NULL; 
     
    393381                                } 
    394382                                free(tm); 
    395                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     383                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    396384                            } else { 
    397385                                strcpy(tm->messages[i], message); 
     
    403391        } 
    404392    } 
    405     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    406     pthread_mutex_lock(&errorTM_mutex); 
    407     errorTM = error; /* Código del error producido */ 
    408     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    409     pthread_mutex_unlock(&errorTM_mutex); 
    410393    /* Se desactiva el semáforo para que otro hilo pueda acceder a Messages a partir de este momento*/ 
    411394    pthread_mutex_unlock(&messagesTM_mutex); 
     
    414397 
    415398/*Retorna todos los mensajes generados por TOL/TOLGrid*/ 
    416 TOLMESSAGES *getMessagesP(void) { 
     399TOLMESSAGES *TOLMachine::getMessagesP(void) { 
    417400    /* Se activa el semáforo para que desde otro hilo no se acceda a Messages en este momento*/ 
    418401    pthread_mutex_lock(&messagesTM_mutex); 
    419     int error = ERROR_TM_NOERROR; 
     402    this->error = ERROR_NOT_ERROR; 
    420403    TOLMESSAGES *tm = (TOLMESSAGES *) malloc(sizeof (TOLMESSAGES)); 
    421404    if (tm == NULL) { 
    422         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     405        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    423406    } else { 
    424         tm->nm = messagesTMP.size(); 
     407        tm->nm = messagesP.size(); 
    425408        if (tm->nm == 0) { 
    426409            tm->messages = NULL; 
     
    429412            if (tm->messages == NULL) { 
    430413                free(tm); 
    431                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     414                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    432415            } else { 
    433416                for (int i = 0; i < tm->nm; ++i) { 
    434                     char *message = messagesTMP[i]; 
     417                    char *message = messagesP[i]; 
    435418                    if (message == NULL) { 
    436419                        tm->messages[i] = NULL; 
     
    446429                                } 
    447430                                free(tm); 
    448                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     431                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    449432                            } else { 
    450433                                strcpy(tm->messages[i], message); 
     
    456439        } 
    457440    } 
    458     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    459     pthread_mutex_lock(&errorTM_mutex); 
    460     errorTM = error; /* Código del error producido */ 
    461     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    462     pthread_mutex_unlock(&errorTM_mutex); 
    463441    /* Se desactiva el semáforo para que otro hilo pueda acceder a Messages a partir de este momento*/ 
    464442    pthread_mutex_unlock(&messagesTM_mutex); 
     
    467445 
    468446/*Inicializa la instancia de TOL asociada a este servidor*/ 
    469 void initTOL(void) { 
    470     int error = ERROR_TM_NOERROR; 
     447void TOLMachine::initTOL(void) { 
     448    this->error = ERROR_NOT_ERROR; 
    471449    int lang = 1; 
    472450    char *vmode = NULL; 
     
    476454    BOut::PutHciWriter(saveMessage); 
    477455    BOut::PutLogHciWriter(saveMessage); 
    478     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    479     pthread_mutex_lock(&errorTM_mutex); 
    480     //OJO: hay que chequear si se ha producido un error y tomar el código del error producido 
    481     errorTM = error; /* No se ha producido ningún error */ 
    482     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    483     pthread_mutex_unlock(&errorTM_mutex); 
    484456} 
    485457 
    486458/*Ejecuta código TOL, retorna el número de errores producidos (0=NO HAY ERRORES)*/ 
    487 int executeCode(const char *tolcode) { 
    488     int error = ERROR_TM_NOERROR; 
     459int TOLMachine::executeCode(const char *tolcode) { 
     460    this->error = ERROR_NOT_ERROR; 
    489461    clearMessages(); 
    490462    TOLErrorNumber().GetValue() = 0; 
     
    492464    int ne = TOLErrorNumber().GetValue(); 
    493465    if (ne > 0) { 
    494         error = ERRORTM_EXECUTE; /* Error ejecutando código */ 
    495     } 
    496     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    497     pthread_mutex_lock(&errorTM_mutex); 
    498     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    499     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    500     pthread_mutex_unlock(&errorTM_mutex); 
     466        error = ERROR_TM_EXECUTE; /* Error ejecutando código */ 
     467    } 
    501468    return ne; 
    502469} 
    503470 
    504471/*Obtiene una variable cuyo nombre es pasado por argumento*/ 
    505 TOLVARIABLE getVariable(char *varname) { 
    506     int error = ERROR_TM_NOERROR; 
     472TOLVARIABLE TOLMachine::getVariable(char *varname) { 
     473    this->error = ERROR_NOT_ERROR; 
    507474    clearMessages(); 
    508475    TOLVARIABLE var; 
     
    517484        BUserText *btxt = UText(bso); 
    518485        if (btxt == NULL) { 
    519             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     486            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    520487        } else { 
    521488            TOLTEXT *text_value = (TOLTEXT *) malloc(sizeof (TOLTEXT)); 
    522489            if (text_value == NULL) { 
    523                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     490                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    524491            } else { 
    525492                const char *text = btxt->Contens().String(); 
     
    528495                    *text_value = (char *) malloc(text_len + 1); 
    529496                    if (text_value == NULL) { 
    530                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     497                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    531498                    } else { 
    532499                        strcpy((char *) (*text_value), text); 
     
    542509            BUserDat *br = UDat(bso); 
    543510            if (br == NULL) { 
    544                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     511                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    545512            } else { 
    546513                TOLREAL *real_value = (TOLREAL *) malloc(sizeof (TOLREAL)); 
    547514                if (real_value == NULL) { 
    548                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     515                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    549516                } else { 
    550517                    *real_value = br->Contens().GetValue(); 
     
    558525                BUserDate *bd = UDate(bso); 
    559526                if (bd == NULL) { 
    560                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     527                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    561528                } else { 
    562529                    TOLDATE *date_value = (TOLDATE *) malloc(sizeof (TOLDATE)); 
    563530                    if (date_value == NULL) { 
    564                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     531                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    565532                    } else { 
    566533                        BDate date = bd->Contens(); 
     
    580547                    BUserCmp *bc = UCmp(bso); 
    581548                    if (bc == NULL) { 
    582                         error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     549                        error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    583550                    } else { 
    584551                        var.value.value = (TOLCOMPLEX *) malloc(sizeof (TOLCOMPLEX)); 
    585552                        if (var.value.value == NULL) { 
    586                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     553                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    587554                        } else { 
    588555                            ((TOLCOMPLEX *) (var.value.value))->x = bc->Contens().X().GetValue(); 
     
    596563                        BUserMat *bmat = UMat(bso); 
    597564                        if (bmat == NULL) { 
    598                             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     565                            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    599566                        } else { 
    600567                            var.value.value = (TOLMATRIX *) malloc(sizeof (TOLMATRIX)); 
    601568                            if (var.value.value == NULL) { 
    602                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     569                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    603570                            } else { 
    604571                                BMatrix<BDat> mat = bmat->Contens(); 
     
    613580                                        free(var.value.value); 
    614581                                        var.value.value = NULL; 
    615                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     582                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    616583                                    } else { 
    617584                                        BArray<BDat> vals = mat.Data(); 
     
    631598                            BUserVMat *bvmat = UVMat(bso); 
    632599                            if (bvmat == NULL) { 
    633                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     600                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    634601                            } else { 
    635602                                var.value.value = (TOLVMATRIX *) malloc(sizeof (TOLVMATRIX)); 
    636603                                if (var.value.value == NULL) { 
    637                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     604                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    638605                                } else { 
    639606                                    BVMat vmat = bvmat->Contens(); 
     
    648615                                            free(var.value.value); 
    649616                                            var.value.value = NULL; 
    650                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     617                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    651618                                        } else { 
    652619                                            BMatrix<double> mat = vmat.GetDMat(); 
     
    667634                                BUserPol *bp = UPol(bso); 
    668635                                if (bp == NULL) { 
    669                                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     636                                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    670637                                } else { 
    671638                                    var.value.value = malloc(sizeof (TOLPOLYN)); 
    672639                                    if (var.value.value == NULL) { 
    673                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     640                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    674641                                    } else { 
    675642                                        BPolyn<BDat> pol = bp->Contens(); 
     
    680647                                            free(var.value.value); 
    681648                                            var.value.value = NULL; 
    682                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     649                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    683650                                        } else { 
    684651                                            for (int i = 0; i < nt; ++i) { 
     
    696663                                    BUserRat *br = URat(bso); 
    697664                                    if (br == NULL) { 
    698                                         error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     665                                        error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    699666                                    } else { 
    700667                                        var.value.value = malloc(sizeof (TOLRATIO)); 
    701668                                        if (var.value.value == NULL) { 
    702                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     669                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    703670                                        } else { 
    704671                                            BRational<BDat> rat = br->Contens(); 
     
    710677                                                free(var.value.value); 
    711678                                                var.value.value = NULL; 
    712                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     679                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    713680                                            } else { 
    714681                                                for (int i = 0; i < nt; ++i) { 
     
    725692                                                    free(var.value.value); 
    726693                                                    var.value.value = NULL; 
    727                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     694                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    728695                                                } else { 
    729696                                                    for (int i = 0; i < nt; ++i) { 
     
    742709                                        BUserCode *bc = UCode(bso); 
    743710                                        if (bc == NULL) { 
    744                                             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     711                                            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    745712                                        } else { 
    746713 
    747714                                            var.value.value = malloc(sizeof (TOLCODE)); 
    748715                                            if (var.value.value == NULL) { 
    749                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     716                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    750717                                            } else { 
    751718                                                BCode cod = bc->Contens(); 
     
    756723                                                        free(var.value.value); 
    757724                                                        var.value.value = NULL; 
    758                                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     725                                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    759726                                                    } else { 
    760727                                                        strcpy(((TOLCODE *) (var.value.value))->name, cod.Name().String()); 
    761728                                                    } 
    762729                                                } 
    763                                                 if (error == ERROR_TM_NOERROR) { 
     730                                                if (error == ERROR_NOT_ERROR) { 
    764731                                                    int lenInfo = cod.Info().Length(); 
    765732                                                    if (lenInfo > 0) { 
     
    769736                                                            free(var.value.value); 
    770737                                                            var.value.value = NULL; 
    771                                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     738                                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    772739                                                        } else { 
    773740                                                            strcpy(((TOLCODE *) (var.value.value))->info, cod.Info().String()); 
    774741                                                        } 
    775742                                                    } 
    776                                                     if (error == ERROR_TM_NOERROR) { 
     743                                                    if (error == ERROR_NOT_ERROR) { 
    777744                                                        int lenDump = cod.Dump().Length(); 
    778745                                                        if (lenDump > 0) { 
     
    783750                                                                free(var.value.value); 
    784751                                                                var.value.value = NULL; 
    785                                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     752                                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    786753                                                            } else { 
    787754                                                                strcpy(((TOLCODE *) (var.value.value))->dump, cod.Dump().String()); 
     
    799766                                            BUserTimeSet *bt = Tms(bso); 
    800767                                            if (bt == NULL) { 
    801                                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     768                                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    802769                                            } else { 
    803770                                                TOLTIMESET *timeset_value = (TOLTIMESET *) malloc(sizeof (TOLTIMESET)); 
    804771                                                if (timeset_value == NULL) { 
    805                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     772                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    806773                                                } else { 
    807774                                                    int lenName = strlen(varname); 
     
    811778                                                            free(timeset_value); 
    812779                                                            timeset_value = NULL; 
    813                                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     780                                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    814781                                                        } else { 
    815782                                                            strcpy(timeset_value->name, varname); 
     
    825792                                                BUserTimeSerie *bs = Tsr(bso); 
    826793                                                if (bs == NULL) { 
    827                                                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     794                                                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    828795                                                } else { 
    829796                                                    var.value.value = malloc(sizeof (TOLSERIE)); 
    830797                                                    if (var.value.value == NULL) { 
    831                                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     798                                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    832799                                                    } else { 
    833800                                                        int lenName = strlen(varname); 
     
    837804                                                                free(var.value.value); 
    838805                                                                var.value.value = NULL; 
    839                                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     806                                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    840807                                                            } else { 
    841808                                                                strcpy(((TOLSERIE *) (var.value.value))->name, varname); 
     
    850817                                                    BUserSet *bs = USet(bso); 
    851818                                                    if (bs == NULL) { 
    852                                                         error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     819                                                        error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    853820                                                    } else { 
    854821                                                        var.value.type = SET; 
    855822                                                        var.value.value = malloc(sizeof (TOLSET)); 
    856823                                                        if (var.value.value == NULL) { 
    857                                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     824                                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    858825                                                        } else { 
    859826                                                            int lenName = strlen(varname); 
     
    863830                                                                    free(var.value.value); 
    864831                                                                    var.value.value = NULL; 
    865                                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     832                                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    866833                                                                } else { 
    867834                                                                    strcpy(((TOLSET *) (var.value.value))->name, varname); 
     
    876843                                                        BUserNameBlock *bn = UNameBlock(bso); 
    877844                                                        if (bn == NULL) { 
    878                                                             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     845                                                            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    879846                                                        } else { 
    880847                                                            TOLNAMEBLOCK *nameblock_value = (TOLNAMEBLOCK *) malloc(sizeof (TOLNAMEBLOCK)); 
    881848                                                            if (nameblock_value == NULL) { 
    882                                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     849                                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    883850                                                            } else { 
    884851                                                                int lenName = strlen(varname); 
     
    886853                                                                    nameblock_value->name = (char *) malloc(lenName + 1); 
    887854                                                                    if (nameblock_value->name == NULL) { 
    888                                                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     855                                                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    889856                                                                    } else { 
    890857                                                                        strcpy((char *) nameblock_value->name, varname); 
     
    897864                                                        } 
    898865                                                    } else { 
    899                                                         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     866                                                        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    900867                                                    } 
    901868                                                } 
     
    911878        } 
    912879    } 
    913     if (error == ERROR_TM_NOERROR) { 
     880    if (error == ERROR_NOT_ERROR) { 
    914881        var.name = (char *) malloc(strlen(varname) + 1); 
    915882        if (var.name == NULL) { 
    916883            TOLGridUtil::freeValue(var.value); 
    917             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     884            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    918885        } else { 
    919886            strcpy(var.name, varname); 
     
    924891                free(var.name); 
    925892                var.name = NULL; 
    926                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     893                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    927894            } else { 
    928895                strcpy(var.desc, desc); 
     
    930897        } 
    931898    } 
    932     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    933     pthread_mutex_lock(&errorTM_mutex); 
    934     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    935     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    936     pthread_mutex_unlock(&errorTM_mutex); 
    937899    return var; 
    938900} 
    939901 
    940902/*Obtiene el valor contenido en un nodo sintáctico */ 
    941 TOLVALUE getValue(BSyntaxObject *bso) { 
    942     int error = ERROR_TM_NOERROR; 
     903TOLVALUE TOLMachine::getValue(BSyntaxObject *bso) { 
     904    this->error = ERROR_NOT_ERROR; 
    943905    clearMessages(); 
    944906    TOLVALUE value; 
     
    950912        TOLTEXT *text_value = (TOLTEXT *) malloc(sizeof (TOLTEXT)); 
    951913        if (text_value == NULL) { 
    952             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     914            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    953915        } else { 
    954916            const char *text = btxt->Contens().String(); 
     
    957919                *text_value = (char *) malloc(text_len + 1); 
    958920                if (text_value == NULL) { 
    959                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     921                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    960922                } else { 
    961923                    strcpy((char *) (*text_value), text); 
     
    970932            TOLREAL *real_value = (TOLREAL *) malloc(sizeof (TOLREAL)); 
    971933            if (real_value == NULL) { 
    972                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     934                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    973935            } else { 
    974936                *real_value = br->Contens().GetValue(); 
     
    981943                TOLDATE *date_value = (TOLDATE *) malloc(sizeof (TOLDATE)); 
    982944                if (date_value == NULL) { 
    983                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     945                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    984946                } else { 
    985947                    BDate date = bd->Contens(); 
     
    998960                    TOLCOMPLEX *complex_value = (TOLCOMPLEX *) malloc(sizeof (TOLCOMPLEX)); 
    999961                    if (complex_value == NULL) { 
    1000                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     962                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    1001963                    } else { 
    1002964                        complex_value->x = bc->Contens().X().GetValue(); 
     
    1010972                        TOLMATRIX *matrix_value = (TOLMATRIX *) malloc(sizeof (TOLMATRIX)); 
    1011973                        if (matrix_value == NULL) { 
    1012                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     974                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    1013975                        } else { 
    1014976                            BMatrix<BDat> mat = bmat->Contens(); 
     
    1023985                                    free(matrix_value); 
    1024986                                    matrix_value = NULL; 
    1025                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     987                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    1026988                                } else { 
    1027989                                    BArray<BDat> vals = mat.Data(); 
     
    10411003                            TOLVMATRIX *vmatrix_value = (TOLVMATRIX *) malloc(sizeof (TOLVMATRIX)); 
    10421004                            if (vmatrix_value == NULL) { 
    1043                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1005                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    10441006                            } else { 
    10451007                                BVMat vmat = bvmat->Contens(); 
     
    10541016                                        free(vmatrix_value); 
    10551017                                        vmatrix_value = NULL; 
    1056                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1018                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    10571019                                    } else { 
    10581020                                        BMatrix<double> mat = vmat.GetDMat(); 
     
    10731035                                TOLPOLYN *polyn_value = (TOLPOLYN *) malloc(sizeof (TOLPOLYN)); 
    10741036                                if (polyn_value == NULL) { 
    1075                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1037                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    10761038                                } else { 
    10771039                                    BPolyn<BDat> pol = bp->Contens(); 
     
    10821044                                        free(polyn_value); 
    10831045                                        polyn_value = NULL; 
    1084                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1046                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    10851047                                    } else { 
    10861048                                        for (int i = 0; i < nt; ++i) { 
     
    10981060                                    TOLRATIO *ratio_value = (TOLRATIO *) malloc(sizeof (TOLRATIO)); 
    10991061                                    if (ratio_value == NULL) { 
    1100                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1062                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11011063                                    } else { 
    11021064                                        BRational<BDat> rat = br->Contens(); 
     
    11081070                                            free(ratio_value); 
    11091071                                            ratio_value = NULL; 
    1110                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1072                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11111073                                        } else { 
    11121074                                            for (int i = 0; i < nt; ++i) { 
     
    11231085                                                free(ratio_value); 
    11241086                                                ratio_value = NULL; 
    1125                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1087                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11261088                                            } else { 
    11271089                                                for (int i = 0; i < nt; ++i) { 
     
    11401102                                        TOLCODE *code_value = (TOLCODE *) malloc(sizeof (TOLCODE)); 
    11411103                                        if (code_value == NULL) { 
    1142                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1104                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11431105                                        } else { 
    11441106                                            BCode cod = bc->Contens(); 
     
    11491111                                                    free(code_value); 
    11501112                                                    code_value = NULL; 
    1151                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1113                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11521114                                                } else { 
    11531115                                                    strcpy(code_value->name, cod.Name().String()); 
    11541116                                                } 
    11551117                                            } 
    1156                                             if (error == ERROR_TM_NOERROR) { 
     1118                                            if (error == ERROR_NOT_ERROR) { 
    11571119                                                int lenInfo = cod.Info().Length(); 
    11581120                                                if (lenInfo > 0) { 
     
    11621124                                                        free(code_value); 
    11631125                                                        code_value = NULL; 
    1164                                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1126                                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11651127                                                    } else { 
    11661128                                                        strcpy(code_value->info, cod.Info().String()); 
    11671129                                                    } 
    11681130                                                } 
    1169                                                 if (error == ERROR_TM_NOERROR) { 
     1131                                                if (error == ERROR_NOT_ERROR) { 
    11701132                                                    int lenDump = cod.Dump().Length(); 
    11711133                                                    if (lenDump > 0) { 
     
    11761138                                                            free(code_value); 
    11771139                                                            code_value = NULL; 
    1178                                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1140                                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11791141                                                        } else { 
    11801142                                                            strcpy(code_value->dump, cod.Dump().String()); 
     
    11911153                                            TOLTIMESET *timeset_value = (TOLTIMESET *) malloc(sizeof (TOLTIMESET)); 
    11921154                                            if (timeset_value == NULL) { 
    1193                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1155                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    11941156                                            } else { 
    11951157                                                const char *ts_name = bt->Name().String(); 
     
    12001162                                                        free(timeset_value); 
    12011163                                                        timeset_value = NULL; 
    1202                                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1164                                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12031165                                                    } else { 
    12041166                                                        strcpy(timeset_value->name, ts_name); 
     
    12151177                                                TOLSERIE *serie_value = (TOLSERIE *) malloc(sizeof (TOLSERIE)); 
    12161178                                                if (serie_value == NULL) { 
    1217                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1179                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12181180                                                } else { 
    12191181                                                    const char *ser_name = bs->Name().String(); 
     
    12241186                                                            free(serie_value); 
    12251187                                                            serie_value = NULL; 
    1226                                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1188                                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12271189                                                        } else { 
    12281190                                                            strcpy(serie_value->name, ser_name); 
     
    12391201                                                    TOLSET *set_value = (TOLSET *) malloc(sizeof (TOLSET)); 
    12401202                                                    if (set_value == NULL) { 
    1241                                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1203                                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12421204                                                    } else { 
    12431205                                                        const char *set_name = bs->Name().String(); 
     
    12481210                                                                free(set_value); 
    12491211                                                                set_value = NULL; 
    1250                                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1212                                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12511213                                                            } else { 
    12521214                                                                strcpy(set_value->name, set_name); 
     
    12631225                                                        TOLNAMEBLOCK *nameblock_value = (TOLNAMEBLOCK *) malloc(sizeof (TOLNAMEBLOCK)); 
    12641226                                                        if (nameblock_value == NULL) { 
    1265                                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1227                                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12661228                                                        } else { 
    12671229                                                            const char *nb_name = bnb->Name().String(); 
     
    12701232                                                                nameblock_value->name = (char *) malloc(lenName + 1); 
    12711233                                                                if (nameblock_value->name == NULL) { 
    1272                                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1234                                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    12731235                                                                } else { 
    12741236                                                                    strcpy((char *) nameblock_value->name, nb_name); 
     
    12801242                                                        } 
    12811243                                                    } else { 
    1282                                                         error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1244                                                        error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    12831245                                                    } 
    12841246                                                } 
     
    12941256        } 
    12951257    } 
    1296     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1297     pthread_mutex_lock(&errorTM_mutex); 
    1298     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1299     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1300     pthread_mutex_unlock(&errorTM_mutex); 
    13011258    return value; 
    13021259} 
    13031260 
    13041261/*Obtiene el valor de una variable cuyo nombre es pasado por argumento*/ 
    1305 TOLVALUE getValue(char *varname) { 
     1262TOLVALUE TOLMachine::getValue(char *varname) { 
    13061263    clearMessages(); 
    13071264    TOLVARIABLE var = getVariable(varname); 
     
    13101267 
    13111268/*Obtiene la fecha previa a una dada en un TimeSet cuyo nombre es dado*/ 
    1312 TOLDATE GetPrevDate_TimeSet(char *varname, TOLDATE date) { 
    1313     int error = ERROR_TM_NOERROR; 
     1269TOLDATE TOLMachine::GetPrevDate_TimeSet(char *varname, TOLDATE date) { 
     1270    this->error = ERROR_NOT_ERROR; 
    13141271    TOLDATE ndate; 
    13151272    ndate.year = 0; 
     
    13201277    BSyntaxObject *bso = GraTimeSet()->EvaluateExpr(varname); 
    13211278    if (bso == NULL) { 
    1322         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1279        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    13231280    } else { 
    13241281        BUserTimeSet *bs = Tms(bso); 
    13251282        if (bs == NULL) { 
    1326             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1283            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    13271284        } else { 
    13281285            BDate tdate; 
     
    13431300        } 
    13441301    } 
    1345     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1346     pthread_mutex_lock(&errorTM_mutex); 
    1347     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1348     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1349     pthread_mutex_unlock(&errorTM_mutex); 
    13501302    return ndate; 
    13511303} 
    13521304 
    13531305/*Obtiene la fecha siguiente a una dada en un TimeSet cuyo nombre es dado*/ 
    1354 TOLDATE GetNextDate_TimeSet(char *varname, TOLDATE date) { 
    1355     int error = ERROR_TM_NOERROR; 
     1306TOLDATE TOLMachine::GetNextDate_TimeSet(char *varname, TOLDATE date) { 
     1307    this->error = ERROR_NOT_ERROR; 
    13561308    TOLDATE ndate; 
    13571309    ndate.year = 0; 
     
    13621314    BSyntaxObject *bso = GraTimeSet()->EvaluateExpr(varname); 
    13631315    if (bso == NULL) { 
    1364         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1316        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    13651317    } else { 
    13661318        BUserTimeSet *bs = Tms(bso); 
    13671319        if (bs == NULL) { 
    1368             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1320            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    13691321        } else { 
    13701322            BDate tdate; 
     
    13731325            ndate.year = (short) pdate.Year(); 
    13741326            ndate.month = (char) pdate.Month(); 
    1375             ; 
    13761327            ndate.day = (char) pdate.Day(); 
    13771328            ndate.hour = (char) pdate.Hour(); 
     
    13801331        } 
    13811332    } 
    1382     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1383     pthread_mutex_lock(&errorTM_mutex); 
    1384     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1385     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1386     pthread_mutex_unlock(&errorTM_mutex); 
    13871333    return ndate; 
    13881334} 
    13891335 
    13901336/*Obtiene un arreglo fechas de un TimeSet, a partir de una fecha y una cantidad dada*/ 
    1391 TOLDATES getDates_TimeSet(char *varname, TOLDATE date, short size) { 
     1337TOLDATES TOLMachine::getDates_TimeSet(char *varname, TOLDATE date, short size) { 
    13921338    TOLDATES dates; 
    13931339    dates.ndates = 0; 
    13941340    dates.dates = NULL; 
    1395     int error = ERROR_TM_NOERROR; 
     1341    this->error = ERROR_NOT_ERROR; 
    13961342    clearMessages(); 
    13971343    BSyntaxObject *bso = GraTimeSet()->EvaluateExpr(varname); 
    13981344    if (bso == NULL) { 
    1399         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1345        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    14001346    } else { 
    14011347        BUserTimeSet *bs = Tms(bso); 
    14021348        if (bs == NULL) { 
    1403             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1349            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    14041350        } else { 
    14051351            BDate tdate; 
    14061352            tdate.PutDate(date.year, date.month, date.day, date.hour, date.minute, date.second); 
    14071353            if (!bs->Contain(tdate)) { 
    1408                 error = ERRORTM_INVALID_DATE; /*Fecha no válida para este TimeSet*/ 
     1354                error = ERROR_TM_INVALID_DATE; /*Fecha no válida para este TimeSet*/ 
    14091355            } else { 
    14101356                TOLDATE *dates1 = (TOLDATE *) malloc(size * sizeof (TOLDATE)); 
    14111357                if (dates1 == NULL) { 
    1412                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1358                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    14131359                } else { 
    14141360                    int i = 0; 
     
    14401386        } 
    14411387    } 
    1442     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1443     pthread_mutex_lock(&errorTM_mutex); 
    1444     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1445     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1446     pthread_mutex_unlock(&errorTM_mutex); 
    14471388    return dates; 
    14481389} 
    14491390 
    14501391/*Obtiene el fechado de una serie cuyo nombre es dado*/ 
    1451 char *GetDating_Serie(char *varname) { 
    1452     int error = ERROR_TM_NOERROR; 
     1392char *TOLMachine::GetDating_Serie(char *varname) { 
     1393    this->error = ERROR_NOT_ERROR; 
    14531394    clearMessages(); 
    14541395    char *expr = NULL; 
    14551396    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    14561397    if (bso == NULL) { 
    1457         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1398        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    14581399    } else { 
    14591400        BUserTimeSerie *bs = Tsr(bso); 
    14601401        if (bs == NULL) { 
    1461             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1402            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    14621403        } else { 
    14631404            BUserTimeSet *ts = bs->Dating(); 
     
    14671408                expr = (char *) malloc(len_expr + 1); 
    14681409                if (expr == NULL) { 
    1469                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1410                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    14701411                } else { 
    14711412                    strcpy(expr, old_expr); 
     
    14741415        } 
    14751416    } 
    1476     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1477     pthread_mutex_lock(&errorTM_mutex); 
    1478     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1479     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1480     pthread_mutex_unlock(&errorTM_mutex); 
    14811417    return expr; 
    14821418} 
    14831419 
    14841420/*Obtiene el valor de una serie en una fecha dada*/ 
    1485 TOLREAL getValue_Serie(char *varname, TOLDATE date) { 
    1486     int error = ERROR_TM_NOERROR; 
     1421TOLREAL TOLMachine::getValue_Serie(char *varname, TOLDATE date) { 
     1422    this->error = ERROR_NOT_ERROR; 
    14871423    clearMessages(); 
    14881424    TOLREAL value; 
    14891425    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    14901426    if (bso == NULL) { 
    1491         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1427        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    14921428    } else { 
    14931429        BUserTimeSerie *bs = Tsr(bso); 
    14941430        if (bs == NULL) { 
    1495             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1431            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    14961432        } else { 
    14971433            BDate d; 
     
    14991435            int index = bs->GetIndex(d); 
    15001436            if (index < 0) { 
    1501                 error = ERRORTM_INVALID_DATE; /* Fecha no válida porque no pertenece a la serie */ 
     1437                error = ERROR_TM_INVALID_DATE; /* Fecha no válida porque no pertenece a la serie */ 
    15021438            } else { 
    15031439                value = bs->GetDat(d).GetValue(); 
     
    15051441        } 
    15061442    } 
    1507     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1508     pthread_mutex_lock(&errorTM_mutex); 
    1509     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1510     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1511     pthread_mutex_unlock(&errorTM_mutex); 
    15121443    return value; 
    15131444} 
    15141445 
    15151446/*Obtiene un arreglo de items de una serie a partir de una fecha dada con un tamaño máximo dado*/ 
    1516 TOLSERIEITEMS getItems_Serie(char *varname, TOLDATE date, short size) { 
     1447TOLSERIEITEMS TOLMachine::getItems_Serie(char *varname, TOLDATE date, short size) { 
    15171448    TOLSERIEITEMS tsis; 
    15181449    tsis.nitems = 0; 
    15191450    tsis.items = NULL; 
    1520     int error = ERROR_TM_NOERROR; 
     1451    this->error = ERROR_NOT_ERROR; 
    15211452    clearMessages(); 
    15221453    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    15231454    if (bso == NULL) { 
    1524         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1455        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    15251456    } else { 
    15261457        BUserTimeSerie *bs = Tsr(bso); 
    15271458        if (bs == NULL) { 
    1528             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1459            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    15291460        } else { 
    15301461            BDate d; 
     
    15321463            int index = bs->GetIndex(d); 
    15331464            if (index < 0) { 
    1534                 error = ERRORTM_INVALID_DATE; /*Fecha no válida para esta Serie*/ 
     1465                error = ERROR_TM_INVALID_DATE; /*Fecha no válida para esta Serie*/ 
    15351466            } else { 
    15361467                int l = bs->GetLength(); 
     
    15411472                tsis.items = (TOLSERIEITEM *) malloc(tsis.nitems * sizeof (TOLSERIEITEM)); 
    15421473                if (tsis.items == NULL) { 
    1543                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1474                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    15441475                } else { 
    15451476                    for (int i = index; i < l; ++i) { 
     
    15571488        } 
    15581489    } 
    1559     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1560     pthread_mutex_lock(&errorTM_mutex); 
    1561     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1562     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1563     pthread_mutex_unlock(&errorTM_mutex); 
    15641490    return tsis; 
    15651491} 
    15661492 
    15671493/*Obtiene un arreglo de items de una serie a partir de una fecha dada con un tamaño máximo dado*/ 
    1568 TOLSERIEITEMS getAllItems_Serie(char *varname) { 
     1494TOLSERIEITEMS TOLMachine::getAllItems_Serie(char *varname) { 
    15691495    TOLSERIEITEMS tsis; 
    15701496    tsis.nitems = 0; 
    15711497    tsis.items = NULL; 
    1572     int error = ERROR_TM_NOERROR; 
     1498    this->error = ERROR_NOT_ERROR; 
    15731499    clearMessages(); 
    15741500    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    15751501    if (bso == NULL) { 
    1576         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1502        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    15771503    } else { 
    15781504        BUserTimeSerie *bs = Tsr(bso); 
    15791505        if (bs == NULL) { 
    1580             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1506            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    15811507        } else { 
    15821508            int l = bs->GetLength(); 
    15831509            if (l < 0) { 
    1584                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1510                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    15851511            } else { 
    15861512                tsis.items = (TOLSERIEITEM *) malloc(l * sizeof (TOLSERIEITEM)); 
    15871513                if (tsis.items == NULL) { 
    1588                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1514                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    15891515                } else { 
    15901516                    tsis.nitems = l; 
     
    16031529        } 
    16041530    } 
    1605     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1606     pthread_mutex_lock(&errorTM_mutex); 
    1607     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1608     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1609     pthread_mutex_unlock(&errorTM_mutex); 
    16101531    return tsis; 
    16111532} 
    16121533 
    16131534/*Obtiene la primera fecha de una serie*/ 
    1614 TOLDATE getFirstDate_Serie(char *varname) { 
    1615     int error = ERROR_TM_NOERROR; 
     1535TOLDATE TOLMachine::getFirstDate_Serie(char *varname) { 
     1536    this->error = ERROR_NOT_ERROR; 
    16161537    TOLDATE fdate; 
    16171538    fdate.year = 0; 
     
    16221543    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    16231544    if (bso == NULL) { 
    1624         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1545        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    16251546    } else { 
    16261547        BUserTimeSerie *bs = Tsr(bso); 
    16271548        if (bs == NULL) { 
    1628             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1549            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    16291550        } else { 
    16301551            BDate date = bs->FirstDate(); 
     
    16371558        } 
    16381559    } 
    1639     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1640     pthread_mutex_lock(&errorTM_mutex); 
    1641     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1642     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1643     pthread_mutex_unlock(&errorTM_mutex); 
    16441560    return fdate; 
    16451561} 
    16461562 
    16471563/*Obtiene la primera fecha de una serie*/ 
    1648 TOLDATE getLastDate_Serie(char *varname) { 
    1649     int error = ERROR_TM_NOERROR; 
     1564TOLDATE TOLMachine::getLastDate_Serie(char *varname) { 
     1565    this->error = ERROR_NOT_ERROR; 
    16501566    TOLDATE fdate; 
    16511567    fdate.year = 0; 
     
    16561572    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    16571573    if (bso == NULL) { 
    1658         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1574        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    16591575    } else { 
    16601576        BUserTimeSerie *bs = Tsr(bso); 
    16611577        if (bs == NULL) { 
    1662             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1578            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    16631579        } else { 
    16641580            BDate date = bs->LastDate(); 
     
    16711587        } 
    16721588    } 
    1673     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1674     pthread_mutex_lock(&errorTM_mutex); 
    1675     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1676     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1677     pthread_mutex_unlock(&errorTM_mutex); 
    16781589    return fdate; 
    16791590} 
    16801591 
    1681 /*Obtiene la primera fecha de una serie*/ 
    1682 int getSize_Serie(char *varname) { 
    1683     int error = ERROR_TM_NOERROR; 
     1592/*Obtiene el tamaño de una serie*/ 
     1593int TOLMachine::getSize_Serie(char *varname) { 
     1594    this->error = ERROR_NOT_ERROR; 
    16841595    int size = 0; 
    16851596    clearMessages(); 
    16861597    BSyntaxObject *bso = GraSerie()->EvaluateExpr(varname); 
    16871598    if (bso == NULL) { 
    1688         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1599        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    16891600    } else { 
    16901601        BUserTimeSerie *bs = Tsr(bso); 
    16911602        if (bs == NULL) { 
    1692             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1603            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    16931604        } else { 
    16941605            size = bs->Length(); 
    16951606        } 
    16961607    } 
    1697     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1698     pthread_mutex_lock(&errorTM_mutex); 
    1699     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1700     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1701     pthread_mutex_unlock(&errorTM_mutex); 
    17021608    return size; 
    17031609} 
    17041610 
    17051611/*Obtiene el tamaño de un elemento de tipo Set*/ 
    1706 int getSize_Set(char *varname) { 
    1707     int error = ERROR_TM_NOERROR; 
     1612int TOLMachine::getSize_Set(char *varname) { 
     1613    this->error = ERROR_NOT_ERROR; 
    17081614    int size = 0; 
    17091615    clearMessages(); 
    17101616    BSyntaxObject *bso = GraSet()->EvaluateExpr(varname); 
    17111617    if (bso == NULL) { 
    1712         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1618        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    17131619    } else { 
    17141620        BUserSet *bs = USet(bso); 
    17151621        if (bs == NULL) { 
    1716             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1622            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    17171623        } else { 
    17181624            size = bs->Contens().Card(); 
    17191625        } 
    17201626    } 
    1721     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1722     pthread_mutex_lock(&errorTM_mutex); 
    1723     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1724     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1725     pthread_mutex_unlock(&errorTM_mutex); 
    17261627    return size; 
    17271628} 
    17281629 
    17291630/*Obtiene un elemento de un conjunto ubicado en una posición dada*/ 
    1730 TOLVALUE getElement_Set(char *varname, int index) { 
    1731     int error = ERROR_TM_NOERROR; 
     1631TOLVALUE  TOLMachine::getElement_Set(char *varname, int index) { 
     1632    this->error = ERROR_NOT_ERROR; 
    17321633    TOLVALUE value; 
    17331634    value.type = ANYTHING; 
     
    17361637    BSyntaxObject *bso = GraSet()->EvaluateExpr(varname); 
    17371638    if (bso == NULL) { 
    1738         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1639        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    17391640    } else { 
    17401641        BUserSet *bs = USet(bso); 
    17411642        if (bs == NULL) { 
    1742             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1643            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    17431644        } else { 
    17441645            int size = bs->Contens().Card(); 
    17451646            if (index < 1 || index > size) { 
    1746                 error = ERRORTM_INVALID_INDEX; /*Índice fuera de rango*/ 
     1647                error = ERROR_TM_INVALID_INDEX; /*Índice fuera de rango*/ 
    17471648            } else { 
    17481649                BSyntaxObject *bse = bs->Contens().GetElement(index); 
    17491650                if (bse == NULL) { 
    1750                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1651                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    17511652                } else { 
    17521653                    value = getValue(bse); 
     
    17551656                        char *new_name = (char *) malloc(len_varname + 10); 
    17561657                        if (new_name == NULL) { 
    1757                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1658                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    17581659                        } else { 
    17591660                            sprintf(new_name, "%s[%d]", varname, index); 
     
    17961697        } 
    17971698    } 
    1798     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1799     pthread_mutex_lock(&errorTM_mutex); 
    1800     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1801     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1802     pthread_mutex_unlock(&errorTM_mutex); 
    18031699    return value; 
    18041700} 
    18051701 
    18061702/*Obtiene todos los elementos de un Set*/ 
    1807 TOLVALUES getElements_Set(char *varname) { 
    1808     int error = ERROR_TM_NOERROR; 
     1703TOLVALUES TOLMachine::getElements_Set(char *varname) { 
     1704    this->error = ERROR_NOT_ERROR; 
    18091705    TOLVALUES values; 
    18101706    values.nvalues = 0; 
     
    18131709    BSyntaxObject *bso = GraSet()->EvaluateExpr(varname); 
    18141710    if (bso == NULL) { 
    1815         error = ERRORTM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
     1711        error = ERROR_TM_VARIABLE_NOT_FOUND; /* Variable NO ENCONTRADA */ 
    18161712    } else { 
    18171713        BUserSet *bs = USet(bso); 
    18181714        if (bs == NULL) { 
    1819             error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1715            error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    18201716        } else { 
    18211717            int size = bs->Contens().Card(); 
    18221718            values.values = (TOLVALUE *) malloc(size * sizeof (TOLVALUE)); 
    18231719            if (values.values == NULL) { 
    1824                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1720                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    18251721            } else { 
    18261722                values.nvalues = size; 
     
    18321728                        char *new_name = (char *) malloc(len_varname + 10); 
    18331729                        if (new_name == NULL) { 
    1834                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1730                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    18351731                        } else { 
    18361732                            sprintf(new_name, "%s[%d]", varname, i + 1); 
     
    18691765                        } 
    18701766                    } 
    1871                     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1872                     pthread_mutex_lock(&errorTM_mutex); 
    1873                     error = errorTM; /* Código del error ocurrido (si lo hubo) */ 
    1874                     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1875                     pthread_mutex_unlock(&errorTM_mutex); 
    1876                     if (error != ERROR_TM_NOERROR) { 
     1767                    if (error != ERROR_NOT_ERROR) { 
    18771768                        free(values.values); 
    18781769                        values.nvalues = 0; 
     
    18841775        } 
    18851776    } 
    1886     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1887     pthread_mutex_lock(&errorTM_mutex); 
    1888     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1889     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1890     pthread_mutex_unlock(&errorTM_mutex); 
    18911777    return values; 
    18921778} 
    18931779 
    18941780/*Obtiene todas las variables de tipo Text*/ 
    1895 TOLVARIABLES getTextVariables(void) { 
    1896     int error = ERROR_TM_NOERROR; 
     1781TOLVARIABLES TOLMachine::getTextVariables(void) { 
     1782    this->error = ERROR_NOT_ERROR; 
    18971783    TOLVARIABLES vars; 
    18981784    vars.nvars = 0; 
     
    19051791        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    19061792        if (vars.vars == NULL) { 
    1907             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1793            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    19081794        } else { 
    19091795            vars.nvars = nv; 
     
    19161802                BSyntaxObject *bso = sv[i + 1]; 
    19171803                if (bso == NULL) { 
    1918                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1804                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    19191805                } else { 
    19201806                    const char *varname = bso->Name().String(); 
     
    19231809                        var.name = (char *) malloc(lenName + 1); 
    19241810                        if (var.name == NULL) { 
    1925                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1811                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    19261812                        } else { 
    19271813                            strcpy((char *) var.name, varname); 
    19281814                        } 
    19291815                    } 
    1930                     if (error == ERROR_TM_NOERROR) { 
     1816                    if (error == ERROR_NOT_ERROR) { 
    19311817                        const char *vardesc = bso->Description().String(); 
    19321818                        int lenDesc = strlen(vardesc); 
     
    19341820                            var.desc = (char *) malloc(lenDesc + 1); 
    19351821                            if (var.desc == NULL) { 
    1936                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1822                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    19371823                            } else { 
    19381824                                strcpy((char *) var.desc, vardesc); 
    19391825                            } 
    19401826                        } 
    1941                         if (error == ERROR_TM_NOERROR) { 
     1827                        if (error == ERROR_NOT_ERROR) { 
    19421828                            BUserText *btxt = UText(bso); 
    19431829                            if (btxt == NULL) { 
    1944                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1830                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    19451831                            } else { 
    19461832                                TOLTEXT *text_value = (TOLTEXT *) malloc(sizeof (TOLTEXT)); 
    19471833                                if (text_value == NULL) { 
    1948                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1834                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    19491835                                } else { 
    19501836                                    const char *text = btxt->Contens().String(); 
     
    19531839                                        *text_value = (char *) malloc(lenText + 1); 
    19541840                                        if (*text_value == NULL) { 
    1955                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1841                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    19561842                                        } else { 
    19571843                                            strcpy((char *) (*text_value), text); 
     
    19641850                    } 
    19651851                } 
    1966                 if (error == ERROR_TM_NOERROR) { 
     1852                if (error == ERROR_NOT_ERROR) { 
    19671853                    vars.vars[i] = var; 
    19681854                } else { 
     
    19721858        } 
    19731859    } 
    1974     if (error != ERROR_TM_NOERROR) { 
     1860    if (error != ERROR_NOT_ERROR) { 
    19751861        if (vars.vars != NULL) { 
    19761862            for (int i = 0; i < vars.nvars; ++i) { 
     
    19821868        vars.vars = NULL; 
    19831869    } 
    1984     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    1985     pthread_mutex_lock(&errorTM_mutex); 
    1986     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    1987     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    1988     pthread_mutex_unlock(&errorTM_mutex); 
    19891870    return vars; 
    19901871} 
    19911872 
    19921873/*Obtiene todas las variables de tipo Real*/ 
    1993 TOLVARIABLES getRealVariables(void) { 
    1994     int error = ERROR_TM_NOERROR; 
     1874TOLVARIABLES TOLMachine::getRealVariables(void) { 
     1875    this->error = ERROR_NOT_ERROR; 
    19951876    TOLVARIABLES vars; 
    19961877    vars.nvars = 0; 
     
    20031884        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    20041885        if (vars.vars == NULL) { 
    2005             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1886            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    20061887        } else { 
    20071888            vars.nvars = nv; 
     
    20141895                BSyntaxObject *bso = sv[i + 1]; 
    20151896                if (bso == NULL) { 
    2016                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1897                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    20171898                } else { 
    20181899                    const char *varname = bso->Name().String(); 
     
    20211902                        var.name = (char *) malloc(lenName + 1); 
    20221903                        if (var.name == NULL) { 
    2023                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1904                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    20241905                        } else { 
    20251906                            strcpy((char *) var.name, varname); 
    20261907                        } 
    20271908                    } 
    2028                     if (error == ERROR_TM_NOERROR) { 
     1909                    if (error == ERROR_NOT_ERROR) { 
    20291910                        const char *vardesc = bso->Description().String(); 
    20301911                        int lenDesc = strlen(vardesc); 
     
    20321913                            var.desc = (char *) malloc(lenDesc + 1); 
    20331914                            if (var.desc == NULL) { 
    2034                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1915                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    20351916                            } else { 
    20361917                                strcpy((char *) var.desc, vardesc); 
    20371918                            } 
    20381919                        } 
    2039                         if (error == ERROR_TM_NOERROR) { 
     1920                        if (error == ERROR_NOT_ERROR) { 
    20401921                            BUserDat *br = UDat(bso); 
    20411922                            if (br == NULL) { 
    2042                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1923                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    20431924                            } else { 
    20441925                                TOLREAL *realvalue = (TOLREAL *) malloc(sizeof (TOLREAL)); 
    20451926                                if (realvalue == NULL) { 
    2046                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1927                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    20471928                                } else { 
    20481929                                    *realvalue = br->Contens().GetValue(); 
     
    20531934                    } 
    20541935                } 
    2055                 if (error == ERROR_TM_NOERROR) { 
     1936                if (error == ERROR_NOT_ERROR) { 
    20561937                    vars.vars[i] = var; 
    20571938                } else { 
     
    20611942        } 
    20621943    } 
    2063     if (error != ERROR_TM_NOERROR) { 
     1944    if (error != ERROR_NOT_ERROR) { 
    20641945        if (vars.vars != NULL) { 
    20651946            for (int i = 0; i < vars.nvars; ++i) { 
     
    20711952        vars.vars = NULL; 
    20721953    } 
    2073     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2074     pthread_mutex_lock(&errorTM_mutex); 
    2075     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2076     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2077     pthread_mutex_unlock(&errorTM_mutex); 
    20781954    return vars; 
    20791955} 
    20801956 
    20811957/*Obtiene todas las variables de tipo Date*/ 
    2082 TOLVARIABLES getDateVariables(void) { 
    2083     int error = ERROR_TM_NOERROR; 
     1958TOLVARIABLES TOLMachine::getDateVariables(void) { 
     1959    this->error = ERROR_NOT_ERROR; 
    20841960    TOLVARIABLES vars; 
    20851961    vars.nvars = 0; 
     
    20921968        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    20931969        if (vars.vars == NULL) { 
    2094             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1970            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    20951971        } else { 
    20961972            vars.nvars = nv; 
     
    21031979                BSyntaxObject *bso = sv[i + 1]; 
    21041980                if (bso == NULL) { 
    2105                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     1981                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    21061982                } else { 
    21071983                    const char *varname = bso->Name().String(); 
     
    21101986                        var.name = (char *) malloc(lenName + 1); 
    21111987                        if (var.name == NULL) { 
    2112                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1988                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    21131989                        } else { 
    21141990                            strcpy((char *) var.name, varname); 
    21151991                        } 
    21161992                    } 
    2117                     if (error == ERROR_TM_NOERROR) { 
     1993                    if (error == ERROR_NOT_ERROR) { 
    21181994                        const char *vardesc = bso->Description().String(); 
    21191995                        int lenDesc = strlen(vardesc); 
     
    21211997                            var.desc = (char *) malloc(lenDesc + 1); 
    21221998                            if (var.desc == NULL) { 
    2123                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     1999                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    21242000                            } else { 
    21252001                                strcpy((char *) var.desc, vardesc); 
    21262002                            } 
    21272003                        } 
    2128                         if (error == ERROR_TM_NOERROR) { 
     2004                        if (error == ERROR_NOT_ERROR) { 
    21292005                            BUserDate *bd = UDate(bso); 
    21302006                            if (bd == NULL) { 
    2131                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2007                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    21322008                            } else { 
    21332009                                TOLDATE *date_value = (TOLDATE *) malloc(sizeof (TOLDATE)); 
    21342010                                if (date_value == NULL) { 
    2135                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2011                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    21362012                                } else { 
    21372013                                    BDate date = bd->Contens(); 
     
    21482024                    } 
    21492025                } 
    2150                 if (error == ERROR_TM_NOERROR) { 
     2026                if (error == ERROR_NOT_ERROR) { 
    21512027                    vars.vars[i] = var; 
    21522028                } else { 
     
    21562032        } 
    21572033    } 
    2158     if (error != ERROR_TM_NOERROR) { 
     2034    if (error != ERROR_NOT_ERROR) { 
    21592035        if (vars.vars != NULL) { 
    21602036            for (int i = 0; i < vars.nvars; ++i) { 
     
    21662042        vars.vars = NULL; 
    21672043    } 
    2168     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2169     pthread_mutex_lock(&errorTM_mutex); 
    2170     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2171     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2172     pthread_mutex_unlock(&errorTM_mutex); 
    21732044    return vars; 
    21742045} 
    21752046 
    21762047/*Obtiene todas las variables de tipo Complex*/ 
    2177 TOLVARIABLES getComplexVariables(void) { 
    2178     int error = ERROR_TM_NOERROR; 
     2048TOLVARIABLES TOLMachine::getComplexVariables(void) { 
     2049    this->error = ERROR_NOT_ERROR; 
    21792050    TOLVARIABLES vars; 
    21802051    vars.nvars = 0; 
     
    21872058        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    21882059        if (vars.vars == NULL) { 
    2189             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2060            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    21902061        } else { 
    21912062            vars.nvars = nv; 
     
    21982069                BSyntaxObject *bso = sv[i + 1]; 
    21992070                if (bso == NULL) { 
    2200                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2071                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    22012072                } else { 
    22022073                    const char *varname = bso->Name().String(); 
     
    22052076                        var.name = (char *) malloc(lenName + 1); 
    22062077                        if (var.name == NULL) { 
    2207                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2078                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    22082079                        } else { 
    22092080                            strcpy((char *) var.name, varname); 
    22102081                        } 
    22112082                    } 
    2212                     if (error == ERROR_TM_NOERROR) { 
     2083                    if (error == ERROR_NOT_ERROR) { 
    22132084                        const char *vardesc = bso->Description().String(); 
    22142085                        int lenDesc = strlen(vardesc); 
     
    22162087                            var.desc = (char *) malloc(lenDesc + 1); 
    22172088                            if (var.desc == NULL) { 
    2218                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2089                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    22192090                            } else { 
    22202091                                strcpy((char *) var.desc, vardesc); 
    22212092                            } 
    22222093                        } 
    2223                         if (error == ERROR_TM_NOERROR) { 
     2094                        if (error == ERROR_NOT_ERROR) { 
    22242095                            BUserCmp *bc = UCmp(bso); 
    22252096                            if (bc == NULL) { 
    2226                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2097                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    22272098                            } else { 
    22282099                                TOLCOMPLEX *complex_value = (TOLCOMPLEX *) malloc(sizeof (TOLCOMPLEX)); 
    22292100                                if (complex_value == NULL) { 
    2230                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2101                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    22312102                                } else { 
    22322103                                    complex_value->x = bc->Contens().X().GetValue(); 
     
    22382109                    } 
    22392110                } 
    2240                 if (error == ERROR_TM_NOERROR) { 
     2111                if (error == ERROR_NOT_ERROR) { 
    22412112                    vars.vars[i] = var; 
    22422113                } else { 
     
    22462117        } 
    22472118    } 
    2248     if (error != ERROR_TM_NOERROR) { 
     2119    if (error != ERROR_NOT_ERROR) { 
    22492120        if (vars.vars != NULL) { 
    22502121            for (int i = 0; i < vars.nvars; ++i) { 
     
    22562127        vars.vars = NULL; 
    22572128    } 
    2258     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2259     pthread_mutex_lock(&errorTM_mutex); 
    2260     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2261     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2262     pthread_mutex_unlock(&errorTM_mutex); 
    22632129    return vars; 
    22642130} 
    22652131 
    22662132/*Obtiene todas las variables de tipo Matrix*/ 
    2267 TOLVARIABLES getMatrixVariables(void) { 
    2268     int error = ERROR_TM_NOERROR; 
     2133TOLVARIABLES TOLMachine::getMatrixVariables(void) { 
     2134    this->error = ERROR_NOT_ERROR; 
    22692135    TOLVARIABLES vars; 
    22702136    vars.nvars = 0; 
     
    22772143        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    22782144        if (vars.vars == NULL) { 
    2279             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2145            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    22802146        } else { 
    22812147            vars.nvars = nv; 
     
    22882154                BSyntaxObject *bso = sv[i + 1]; 
    22892155                if (bso == NULL) { 
    2290                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2156                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    22912157                } else { 
    22922158                    const char *varname = bso->Name().String(); 
     
    22952161                        var.name = (char *) malloc(lenName + 1); 
    22962162                        if (var.name == NULL) { 
    2297                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2163                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    22982164                        } else { 
    22992165                            strcpy((char *) var.name, varname); 
    23002166                        } 
    23012167                    } 
    2302                     if (error == ERROR_TM_NOERROR) { 
     2168                    if (error == ERROR_NOT_ERROR) { 
    23032169                        const char *vardesc = bso->Description().String(); 
    23042170                        int lenDesc = strlen(vardesc); 
     
    23062172                            var.desc = (char *) malloc(lenDesc + 1); 
    23072173                            if (var.desc == NULL) { 
    2308                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2174                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    23092175                            } else { 
    23102176                                strcpy((char *) var.desc, vardesc); 
    23112177                            } 
    23122178                        } 
    2313                         if (error == ERROR_TM_NOERROR) { 
     2179                        if (error == ERROR_NOT_ERROR) { 
    23142180                            BUserMat *bmat = UMat(bso); 
    23152181                            if (bmat == NULL) { 
    2316                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2182                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    23172183                            } else { 
    23182184                                TOLMATRIX *matrix_value = (TOLMATRIX *) malloc(sizeof (TOLMATRIX)); 
    23192185                                if (matrix_value == NULL) { 
    2320                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2186                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    23212187                                } else { 
    23222188                                    BMatrix<BDat> mat = bmat->Contens(); 
     
    23282194                                        matrix_value->values = (double *) malloc(matrix_value->rows * matrix_value->cols * sizeof (double)); 
    23292195                                        if (matrix_value->values == NULL) { 
    2330                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2196                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    23312197                                        } else { 
    23322198                                            BArray<BDat> vals = mat.Data(); 
     
    23442210                    } 
    23452211                } 
    2346                 if (error == ERROR_TM_NOERROR) { 
     2212                if (error == ERROR_NOT_ERROR) { 
    23472213                    vars.vars[i] = var; 
    23482214                } else { 
     
    23522218        } 
    23532219    } 
    2354     if (error != ERROR_TM_NOERROR) { 
     2220    if (error != ERROR_NOT_ERROR) { 
    23552221        if (vars.vars != NULL) { 
    23562222            for (int i = 0; i < vars.nvars; ++i) { 
     
    23622228        vars.vars = NULL; 
    23632229    } 
    2364     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2365     pthread_mutex_lock(&errorTM_mutex); 
    2366     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2367     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2368     pthread_mutex_unlock(&errorTM_mutex); 
    23692230    return vars; 
    23702231} 
    23712232 
    23722233/*Obtiene todas las variables de tipo VMatrix*/ 
    2373 TOLVARIABLES getVMatrixVariables(void) { 
    2374     int error = ERROR_TM_NOERROR; 
     2234TOLVARIABLES TOLMachine::getVMatrixVariables(void) { 
     2235    this->error = ERROR_NOT_ERROR; 
    23752236    TOLVARIABLES vars; 
    23762237    vars.nvars = 0; 
     
    23832244        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    23842245        if (vars.vars == NULL) { 
    2385             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2246            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    23862247        } else { 
    23872248            vars.nvars = nv; 
     
    23942255                BSyntaxObject *bso = sv[i + 1]; 
    23952256                if (bso == NULL) { 
    2396                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2257                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    23972258                } else { 
    23982259                    const char *varname = bso->Name().String(); 
     
    24012262                        var.name = (char *) malloc(lenName + 1); 
    24022263                        if (var.name == NULL) { 
    2403                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2264                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    24042265                        } else { 
    24052266                            strcpy((char *) var.name, varname); 
    24062267                        } 
    24072268                    } 
    2408                     if (error == ERROR_TM_NOERROR) { 
     2269                    if (error == ERROR_NOT_ERROR) { 
    24092270                        const char *vardesc = bso->Description().String(); 
    24102271                        int lenDesc = strlen(vardesc); 
     
    24122273                            var.desc = (char *) malloc(lenDesc + 1); 
    24132274                            if (var.desc == NULL) { 
    2414                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2275                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    24152276                            } else { 
    24162277                                strcpy((char *) var.desc, vardesc); 
    24172278                            } 
    24182279                        } 
    2419                         if (error == ERROR_TM_NOERROR) { 
     2280                        if (error == ERROR_NOT_ERROR) { 
    24202281                            BUserVMat *bvmat = UVMat(bso); 
    24212282                            if (bvmat == NULL) { 
    2422                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2283                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    24232284                            } else { 
    24242285                                BVMat vmat = bvmat->Contens(); 
    24252286                                TOLVMATRIX *vmatrix_value = (TOLVMATRIX *) malloc(sizeof (TOLVMATRIX)); 
    24262287                                if (vmatrix_value == NULL) { 
    2427                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2288                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    24282289                                } else { 
    24292290                                    vmatrix_value->rows = vmat.Rows(); 
     
    24342295                                        vmatrix_value->values = (double *) malloc(vmatrix_value->rows * vmatrix_value->cols * sizeof (double)); 
    24352296                                        if (vmatrix_value->values == NULL) { 
    2436                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2297                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    24372298                                        } else { 
    24382299                                            BMatrix<double> mat = vmat.GetDMat(); 
     
    24512312                    } 
    24522313                } 
    2453                 if (error == ERROR_TM_NOERROR) { 
     2314                if (error == ERROR_NOT_ERROR) { 
    24542315                    vars.vars[i] = var; 
    24552316                } else { 
     
    24592320        } 
    24602321    } 
    2461     if (error != ERROR_TM_NOERROR) { 
     2322    if (error != ERROR_NOT_ERROR) { 
    24622323        if (vars.vars != NULL) { 
    24632324            for (int i = 0; i < vars.nvars; ++i) { 
     
    24692330        vars.vars = NULL; 
    24702331    } 
    2471     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2472     pthread_mutex_lock(&errorTM_mutex); 
    2473     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2474     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2475     pthread_mutex_unlock(&errorTM_mutex); 
    24762332    return vars; 
    24772333} 
    24782334 
    24792335/*Obtiene todas las variables de tipo Polyn*/ 
    2480 TOLVARIABLES getPolynVariables(void) { 
    2481     int error = ERROR_TM_NOERROR; 
     2336TOLVARIABLES TOLMachine::getPolynVariables(void) { 
     2337    this->error = ERROR_NOT_ERROR; 
    24822338    TOLVARIABLES vars; 
    24832339    vars.nvars = 0; 
     
    24902346        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    24912347        if (vars.vars == NULL) { 
    2492             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2348            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    24932349        } else { 
    24942350            vars.nvars = nv; 
     
    25012357                BSyntaxObject *bso = sv[i + 1]; 
    25022358                if (bso == NULL) { 
    2503                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2359                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    25042360                } else { 
    25052361                    const char *varname = bso->Name().String(); 
     
    25082364                        var.name = (char *) malloc(lenName + 1); 
    25092365                        if (var.name == NULL) { 
    2510                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2366                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    25112367                        } else { 
    25122368                            strcpy((char *) var.name, varname); 
    25132369                        } 
    25142370                    } 
    2515                     if (error == ERROR_TM_NOERROR) { 
     2371                    if (error == ERROR_NOT_ERROR) { 
    25162372                        const char *vardesc = bso->Description().String(); 
    25172373                        int lenDesc = strlen(vardesc); 
     
    25192375                            var.desc = (char *) malloc(lenDesc + 1); 
    25202376                            if (var.desc == NULL) { 
    2521                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2377                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    25222378                            } else { 
    25232379                                strcpy((char *) var.desc, vardesc); 
    25242380                            } 
    25252381                        } 
    2526                         if (error == ERROR_TM_NOERROR) { 
     2382                        if (error == ERROR_NOT_ERROR) { 
    25272383                            BUserPol *bp = UPol(bso); 
    25282384                            if (bp == NULL) { 
    2529                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2385                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    25302386                            } else { 
    25312387                                TOLPOLYN *polyn_value = (TOLPOLYN *) malloc(sizeof (TOLPOLYN)); 
    25322388                                if (var.desc == NULL) { 
    2533                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2389                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    25342390                                } else { 
    25352391                                    BPolyn<BDat> pol = bp->Contens(); 
     
    25382394                                    if (polyn_value->terms == NULL) { 
    25392395                                        polyn_value->nterm = 0; 
    2540                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2396                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    25412397                                    } else { 
    25422398                                        polyn_value->nterm = nt; 
     
    25532409                    } 
    25542410                } 
    2555                 if (error == ERROR_TM_NOERROR) { 
     2411                if (error == ERROR_NOT_ERROR) { 
    25562412                    vars.vars[i] = var; 
    25572413                } else { 
     
    25612417        } 
    25622418    } 
    2563     if (error != ERROR_TM_NOERROR) { 
     2419    if (error != ERROR_NOT_ERROR) { 
    25642420        if (vars.vars != NULL) { 
    25652421            for (int i = 0; i < vars.nvars; ++i) { 
     
    25712427        vars.vars = NULL; 
    25722428    } 
    2573     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2574     pthread_mutex_lock(&errorTM_mutex); 
    2575     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2576     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2577     pthread_mutex_unlock(&errorTM_mutex); 
    25782429    return vars; 
    25792430} 
    25802431 
    25812432/*Obtiene todas las variables de tipo Ratio*/ 
    2582 TOLVARIABLES getRatioVariables(void) { 
    2583     int error = ERROR_TM_NOERROR; 
     2433TOLVARIABLES TOLMachine::getRatioVariables(void) { 
     2434    this->error = ERROR_NOT_ERROR; 
    25842435    TOLVARIABLES vars; 
    25852436    vars.nvars = 0; 
     
    25922443        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    25932444        if (vars.vars == NULL) { 
    2594             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2445            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    25952446        } else { 
    25962447            vars.nvars = nv; 
     
    26032454                BSyntaxObject *bso = sv[i + 1]; 
    26042455                if (bso == NULL) { 
    2605                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2456                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    26062457                } else { 
    26072458                    const char *varname = bso->Name().String(); 
     
    26102461                        var.name = (char *) malloc(lenName + 1); 
    26112462                        if (var.name == NULL) { 
    2612                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2463                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    26132464                        } else { 
    26142465                            strcpy((char *) var.name, varname); 
    26152466                        } 
    26162467                    } 
    2617                     if (error == ERROR_TM_NOERROR) { 
     2468                    if (error == ERROR_NOT_ERROR) { 
    26182469                        const char *vardesc = bso->Description().String(); 
    26192470                        int lenDesc = strlen(vardesc); 
     
    26212472                            var.desc = (char *) malloc(lenDesc + 1); 
    26222473                            if (var.desc == NULL) { 
    2623                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2474                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    26242475                            } else { 
    26252476                                strcpy((char *) var.desc, vardesc); 
    26262477                            } 
    26272478                        } 
    2628                         if (error == ERROR_TM_NOERROR) { 
     2479                        if (error == ERROR_NOT_ERROR) { 
    26292480                            BUserRat *br = URat(bso); 
    26302481                            if (br == NULL) { 
    2631                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2482                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    26322483                            } else { 
    26332484                                TOLRATIO *ratio_value = (TOLRATIO *) malloc(sizeof (TOLRATIO)); 
    26342485                                if (ratio_value == NULL) { 
    2635                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2486                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    26362487                                } else { 
    26372488                                    BRational<BDat> rat = br->Contens(); 
     
    26412492                                    if (ratio_value->num.terms == NULL) { 
    26422493                                        ratio_value->num.terms = 0; 
    2643                                         error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2494                                        error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    26442495                                    } else { 
    26452496                                        ratio_value->num.nterm = nt; 
     
    26542505                                        if (ratio_value->den.terms == NULL) { 
    26552506                                            ratio_value->den.nterm = 0; 
    2656                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2507                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    26572508                                        } else { 
    26582509                                            ratio_value->den.nterm = nt; 
     
    26702521                    } 
    26712522                } 
    2672                 if (error == ERROR_TM_NOERROR) { 
     2523                if (error == ERROR_NOT_ERROR) { 
    26732524                    vars.vars[i] = var; 
    26742525                } else { 
     
    26782529        } 
    26792530    } 
    2680     if (error != ERROR_TM_NOERROR) { 
     2531    if (error != ERROR_NOT_ERROR) { 
    26812532        if (vars.vars != NULL) { 
    26822533            for (int i = 0; i < vars.nvars; ++i) { 
     
    26882539        vars.vars = NULL; 
    26892540    } 
    2690     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2691     pthread_mutex_lock(&errorTM_mutex); 
    2692     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2693     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2694     pthread_mutex_unlock(&errorTM_mutex); 
    26952541    return vars; 
    26962542} 
    26972543 
    26982544/*Obtiene todas las variables de tipo Code*/ 
    2699 TOLVARIABLES getCodeVariables(void) { 
    2700     int error = ERROR_TM_NOERROR; 
     2545TOLVARIABLES TOLMachine::getCodeVariables(void) { 
     2546    this->error = ERROR_NOT_ERROR; 
    27012547    TOLVARIABLES vars; 
    27022548    vars.nvars = 0; 
     
    27092555        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    27102556        if (vars.vars == NULL) { 
    2711             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2557            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27122558        } else { 
    27132559            vars.nvars = nv; 
     
    27202566                BSyntaxObject *bso = sv[i + 1]; 
    27212567                if (bso == NULL) { 
    2722                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2568                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    27232569                } else { 
    27242570                    const char *varname = bso->Name().String(); 
     
    27272573                        var.name = (char *) malloc(lenName + 1); 
    27282574                        if (var.name == NULL) { 
    2729                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2575                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27302576                        } else { 
    27312577                            strcpy((char *) var.name, varname); 
    27322578                        } 
    27332579                    } 
    2734                     if (error == ERROR_TM_NOERROR) { 
     2580                    if (error == ERROR_NOT_ERROR) { 
    27352581                        const char *vardesc = bso->Description().String(); 
    27362582                        int lenDesc = strlen(vardesc); 
     
    27382584                            var.desc = (char *) malloc(lenDesc + 1); 
    27392585                            if (var.desc == NULL) { 
    2740                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2586                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27412587                            } else { 
    27422588                                strcpy((char *) var.desc, vardesc); 
    27432589                            } 
    27442590                        } 
    2745                         if (error == ERROR_TM_NOERROR) { 
     2591                        if (error == ERROR_NOT_ERROR) { 
    27462592                            BUserCode *bc = UCode(bso); 
    27472593                            if (bc == NULL) { 
    2748                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2594                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    27492595                            } else { 
    27502596                                TOLCODE *code_value = (TOLCODE *) malloc(sizeof (TOLCODE)); 
    27512597                                if (code_value == NULL) { 
    2752                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2598                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27532599                                } else { 
    27542600 
     
    27582604                                        code_value->name = (char *) malloc(lenName + 1); 
    27592605                                        if (code_value->name == NULL) { 
    2760                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2606                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27612607                                        } else { 
    27622608                                            strcpy(code_value->name, cod.Name().String()); 
    27632609                                        } 
    27642610                                    } 
    2765                                     if (error == ERROR_TM_NOERROR) { 
     2611                                    if (error == ERROR_NOT_ERROR) { 
    27662612                                        int lenInfo = cod.Info().Length(); 
    27672613                                        if (lenInfo > 0) { 
    27682614                                            code_value->info = (char *) malloc(lenInfo + 1); 
    27692615                                            if (code_value->info == NULL) { 
    2770                                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2616                                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27712617                                            } else { 
    27722618                                                strcpy(code_value->info, cod.Info().String()); 
    27732619                                            } 
    27742620                                        } 
    2775                                         if (error == ERROR_TM_NOERROR) { 
     2621                                        if (error == ERROR_NOT_ERROR) { 
    27762622                                            int lenDump = cod.Dump().Length(); 
    27772623                                            if (lenDump > 0) { 
    27782624                                                code_value->dump = (char *) malloc(lenDump + 1); 
    27792625                                                if (code_value->dump == NULL) { 
    2780                                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2626                                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    27812627                                                } else { 
    27822628                                                    strcpy(code_value->dump, cod.Dump().String()); 
     
    27912637                    } 
    27922638                } 
    2793                 if (error == ERROR_TM_NOERROR) { 
     2639                if (error == ERROR_NOT_ERROR) { 
    27942640                    vars.vars[i] = var; 
    27952641                } else { 
     
    27992645        } 
    28002646    } 
    2801     if (error != ERROR_TM_NOERROR) { 
     2647    if (error != ERROR_NOT_ERROR) { 
    28022648        if (vars.vars != NULL) { 
    28032649            for (int i = 0; i < vars.nvars; ++i) { 
     
    28092655        vars.vars = NULL; 
    28102656    } 
    2811     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2812     pthread_mutex_lock(&errorTM_mutex); 
    2813     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2814     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2815     pthread_mutex_unlock(&errorTM_mutex); 
    28162657    return vars; 
    28172658} 
    28182659 
    28192660/*Obtiene todas las variables de tipo TimeSet*/ 
    2820 TOLVARIABLES getTimeSetVariables(void) { 
    2821     int error = ERROR_TM_NOERROR; 
     2661TOLVARIABLES TOLMachine::getTimeSetVariables(void) { 
     2662    this->error = ERROR_NOT_ERROR; 
    28222663    TOLVARIABLES vars; 
    28232664    vars.nvars = 0; 
     
    28302671        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    28312672        if (vars.vars == NULL) { 
    2832             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2673            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    28332674        } else { 
    28342675            vars.nvars = nv; 
     
    28412682                BSyntaxObject *bso = sv[i + 1]; 
    28422683                if (bso == NULL) { 
    2843                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2684                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    28442685                } else { 
    28452686                    const char *varname = bso->Name().String(); 
     
    28482689                        var.name = (char *) malloc(lenName + 1); 
    28492690                        if (var.name == NULL) { 
    2850                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2691                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    28512692                        } else { 
    28522693                            strcpy((char *) var.name, varname); 
    28532694                        } 
    28542695                    } 
    2855                     if (error == ERROR_TM_NOERROR) { 
     2696                    if (error == ERROR_NOT_ERROR) { 
    28562697                        const char *vardesc = bso->Description().String(); 
    28572698                        int lenDesc = strlen(vardesc); 
     
    28592700                            var.desc = (char *) malloc(lenDesc + 1); 
    28602701                            if (var.desc == NULL) { 
    2861                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2702                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    28622703                            } else { 
    28632704                                strcpy((char *) var.desc, vardesc); 
    28642705                            } 
    28652706                        } 
    2866                         if (error == ERROR_TM_NOERROR) { 
     2707                        if (error == ERROR_NOT_ERROR) { 
    28672708                            BUserTimeSet *bt = Tms(bso); 
    28682709                            if (bt == NULL) { 
    2869                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2710                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    28702711                            } else { 
    28712712                                TOLTIMESET *timeset_value = (TOLTIMESET *) malloc(sizeof (TOLTIMESET)); 
    28722713                                if (timeset_value == NULL) { 
    2873                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2714                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    28742715                                } else { 
    28752716                                    if (lenName > 0) { 
    28762717                                        timeset_value->name = (char *) malloc(lenName + 1); 
    28772718                                        if (timeset_value->name == NULL) { 
    2878                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2719                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    28792720                                        } else { 
    28802721                                            strcpy((char *) timeset_value->name, varname); 
     
    28892730                    } 
    28902731                } 
    2891                 if (error == ERROR_TM_NOERROR) { 
     2732                if (error == ERROR_NOT_ERROR) { 
    28922733                    vars.vars[i] = var; 
    28932734                } else { 
     
    28972738        } 
    28982739    } 
    2899     if (error != ERROR_TM_NOERROR) { 
     2740    if (error != ERROR_NOT_ERROR) { 
    29002741        if (vars.vars != NULL) { 
    29012742            for (int i = 0; i < vars.nvars; ++i) { 
     
    29072748        vars.vars = NULL; 
    29082749    } 
    2909     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    2910     pthread_mutex_lock(&errorTM_mutex); 
    2911     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    2912     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    2913     pthread_mutex_unlock(&errorTM_mutex); 
    29142750    return vars; 
    29152751} 
    29162752 
    29172753/*Obtiene todas las variables de tipo Serie*/ 
    2918 TOLVARIABLES getSerieVariables(void) { 
    2919     int error = ERROR_TM_NOERROR; 
     2754TOLVARIABLES TOLMachine::getSerieVariables(void) { 
     2755    this->error = ERROR_NOT_ERROR; 
    29202756    TOLVARIABLES vars; 
    29212757    vars.nvars = 0; 
     
    29282764        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    29292765        if (vars.vars == NULL) { 
    2930             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2766            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    29312767        } else { 
    29322768            vars.nvars = nv; 
     
    29392775                BSyntaxObject *bso = sv[i + 1]; 
    29402776                if (bso == NULL) { 
    2941                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2777                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    29422778                } else { 
    29432779                    const char *varname = bso->Name().String(); 
     
    29462782                        var.name = (char *) malloc(lenName + 1); 
    29472783                        if (var.name == NULL) { 
    2948                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2784                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    29492785                        } else { 
    29502786                            strcpy((char *) var.name, varname); 
    29512787                        } 
    29522788                    } 
    2953                     if (error == ERROR_TM_NOERROR) { 
     2789                    if (error == ERROR_NOT_ERROR) { 
    29542790                        const char *vardesc = bso->Description().String(); 
    29552791                        int lenDesc = strlen(vardesc); 
     
    29572793                            var.desc = (char *) malloc(lenDesc + 1); 
    29582794                            if (var.desc == NULL) { 
    2959                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2795                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    29602796                            } else { 
    29612797                                strcpy((char *) var.desc, vardesc); 
    29622798                            } 
    29632799                        } 
    2964                         if (error == ERROR_TM_NOERROR) { 
     2800                        if (error == ERROR_NOT_ERROR) { 
    29652801                            BUserTimeSerie *bs = Tsr(bso); 
    29662802                            if (bs == NULL) { 
    2967                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2803                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    29682804                            } else { 
    29692805                                TOLSERIE *serie_value = (TOLSERIE *) malloc(sizeof (TOLSERIE)); 
    29702806                                if (serie_value == NULL) { 
    2971                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2807                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    29722808                                } else { 
    29732809                                    if (lenName > 0) { 
    29742810                                        serie_value->name = (char *) malloc(lenName + 1); 
    29752811                                        if (serie_value->name == NULL) { 
    2976                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2812                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    29772813                                        } else { 
    29782814                                            strcpy((char *) serie_value->name, varname); 
     
    29872823                    } 
    29882824                } 
    2989                 if (error == ERROR_TM_NOERROR) { 
     2825                if (error == ERROR_NOT_ERROR) { 
    29902826                    vars.vars[i] = var; 
    29912827                } else { 
     
    29952831        } 
    29962832    } 
    2997     if (error != ERROR_TM_NOERROR) { 
     2833    if (error != ERROR_NOT_ERROR) { 
    29982834        if (vars.vars != NULL) { 
    29992835            for (int i = 0; i < vars.nvars; ++i) { 
     
    30052841        vars.vars = NULL; 
    30062842    } 
    3007     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    3008     pthread_mutex_lock(&errorTM_mutex); 
    3009     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    3010     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    3011     pthread_mutex_unlock(&errorTM_mutex); 
    30122843    return vars; 
    30132844} 
    30142845 
    30152846/*Obtiene todas las variables de tipo Set*/ 
    3016 TOLVARIABLES getSetVariables(void) { 
    3017     int error = ERROR_TM_NOERROR; 
     2847TOLVARIABLES TOLMachine::getSetVariables(void) { 
     2848    this->error = ERROR_NOT_ERROR; 
    30182849    TOLVARIABLES vars; 
    30192850    vars.nvars = 0; 
     
    30262857        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    30272858        if (vars.vars == NULL) { 
    3028             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2859            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    30292860        } else { 
    30302861            vars.nvars = nv; 
     
    30372868                BSyntaxObject *bso = sv[i + 1]; 
    30382869                if (bso == NULL) { 
    3039                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2870                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    30402871                } else { 
    30412872                    const char *varname = bso->Name().String(); 
     
    30442875                        var.name = (char *) malloc(lenName + 1); 
    30452876                        if (var.name == NULL) { 
    3046                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2877                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    30472878                        } else { 
    30482879                            strcpy((char *) var.name, varname); 
    30492880                        } 
    30502881                    } 
    3051                     if (error == ERROR_TM_NOERROR) { 
     2882                    if (error == ERROR_NOT_ERROR) { 
    30522883                        const char *vardesc = bso->Description().String(); 
    30532884                        int lenDesc = strlen(vardesc); 
     
    30552886                            var.desc = (char *) malloc(lenDesc + 1); 
    30562887                            if (var.desc == NULL) { 
    3057                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2888                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    30582889                            } else { 
    30592890                                strcpy((char *) var.desc, vardesc); 
    30602891                            } 
    30612892                        } 
    3062                         if (error == ERROR_TM_NOERROR) { 
     2893                        if (error == ERROR_NOT_ERROR) { 
    30632894                            BUserSet *bs = USet(bso); 
    30642895                            if (bs == NULL) { 
    3065                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2896                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    30662897                            } else { 
    30672898                                TOLSET *set_value = (TOLSET *) malloc(sizeof (TOLSET)); 
    30682899                                if (set_value == NULL) { 
    3069                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2900                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    30702901                                } else { 
    30712902                                    if (lenName > 0) { 
    30722903                                        set_value->name = (char *) malloc(lenName + 1); 
    30732904                                        if (set_value->name == NULL) { 
    3074                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2905                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    30752906                                        } else { 
    30762907                                            strcpy((char *) set_value->name, varname); 
     
    30852916                    } 
    30862917                } 
    3087                 if (error == ERROR_TM_NOERROR) { 
     2918                if (error == ERROR_NOT_ERROR) { 
    30882919                    vars.vars[i] = var; 
    30892920                } else { 
     
    30932924        } 
    30942925    } 
    3095     if (error != ERROR_TM_NOERROR) { 
     2926    if (error != ERROR_NOT_ERROR) { 
    30962927        if (vars.vars != NULL) { 
    30972928            for (int i = 0; i < vars.nvars; ++i) { 
     
    31032934        vars.vars = NULL; 
    31042935    } 
    3105     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    3106     pthread_mutex_lock(&errorTM_mutex); 
    3107     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    3108     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    3109     pthread_mutex_unlock(&errorTM_mutex); 
    31102936    return vars; 
    31112937} 
    31122938 
    3113 /*Obtiene todas las variables de tipo Set*/ 
    3114 TOLVARIABLES getNameBlockVariables(void) { 
    3115     int error = ERROR_TM_NOERROR; 
     2939/*Obtiene todas las variables de tipo NameBlock*/ 
     2940TOLVARIABLES TOLMachine::getNameBlockVariables(void) { 
     2941    this->error = ERROR_NOT_ERROR; 
    31162942    TOLVARIABLES vars; 
    31172943    vars.nvars = 0; 
     
    31242950        vars.vars = (TOLVARIABLE *) malloc(nv * sizeof (TOLVARIABLE)); 
    31252951        if (vars.vars == NULL) { 
    3126             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2952            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    31272953        } else { 
    31282954            vars.nvars = nv; 
     
    31352961                BSyntaxObject *bso = sv[i + 1]; 
    31362962                if (bso == NULL) { 
    3137                     error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2963                    error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    31382964                } else { 
    31392965                    const char *varname = bso->Name().String(); 
     
    31422968                        var.name = (char *) malloc(lenName + 1); 
    31432969                        if (var.name == NULL) { 
    3144                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2970                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    31452971                        } else { 
    31462972                            strcpy((char *) var.name, varname); 
    31472973                        } 
    31482974                    } 
    3149                     if (error == ERROR_TM_NOERROR) { 
     2975                    if (error == ERROR_NOT_ERROR) { 
    31502976                        const char *vardesc = bso->Description().String(); 
    31512977                        int lenDesc = strlen(vardesc); 
     
    31532979                            var.desc = (char *) malloc(lenDesc + 1); 
    31542980                            if (var.desc == NULL) { 
    3155                                 error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2981                                error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    31562982                            } else { 
    31572983                                strcpy((char *) var.desc, vardesc); 
    31582984                            } 
    31592985                        } 
    3160                         if (error == ERROR_TM_NOERROR) { 
     2986                        if (error == ERROR_NOT_ERROR) { 
    31612987                            BUserNameBlock *bn = UNameBlock(bso); 
    31622988                            if (bn == NULL) { 
    3163                                 error = ERROR_TM_UNKNOWN; /* Error interno desconocido */ 
     2989                                error = ERROR_UNKNOWN; /* Error interno desconocido */ 
    31642990                            } else { 
    31652991                                TOLNAMEBLOCK *nameblock_value = (TOLNAMEBLOCK *) malloc(sizeof (TOLNAMEBLOCK)); 
    31662992                                if (nameblock_value == NULL) { 
    3167                                     error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2993                                    error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    31682994                                } else { 
    31692995                                    if (lenName > 0) { 
    31702996                                        nameblock_value->name = (char *) malloc(lenName + 1); 
    31712997                                        if (nameblock_value->name == NULL) { 
    3172                                             error = ERRORTM_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
     2998                                            error = ERROR_NOT_ENOUGH_MEMORY; /* No hay suficiente memoria */ 
    31732999                                        } else { 
    31743000                                            strcpy((char *) nameblock_value->name, varname); 
     
    31833009                    } 
    31843010                } 
    3185                 if (error == ERROR_TM_NOERROR) { 
     3011                if (error == ERROR_NOT_ERROR) { 
    31863012                    vars.vars[i] = var; 
    31873013                } else { 
     
    31913017        } 
    31923018    } 
    3193     if (error != ERROR_TM_NOERROR) { 
     3019    if (error != ERROR_NOT_ERROR) { 
    31943020        if (vars.vars != NULL) { 
    31953021            for (int i = 0; i < vars.nvars; ++i) { 
     
    32013027        vars.vars = NULL; 
    32023028    } 
    3203     /* Se activa el semáforo para que desde otro hilo no se acceda a errorTM en este momento*/ 
    3204     pthread_mutex_lock(&errorTM_mutex); 
    3205     errorTM = error; /* Código del error ocurrido (si lo hubo) */ 
    3206     /* Se desactiva el semáforo para que otro hilo pueda acceder a errorTM a partir de este momento*/ 
    3207     pthread_mutex_unlock(&errorTM_mutex); 
    32083029    return vars; 
    32093030} 
    32103031 
    32113032/* Recibe un comando desde un socket */ 
    3212 short readCommand(int sock) { 
    3213     return readShort(sock); 
     3033short TOLMachine::readCommand(int sock) { 
     3034    short s= -1; 
     3035    TOLGridStream tgs(this->ssService); 
     3036    this->error= tgs.getError(); 
     3037    if (this->error==ERROR_NOT_ERROR) { 
     3038        s= tgs.readShort(); 
     3039        this->error= tgs.getError(); 
     3040    } 
     3041    return s; 
    32143042} 
    32153043 
     
    32363064    pthread_mutex_unlock(&server_info_mutex); 
    32373065    socklen_t clilen = sizeof (sinfo->service_addr); 
    3238     int etm = ERROR_TM_NOERROR; 
     3066    int etm = ERROR_NOT_ERROR; 
    32393067    /* Esperando por una conexión */ 
    32403068    client_socket = accept(cs, (struct sockaddr *) & sinfo->service_addr, &clilen); 
     
    32613089                /*Se chequea si el id enviado por el cliente corresponde al asignado a esta máquina*/ 
    32623090                if (ident_tolmachine != ident_tolmachine_cliente) { 
    3263                     etm = ERRORTM_INVALID_ID; 
     3091                    etm = ERROR_TM_INVALID_ID; 
    32643092                } 
    32653093                writeShort(client_socket, etm); 
     
    32703098                } else { 
    32713099                    /*Se chequea si el id enviado por el cliente es erróneo*/ 
    3272                     if (etm == ERRORTM_INVALID_ID) { 
     3100                    if (etm == ERROR_TM_INVALID_ID) { 
    32733101                        /*Si el id enviado por el cliente es erróneo*/ 
    32743102                        printf("\nERROR16: INVALID TOLMACHINE ID\n"); 
     
    34133241                                                status = DEAD; 
    34143242                                            } else { 
    3415                                                 if (etm == ERROR_TM_NOERROR) { 
     3243                                                if (etm == ERROR_NOT_ERROR) { 
    34163244                                                    writeVariable(client_socket, var); 
    34173245                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    34763304                                                status = DEAD; 
    34773305                                            } else { 
    3478                                                 if (etm == ERROR_TM_NOERROR) { 
     3306                                                if (etm == ERROR_NOT_ERROR) { 
    34793307                                                    writeValue(client_socket, value); 
    34803308                                                    /*Se chequea si hubo error de comunicación*/ 
     
    35453373                                                    status = DEAD; 
    35463374                                                } else { 
    3547                                                     if (etm == ERROR_TM_NOERROR) { 
     3375                                                    if (etm == ERROR_NOT_ERROR) { 
    35483376                                                        writeDate(client_socket, ndate); 
    35493377                                                        if (getError() != ERRORCOM_NOTERROR) { 
     
    36133441                                                    status = DEAD; 
    36143442                                                } else { 
    3615                                                     if (etm == ERROR_TM_NOERROR) { 
     3443                                                    if (etm == ERROR_NOT_ERROR) { 
    36163444                                                        writeDate(client_socket, ndate); 
    36173445                                                        if (getError() != ERRORCOM_NOTERROR) { 
     
    36873515                                                        status = DEAD; 
    36883516                                                    } else { 
    3689                                                         if (etm == ERROR_TM_NOERROR) { 
     3517                                                        if (etm == ERROR_NOT_ERROR) { 
    36903518                                                            writeDates(client_socket, dates); 
    36913519                                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    37573585                                                    status = DEAD; 
    37583586                                                } else { 
    3759                                                     if (etm == ERROR_TM_NOERROR) { 
     3587                                                    if (etm == ERROR_NOT_ERROR) { 
    37603588                                                        writeReal(client_socket, real_value); 
    37613589                                                        if (getError() != ERRORCOM_NOTERROR) { 
     
    38313659                                                        status = DEAD; 
    38323660                                                    } else { 
    3833                                                         if (etm == ERROR_TM_NOERROR) { 
     3661                                                        if (etm == ERROR_NOT_ERROR) { 
    38343662                                                            writeItemsSerie(client_socket, items); 
    38353663                                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    38943722                                                status = DEAD; 
    38953723                                            } else { 
    3896                                                 if (etm == ERROR_TM_NOERROR) { 
     3724                                                if (etm == ERROR_NOT_ERROR) { 
    38973725                                                    writeDate(client_socket, fdate); 
    38983726                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    39553783                                                status = DEAD; 
    39563784                                            } else { 
    3957                                                 if (etm == ERROR_TM_NOERROR) { 
     3785                                                if (etm == ERROR_NOT_ERROR) { 
    39583786                                                    writeDate(client_socket, fdate); 
    39593787                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    40163844                                                status = DEAD; 
    40173845                                            } else { 
    4018                                                 if (etm == ERROR_TM_NOERROR) { 
     3846                                                if (etm == ERROR_NOT_ERROR) { 
    40193847                                                    writeInt(client_socket, size); 
    40203848                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    40843912                                                    status = DEAD; 
    40853913                                                } else { 
    4086                                                     if (etm == ERROR_TM_NOERROR) { 
     3914                                                    if (etm == ERROR_NOT_ERROR) { 
    40873915                                                        writeValue(client_socket, value); 
    40883916                                                        if (getError() != ERRORCOM_NOTERROR) { 
     
    41473975                                                status = DEAD; 
    41483976                                            } else { 
    4149                                                 if (etm == ERROR_TM_NOERROR) { 
     3977                                                if (etm == ERROR_NOT_ERROR) { 
    41503978                                                    writeValues(client_socket, values); 
    41513979                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    41824010                                        pthread_mutex_unlock(&server_info_mutex); 
    41834011                                        writeShort(client_socket, etm); 
    4184                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4012                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    41854013                                            writeVariables(client_socket, vars); 
    41864014                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    42154043                                        pthread_mutex_unlock(&server_info_mutex); 
    42164044                                        writeShort(client_socket, etm); 
    4217                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4045                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    42184046                                            writeVariables(client_socket, vars); 
    42194047                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    42484076                                        pthread_mutex_unlock(&server_info_mutex); 
    42494077                                        writeShort(client_socket, etm); 
    4250                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4078                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    42514079                                            writeVariables(client_socket, vars); 
    42524080                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    42814109                                        pthread_mutex_unlock(&server_info_mutex); 
    42824110                                        writeShort(client_socket, etm); 
    4283                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4111                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    42844112                                            writeVariables(client_socket, vars); 
    42854113                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    43144142                                        pthread_mutex_unlock(&server_info_mutex); 
    43154143                                        writeShort(client_socket, etm); 
    4316                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4144                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    43174145                                            writeVariables(client_socket, vars); 
    43184146                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    43474175                                        pthread_mutex_unlock(&server_info_mutex); 
    43484176                                        writeShort(client_socket, etm); 
    4349                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4177                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    43504178                                            writeVariables(client_socket, vars); 
    43514179                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    43804208                                        pthread_mutex_unlock(&server_info_mutex); 
    43814209                                        writeShort(client_socket, etm); 
    4382                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4210                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    43834211                                            writeVariables(client_socket, vars); 
    43844212                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    44134241                                        pthread_mutex_unlock(&server_info_mutex); 
    44144242                                        writeShort(client_socket, etm); 
    4415                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4243                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    44164244                                            writeVariables(client_socket, vars); 
    44174245                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    44464274                                        pthread_mutex_unlock(&server_info_mutex); 
    44474275                                        writeShort(client_socket, etm); 
    4448                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4276                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    44494277                                            writeVariables(client_socket, vars); 
    44504278                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    44794307                                        pthread_mutex_unlock(&server_info_mutex); 
    44804308                                        writeShort(client_socket, etm); 
    4481                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4309                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    44824310                                            writeVariables(client_socket, vars); 
    44834311                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    45124340                                        pthread_mutex_unlock(&server_info_mutex); 
    45134341                                        writeShort(client_socket, etm); 
    4514                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4342                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    45154343                                            writeVariables(client_socket, vars); 
    45164344                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    45454373                                        pthread_mutex_unlock(&server_info_mutex); 
    45464374                                        writeShort(client_socket, etm); 
    4547                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4375                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    45484376                                            writeVariables(client_socket, vars); 
    45494377                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    45784406                                        pthread_mutex_unlock(&server_info_mutex); 
    45794407                                        writeShort(client_socket, etm); 
    4580                                         if (etm == ERROR_TM_NOERROR && getError() == ERRORCOM_NOTERROR) { 
     4408                                        if (etm == ERROR_NOT_ERROR && getError() == ERRORCOM_NOTERROR) { 
    45814409                                            writeVariables(client_socket, vars); 
    45824410                                            if (getError() != ERRORCOM_NOTERROR) { 
     
    45984426                                        BText tgmi("<T> TOLMachine: INICIO del comando 'COMMAND_TM_EXECUTEESTIMATION'</T> "); 
    45994427                                        saveMessage(tgmi); 
    4600                                         int etm = ERROR_TM_NOERROR; 
     4428                                        int etm = ERROR_NOT_ERROR; 
    46014429                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
    46024430                                        pthread_mutex_lock(&server_info_mutex); 
     
    46134441                                            char *oza = (char *) malloc(32767); 
    46144442                                            if (oza == NULL) { 
    4615                                                 etm = ERRORTM_NOT_ENOUGH_MEMORY; /* No se puedo asignar memoria */ 
     4443                                                etm = ERROR_NOT_ENOUGH_MEMORY; /* No se puedo asignar memoria */ 
    46164444                                            } else { 
    46174445                                                char *tmp_name = tmpnam(NULL); 
    46184446                                                if (tmp_name == NULL) { 
    4619                                                     etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4447                                                    etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    46204448                                                } else { 
    46214449                                                    char foza_name[256]; 
     
    46234451                                                    FILE *foza = fopen(foza_name, "w"); 
    46244452                                                    if (foza == NULL) { 
    4625                                                         etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4453                                                        etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    46264454                                                    } else { 
    46274455                                                        while (l > 0) { 
     
    46474475                                                                int w = fwrite(oza, t, 1, foza); 
    46484476                                                                if (w != 1) { 
    4649                                                                     etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4477                                                                    etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    46504478                                                                    break; 
    46514479                                                                } else { 
     
    46554483                                                        } 
    46564484                                                        fclose(foza); 
    4657                                                         if (etm == ERROR_TM_NOERROR && status != DEAD) { 
     4485                                                        if (etm == ERROR_NOT_ERROR && status != DEAD) { 
    46584486                                                            char tol_code0[] = "Real TolPackage::Client::AddRepository(\"http://packages.localbayes.es/BayesPrivateTolPackages/repository.php\");#Require TclCore;#Require MMS;"; 
    46594487                                                            const char *tol_code1 = "MMS::@Estimation estimation = MMS::Container::LoadFile(\""; 
     
    46634491                                                            char *tol_code = (char *) malloc(code_len); 
    46644492                                                            if (tol_code == NULL) { 
    4665                                                                 etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4493                                                                etm = ERROR_NOT_ENOUGH_MEMORY; 
    46664494                                                            } else { 
    46674495                                                                /*Enviar el código de inicio correcto de estimacion*/ 
     
    47014529                                                                    foza = fopen(foza_name, "r"); 
    47024530                                                                    if (foza == NULL) { 
    4703                                                                         etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4531                                                                        etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    47044532                                                                    } else { 
    47054533                                                                        /*Enviar el código de fin de ejecución, seguido del número de errores*/ 
     
    47324560                                                                                        if (c == 0) { 
    47334561                                                                                            if (!feof(foza)) { 
    4734                                                                                                 etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4562                                                                                                etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    47354563                                                                                            } 
    47364564                                                                                            break; 
     
    47544582                                                            } 
    47554583                                                        } 
    4756                                                         if (etm != ERROR_TM_NOERROR) { 
     4584                                                        if (etm != ERROR_NOT_ERROR) { 
    47574585                                                            writeShort(client_socket, etm); 
    47584586                                                            /*Se chequea si hubo error de comunicación*/ 
     
    48194647                                                status = DEAD; 
    48204648                                            } else { 
    4821                                                 if (etm == ERROR_TM_NOERROR) { 
     4649                                                if (etm == ERROR_NOT_ERROR) { 
    48224650                                                    writeInt(client_socket, size); 
    48234651                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    48804708                                                status = DEAD; 
    48814709                                            } else { 
    4882                                                 if (etm == ERROR_TM_NOERROR) { 
     4710                                                if (etm == ERROR_NOT_ERROR) { 
    48834711                                                    writeItemsSerie(client_socket, items); 
    48844712                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    49414769                                                status = DEAD; 
    49424770                                            } else { 
    4943                                                 if (etm == ERROR_TM_NOERROR) { 
     4771                                                if (etm == ERROR_NOT_ERROR) { 
    49444772                                                    writeString(client_socket, expr); 
    49454773                                                    free(expr); 
     
    49634791                                        BText tgmi("<T> TOLMachine: INICIO del comando 'COMMAND_TM_LOADESTIMATION'</T> "); 
    49644792                                        saveMessage(tgmi); 
    4965                                         int etm = ERROR_TM_NOERROR; 
     4793                                        int etm = ERROR_NOT_ERROR; 
    49664794                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
    49674795                                        pthread_mutex_lock(&server_info_mutex); 
     
    49784806                                        } else { 
    49794807                                            if (ec == ERRORCOM_NOT_ENOUGH_MEMORY) { 
    4980                                                 etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4808                                                etm = ERROR_NOT_ENOUGH_MEMORY; 
    49814809                                            } 
    49824810                                            /*Enviar el código de error/ERRORTM_NOTERROR en la lectura*/ 
     
    49874815                                                status = DEAD; 
    49884816                                            } else { 
    4989                                                 if (etm == ERROR_TM_NOERROR) { 
     4817                                                if (etm == ERROR_NOT_ERROR) { 
    49904818                                                    int l = readInt(client_socket); 
    49914819                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    50034831                                                            switch (ec) { 
    50044832                                                                case ERRORCOM_NOT_ENOUGH_MEMORY: 
    5005                                                                     etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4833                                                                    etm = ERROR_NOT_ENOUGH_MEMORY; 
    50064834                                                                    break; 
    50074835                                                                case ERRORCOM_INTERNAL_FILE_ERROR: 
    5008                                                                     etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4836                                                                    etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    50094837                                                                    break; 
    50104838                                                            } 
    5011                                                             if (etm != ERROR_TM_NOERROR) { 
     4839                                                            if (etm != ERROR_NOT_ERROR) { 
    50124840                                                                /*Enviar el código de error/ERRORTM_NOTERROR de lectura del .oza*/ 
    50134841                                                                writeShort(client_socket, etm); 
     
    50254853                                                                char *tol_code = (char *) malloc(code_len); 
    50264854                                                                if (tol_code == NULL) { 
    5027                                                                     etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4855                                                                    etm = ERROR_NOT_ENOUGH_MEMORY; 
    50284856                                                                } 
    50294857                                                                /*Enviar el código de inicio correcto de estimacion*/ 
     
    50344862                                                                    status = DEAD; 
    50354863                                                                } else { 
    5036                                                                     if (etm == ERROR_TM_NOERROR) { 
     4864                                                                    if (etm == ERROR_NOT_ERROR) { 
    50374865                                                                        strcat(strcat(strcat(strcat(strcpy(tol_code, tol_code1), varname), tol_code2), foza_name), tol_code3); 
    50384866                                                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
     
    50974925                                        BText tgmi("<T> TOLMachine: INICIO del comando 'COMMAND_TM_LOADFORECAST'</T> "); 
    50984926                                        saveMessage(tgmi); 
    5099                                         int etm = ERROR_TM_NOERROR; 
     4927                                        int etm = ERROR_NOT_ERROR; 
    51004928                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
    51014929                                        pthread_mutex_lock(&server_info_mutex); 
     
    51124940                                        } else { 
    51134941                                            if (ec == ERRORCOM_NOT_ENOUGH_MEMORY) { 
    5114                                                 etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4942                                                etm = ERROR_NOT_ENOUGH_MEMORY; 
    51154943                                            } 
    51164944                                            /*Enviar el código de error/ERRORTM_NOTERROR en la lectura*/ 
     
    51214949                                                status = DEAD; 
    51224950                                            } else { 
    5123                                                 if (etm == ERROR_TM_NOERROR) { 
     4951                                                if (etm == ERROR_NOT_ERROR) { 
    51244952                                                    int l = readInt(client_socket); 
    51254953                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    51374965                                                            switch (ec) { 
    51384966                                                                case ERRORCOM_NOT_ENOUGH_MEMORY: 
    5139                                                                     etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4967                                                                    etm = ERROR_NOT_ENOUGH_MEMORY; 
    51404968                                                                    break; 
    51414969                                                                case ERRORCOM_INTERNAL_FILE_ERROR: 
    5142                                                                     etm = ERRORTM_INTERNAL_FILE_ERROR; 
     4970                                                                    etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    51434971                                                                    break; 
    51444972                                                            } 
    5145                                                             if (etm != ERROR_TM_NOERROR) { 
     4973                                                            if (etm != ERROR_NOT_ERROR) { 
    51464974                                                                /*Enviar el código de error/ERRORTM_NOTERROR de lectura del .oza*/ 
    51474975                                                                writeShort(client_socket, etm); 
     
    51594987                                                                char *tol_code = (char *) malloc(code_len); 
    51604988                                                                if (tol_code == NULL) { 
    5161                                                                     etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     4989                                                                    etm = ERROR_NOT_ENOUGH_MEMORY; 
    51624990                                                                } 
    51634991                                                                /*Enviar el código de inicio correcto de estimacion*/ 
     
    51684996                                                                    status = DEAD; 
    51694997                                                                } else { 
    5170                                                                     if (etm == ERROR_TM_NOERROR) { 
     4998                                                                    if (etm == ERROR_NOT_ERROR) { 
    51714999                                                                        strcat(strcat(strcat(strcat(strcpy(tol_code, tol_code1), varname), tol_code2), foza_name), tol_code3); 
    51725000                                                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
     
    52375065                                        /*Se desactiva el semáforo para que el otro hilo pueda acceder a server_info a partir de este momento*/ 
    52385066                                        pthread_mutex_unlock(&server_info_mutex); 
    5239                                         int nm = messagesTMP.size(); 
     5067                                        int nm = messagesP.size(); 
    52405068                                        /*Enviar el número de mensajes almacenados en el log permanente*/ 
    52415069                                        writeInt(client_socket, nm); 
     
    52465074                                        } else { 
    52475075                                            for (int i = 0; i < nm; i++) { 
    5248                                                 char *message = messagesTMP[i]; 
     5076                                                char *message = messagesP[i]; 
    52495077                                                writeString(client_socket, message); 
    52505078                                                if (getError() != ERRORCOM_NOTERROR) { 
     
    52675095                                        BText tgmi("<T> TOLMachine: INICIO del comando 'COMMAND_TM_LOADOPTIMIZATION'</T> "); 
    52685096                                        saveMessage(tgmi); 
    5269                                         int etm = ERROR_TM_NOERROR; 
     5097                                        int etm = ERROR_NOT_ERROR; 
    52705098                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
    52715099                                        pthread_mutex_lock(&server_info_mutex); 
     
    52825110                                        } else { 
    52835111                                            if (ec == ERRORCOM_NOT_ENOUGH_MEMORY) { 
    5284                                                 etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     5112                                                etm = ERROR_NOT_ENOUGH_MEMORY; 
    52855113                                            } 
    52865114                                            /*Enviar el código de error/ERRORTM_NOTERROR en la lectura*/ 
     
    52915119                                                status = DEAD; 
    52925120                                            } else { 
    5293                                                 if (etm == ERROR_TM_NOERROR) { 
     5121                                                if (etm == ERROR_NOT_ERROR) { 
    52945122                                                    int l = readInt(client_socket); 
    52955123                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    53075135                                                            switch (ec) { 
    53085136                                                                case ERRORCOM_NOT_ENOUGH_MEMORY: 
    5309                                                                     etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     5137                                                                    etm = ERROR_NOT_ENOUGH_MEMORY; 
    53105138                                                                    break; 
    53115139                                                                case ERRORCOM_INTERNAL_FILE_ERROR: 
    5312                                                                     etm = ERRORTM_INTERNAL_FILE_ERROR; 
     5140                                                                    etm = ERROR_TM_INTERNAL_FILE_ERROR; 
    53135141                                                                    break; 
    53145142                                                            } 
    5315                                                             if (etm != ERROR_TM_NOERROR) { 
     5143                                                            if (etm != ERROR_NOT_ERROR) { 
    53165144                                                                /*Enviar el código de error/ERRORTM_NOTERROR de lectura del .oza*/ 
    53175145                                                                writeShort(client_socket, etm); 
     
    53295157                                                                char *tol_code = (char *) malloc(code_len); 
    53305158                                                                if (tol_code == NULL) { 
    5331                                                                     etm = ERRORTM_NOT_ENOUGH_MEMORY; 
     5159                                                                    etm = ERROR_NOT_ENOUGH_MEMORY; 
    53325160                                                                } 
    53335161                                                                /*Enviar el código de inicio correcto de estimacion*/ 
     
    53385166                                                                    status = DEAD; 
    53395167                                                                } else { 
    5340                                                                     if (etm == ERROR_TM_NOERROR) { 
     5168                                                                    if (etm == ERROR_NOT_ERROR) { 
    53415169                                                                        strcat(strcat(strcat(strcat(strcpy(tol_code, tol_code1), varname), tol_code2), foza_name), tol_code3); 
    53425170                                                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
     
    54005228                                        BText tgmi("<T> TOLMachine: INICIO del comando 'COMMAND_TM_LOADOZA'</T> "); 
    54015229                                        saveMessage(tgmi); 
    5402                                         int etm= ERROR_TM_NOERROR; 
     5230                                        int etm= ERROR_NOT_ERROR; 
    54035231                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
    54045232                                        pthread_mutex_lock(&server_info_mutex); 
     
    54155243                                        } else { 
    54165244                                            if (ec== ERRORCOM_NOT_ENOUGH_MEMORY) { 
    5417                                                 etm= ERRORTM_NOT_ENOUGH_MEMORY; 
     5245                                                etm= ERROR_NOT_ENOUGH_MEMORY; 
    54185246                                            } 
    54195247                                            /*Enviar el código de error/ERRORTM_NOTERROR en la lectura*/ 
     
    54245252                                                status = DEAD; 
    54255253                                            } else { 
    5426                                                 if (etm==ERROR_TM_NOERROR) { 
     5254                                                if (etm==ERROR_NOT_ERROR) { 
    54275255                                                    int l= readInt(client_socket); 
    54285256                                                    if (getError() != ERRORCOM_NOTERROR) { 
     
    54405268                                                            switch (ec) { 
    54415269                                                                case ERRORCOM_NOT_ENOUGH_MEMORY: 
    5442                                                                     etm= ERRORTM_NOT_ENOUGH_MEMORY; 
     5270                                                                    etm= ERROR_NOT_ENOUGH_MEMORY; 
    54435271                                                                    break; 
    54445272                                                                case ERRORCOM_INTERNAL_FILE_ERROR: 
    5445                                                                     etm= ERRORTM_INTERNAL_FILE_ERROR; 
     5273                                                                    etm= ERROR_TM_INTERNAL_FILE_ERROR; 
    54465274                                                                    break; 
    54475275                                                            } 
    5448                                                             if (etm!=ERROR_TM_NOERROR) { 
     5276                                                            if (etm!=ERROR_NOT_ERROR) { 
    54495277                                                                /*Enviar el código de error/ERRORTM_NOTERROR de lectura del .oza*/ 
    54505278                                                                writeShort(client_socket, etm); 
     
    54625290                                                                char *tol_code= (char *)malloc(code_len); 
    54635291                                                                if (tol_code==NULL) { 
    5464                                                                     etm= ERRORTM_NOT_ENOUGH_MEMORY; 
     5292                                                                    etm= ERROR_NOT_ENOUGH_MEMORY; 
    54655293                                                                } 
    54665294                                                                /*Enviar el código de inicio correcto de estimacion*/ 
     
    54715299                                                                    status = DEAD; 
    54725300                                                                } else { 
    5473                                                                     if (etm==ERROR_TM_NOERROR) { 
     5301                                                                    if (etm==ERROR_NOT_ERROR) { 
    54745302                                                                        strcat(strcat(strcat(strcat(strcpy(tol_code, tol_code1), varname), tol_code2), foza_name), tol_code3); 
    54755303                                                                        /* Se activa el semáforo para que el otro hilo no acceda a server_info en este momento*/ 
     
    56165444                        double ident_control= readReal(control_socket); 
    56175445                        if (id_control!=id || ident_control!=ident) { 
    5618                             writeShort(control_socket, ERRORTM_INVALID_ID); 
     5446                            writeShort(control_socket, ERROR_TM_INVALID_ID); 
    56195447                        } else { 
    5620                             writeShort(control_socket, ERROR_TM_NOERROR); 
     5448                            writeShort(control_socket, ERROR_NOT_ERROR); 
    56215449                            char endControl = 'N'; 
    56225450                            while (status != DEAD && endControl == 'N') { 
     
    56255453                                switch (controlCommand) { 
    56265454                                    case COMMAND_TM_GETLOG: { 
    5627                                         writeShort(control_socket, ERROR_TM_NOERROR); 
    5628                                         int nm = messagesTMP.size(); 
     5455                                        writeShort(control_socket, ERROR_NOT_ERROR); 
     5456                                        int nm = messagesP.size(); 
    56295457                                        /*Enviar el número de mensajes almacenados en el log permanente*/ 
    56305458                                        writeInt(control_socket, nm); 
     
    56355463                                        } else { 
    56365464                                            for (int i = 0; i < nm; i++) { 
    5637                                                 char *message = messagesTMP[i]; 
     5465                                                char *message = messagesP[i]; 
    56385466                                                writeString(control_socket, message); 
    56395467                                                if (getError() != ERRORCOM_NOTERROR) { 
     
    56485476                                    } 
    56495477                                    default: { 
    5650                                         writeShort(control_socket, ERRORTM_INVALID_COMMAND); 
     5478                                        writeShort(control_socket, ERROR_TM_INVALID_COMMAND); 
    56515479                                        break; 
    56525480                                    } 
     
    57465574    } 
    57475575    printf("\nParámetros-> control_port: %ld, service_port: %ld, tolgridserver_port: %ld, confirm_port: %ld\n", control_port, service_port, tolmachine_server_port, confirm_port); 
    5748     tma.ident = ident; 
     5576    curTMA.ident = ident; 
    57495577    /* Se crea el socket para la escucha del cliente */ 
    5750     tma.service_socket = socket(AF_INET, SOCK_STREAM, 0); 
    5751     if (tma.service_socket < 0) { 
     5578    curTMA.service_socket = socket(AF_INET, SOCK_STREAM, 0); 
     5579    if (curTMA.service_socket < 0) { 
    57525580        printf("\nERROR03: CLIENT SERVER PORT NOT OPENED\n"); 
    57535581        exit(EXIT_FAILURE); 
    57545582    } 
    57555583    /* Se rellenan los datos de la dirección de escucha al cliente */ 
    5756     bzero((char *) & tma.service_addr, sizeof (tma.service_addr)); 
    5757     tma.service_addr.sin_family = AF_INET; 
    5758     tma.service_addr.sin_addr.s_addr = INADDR_ANY; 
    5759     tma.service_addr.sin_port = htons(service_port); 
    5760     if (bind(tma.service_socket, (struct sockaddr *) & tma.service_addr, sizeof (tma.service_addr)) < 0) { 
     5584    bzero((char *) & curTMA.service_addr, sizeof (curTMA.service_addr)); 
     5585    curTMA.service_addr.sin_family = AF_INET; 
     5586    curTMA.service_addr.sin_addr.s_addr = INADDR_ANY; 
     5587    curTMA.service_addr.sin_port = htons(service_port); 
     5588    if (bind(curTMA.service_socket, (struct sockaddr *) & curTMA.service_addr, sizeof (curTMA.service_addr)) < 0) { 
    57615589        printf("\nERROR04: CLIENT SERVER PORT IN USE\n"); 
    57625590        exit(EXIT_FAILURE); 
    57635591    } 
    5764     if (listen(tma.service_socket, 5)) { 
     5592    if (listen(curTMA.service_socket, 5)) { 
    57655593        printf("\nERROR04: CLIENT SERVER PORT IN USE\n"); 
    57665594        exit(EXIT_FAILURE); 
    57675595    } 
    57685596 
    5769     tma.control_socket = socket(AF_INET, SOCK_STREAM, 0); 
    5770     if (tma.control_socket < 0) { 
     5597    curTMA.control_socket = socket(AF_INET, SOCK_STREAM, 0); 
     5598    if (curTMA.control_socket < 0) { 
    57715599        printf("\nERROR05: CONTROL SERVER PORT NOT OPENED\n"); 
    57725600        exit(EXIT_FAILURE); 
    57735601    } 
    5774     bzero((char *) & tma.control_addr, sizeof (tma.control_addr)); 
    5775     tma.control_addr.sin_family = AF_INET; 
    5776     tma.control_addr.sin_addr.s_addr = INADDR_ANY; 
    5777     tma.control_addr.sin_port = htons(control_port); 
    5778     if (bind(tma.control_socket, (struct sockaddr *) & tma.control_addr, sizeof (tma.control_addr)) < 0) { 
     5602    bzero((char *) & curTMA.control_addr, sizeof (curTMA.control_addr)); 
     5603    curTMA.control_addr.sin_family = AF_INET; 
     5604    curTMA.control_addr.sin_addr.s_addr = INADDR_ANY; 
     5605    curTMA.control_addr.sin_port = htons(control_port); 
     5606    if (bind(curTMA.control_socket, (struct sockaddr *) & curTMA.control_addr, sizeof (curTMA.control_addr)) < 0) { 
    57795607        printf("\nERROR07: CONTROL SERVER PORT IN USE\n"); 
    57805608        exit(EXIT_FAILURE); 
    57815609    } 
    5782     if (listen(tma.control_socket, 5)) { 
     5610    if (listen(curTMA.control_socket, 5)) { 
    57835611        printf("\nERROR07: CONTROL SERVER PORT IN USE\n"); 
    57845612        exit(EXIT_FAILURE); 
     
    57905618        exit(EXIT_FAILURE); 
    57915619    } 
    5792     bzero((char *) & tma.tolserver_addr, sizeof (tma.tolserver_addr)); 
    5793     tma.tolserver_addr.sin_family = AF_INET; 
    5794     bcopy((char *) tolgridserver_host->h_addr, (char *) & tma.tolserver_addr.sin_addr.s_addr, tolgridserver_host->h_length); 
    5795     tma.tolserver_addr.sin_port = htons(tolmachine_server_port); 
    5796     tma.status = CREATED; 
    5797     tma.send_log = 'N'; 
     5620    bzero((char *) & curTMA.tolserver_addr, sizeof (curTMA.tolserver_addr)); 
     5621    curTMA.tolserver_addr.sin_family = AF_INET; 
     5622    bcopy((char *) tolgridserver_host->h_addr, (char *) & curTMA.tolserver_addr.sin_addr.s_addr, tolgridserver_host->h_length); 
     5623    curTMA.tolserver_addr.sin_port = htons(tolmachine_server_port); 
     5624    curTMA.status = CREATED; 
     5625    curTMA.send_log = 'N'; 
    57985626    pthread_t thread_tms; 
    5799     int rtms = pthread_create(&thread_tms, NULL, TOLMachineServer, (void*) & tma); 
     5627    int rtms = pthread_create(&thread_tms, NULL, TOLMachineServer, (void*) & curTMA); 
    58005628    pthread_t thread_tmc; 
    5801     int rtmc = pthread_create(&thread_tmc, NULL, TOLMachineControl, (void*) & tma); 
     5629    int rtmc = pthread_create(&thread_tmc, NULL, TOLMachineControl, (void*) & curTMA); 
    58025630    pthread_join(thread_tms, NULL); 
    58035631    pthread_join(thread_tmc, NULL); 
  • tolgrid/tolmachine/trunk/TOLGrid-TOLMACHINE/tolmachine.h

    r4410 r4412  
    88#ifndef _TOLMACHINE_H 
    99#define _TOLMACHINE_H 
     10 
     11#include <vector> 
     12 
     13#include <tol/tol_btext.h> 
    1014 
    1115#include "tolgrid.h" 
     
    9498    char sendLog; 
    9599 
     100protected: 
     101    /*Vector de mensajes generados por TOL/TOLGrid que son maneados por el cliente*/ 
     102    std::vector<char *> messages; 
     103    /*Vector de mensajes generados por TOL/TOLGrid que son almacenados por TOLMachine hasta el fin de su ejecución*/ 
     104    std::vector<char *> messagesP; 
     105 
    96106public: 
    97107    TOLMachine(double ident, int service_port, int control_port, int confirm_port); 
     
    112122    char getSendLog(); 
    113123    void setSendLog(char senLog); 
     124 
     125    void clearMessages(); 
     126    void saveMessage(const BText &message); 
     127    TOLMESSAGES *getMessages(void); 
     128    TOLMESSAGES *getMessagesP(void); 
     129    /*Inicializa la instancia de TOL asociada a este servidor*/ 
     130    void initTOL(void); 
     131    /*Ejecuta código TOL, retorna el número de errores producidos (0=NO HAY ERRORES)*/ 
     132    int executeCode(const char *tolcode); 
     133    /*Obtiene una variable cuyo nombre es pasado por argumento*/ 
     134    TOLVARIABLE getVariable(char *varname); 
     135    /*Obtiene el valor contenido en un nodo sintáctico */ 
     136    TOLVALUE getValue(BSyntaxObject *bso); 
     137    /*Obtiene el valor de una variable cuyo nombre es pasado por argumento*/ 
     138    TOLVALUE getValue(char *varname); 
     139    /*Obtiene la fecha previa a una dada en un TimeSet cuyo nombre es dado*/ 
     140    TOLDATE GetPrevDate_TimeSet(char *varname, TOLDATE date); 
     141    /*Obtiene la fecha siguiente a una dada en un TimeSet cuyo nombre es dado*/ 
     142    TOLDATE GetNextDate_TimeSet(char *varname, TOLDATE date); 
     143    /*Obtiene un arreglo fechas de un TimeSet, a partir de una fecha y una cantidad dada*/ 
     144    TOLDATES getDates_TimeSet(char *varname, TOLDATE date, short size); 
     145    /*Obtiene el fechado de una serie cuyo nombre es dado*/ 
     146    char *GetDating_Serie(char *varname); 
     147    /*Obtiene el valor de una serie en una fecha dada*/ 
     148    TOLREAL getValue_Serie(char *varname, TOLDATE date); 
     149    /*Obtiene un arreglo de items de una serie a partir de una fecha dada con un tamaño máximo dado*/ 
     150    TOLSERIEITEMS getItems_Serie(char *varname, TOLDATE date, short size); 
     151    /*Obtiene un arreglo de items de una serie a partir de una fecha dada con un tamaño máximo dado*/ 
     152    TOLSERIEITEMS getAllItems_Serie(char *varname); 
     153    /*Obtiene la primera fecha de una serie*/ 
     154    TOLDATE getFirstDate_Serie(char *varname); 
     155    /*Obtiene la primera fecha de una serie*/ 
     156    TOLDATE getLastDate_Serie(char *varname); 
     157    /*Obtiene el tamaño de una serie*/ 
     158    int getSize_Serie(char *varname); 
     159    /*Obtiene el tamaño de un elemento de tipo Set*/ 
     160    int getSize_Set(char *varname); 
     161    /*Obtiene un elemento de un conjunto ubicado en una posición dada*/ 
     162    TOLVALUE getElement_Set(char *varname, int index); 
     163    /*Obtiene todos los elementos de un Set*/ 
     164    TOLVALUES getElements_Set(char *varname); 
     165    /*Obtiene todas las variables de tipo Text*/ 
     166    TOLVARIABLES getTextVariables(void); 
     167    /*Obtiene todas las variables de tipo Real*/ 
     168    TOLVARIABLES getRealVariables(void); 
     169    /*Obtiene todas las variables de tipo Date*/ 
     170    TOLVARIABLES getDateVariables(void); 
     171    /*Obtiene todas las variables de tipo Complex*/ 
     172    TOLVARIABLES getComplexVariables(void); 
     173    /*Obtiene todas las variables de tipo Matrix*/ 
     174    TOLVARIABLES getMatrixVariables(void); 
     175    /*Obtiene todas las variables de tipo Polyn*/ 
     176    TOLVARIABLES getPolynVariables(void); 
     177    /*Obtiene todas las variables de tipo Ratio*/ 
     178    TOLVARIABLES getRatioVariables(void); 
     179    /*Obtiene todas las variables de tipo Code*/ 
     180    TOLVARIABLES getCodeVariables(void); 
     181    /*Obtiene todas las variables de tipo TimeSet*/ 
     182    TOLVARIABLES getTimeSetVariables(void); 
     183    /*Obtiene todas las variables de tipo Serie*/ 
     184    TOLVARIABLES getSerieVariables(void); 
     185    /*Obtiene todas las variables de tipo Set*/ 
     186    TOLVARIABLES getSetVariables(void); 
     187    /*Obtiene todas las variables de tipo NameBlock*/ 
     188    TOLVARIABLES getNameBlockVariables(void); 
     189    /* Recibe un comando desde un socket */ 
     190    short readCommand(int sock); 
     191 
     192 
    114193}; 
    115194 
    116 /* Códigos de errores en TOLMachine (manejados a través de la variable errorTM) */ 
    117 #define ERROR_TM_UNKNOWN             -1      /* Error 'desconocido' */ 
    118 #define ERROR_TM_NOERROR            0       /* No hay error */ 
    119 #define ERRORTM_NOT_ENOUGH_MEMORY   1       /* No hay suficiente memoria */ 
    120  
    121 #define ERRORTM_VARIABLE_NOT_FOUND  2       /* Se intenta acceder a una variable TOL con un nombre no encontrado */ 
    122 #define ERRORTM_VARIABLE_NULL       3       /* Se intenta acceder a una variable TOL con nombre NULO o VACÍO */ 
    123 #define ERRORTM_EXECUTE             4       /* No se pudo ejecutar correctamente el código TOL */ 
    124 #define ERRORTM_INVALID_DATE        5       /* Se intenta usar una fecha no válida para la operación */ 
    125 #define ERRORTM_INVALID_INDEX       6       /* Se intenta usar un elemento de un conjunto con indice fuera de rango */ 
    126 #define ERRORTM_INVALID_TYPE        7       /* Se intenta asignar a una variable un valor de un tipo distinto al de la variable */ 
    127 #define ERRORTM_INVALID_ID          8       /* Se intenta establecer una conexión enviando un id que no corresponde al asignado a la tolmachine */ 
    128 #define ERRORTM_INTERNAL_FILE_ERROR 9       /* Se intenta realizar una operación sobre un fichero y falla */ 
    129 #define ERRORTM_INVALID_COMMAND     10      /* Se ha enviado un comando inválido o desconocido */ 
    130  
    131 /* Tipos de mensajes: ERROR, WARNING, OUTPUT, TOLGRID */ 
    132 #define MSG_TYPE_TOL_ERROR          1 
    133 #define MSG_TYPE_TOL_WARNING        2 
    134 #define MSG_TYPE_TOL_OUTPUT         3 
    135 #define MSG_TYPE_TOLGRID            4 
    136  
    137195#endif  /* _TOLMACHINE_H */