Utilizzare questa maschera per creare ambienti di linguaggio propri.
Figura 2. Maschera dell'ambiente di linguaggio
/**********************************************************************/ /* */ /* Nome file */ /* */ /* Descrizione */ /* */ /* Funzioni */ /* */ /* Entry point */ /* */ /* Modifica attività */ /* */ /* Indic. Motivo Data Sviluppatore Descrizione */ /* ------ ---------- -------- ------------ ---------------------- */ /* */ /**********************************************************************/ /*--------------------------------------------------------------------*/ /* Include */ /*--------------------------------------------------------------------*/ #include "dtwle.h"
/*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* dtw_initialize */ /* */ /* Finalità */ /* */ /* Formato */ /* int dtw_initialize(dtw_lei_t *le_interface) */ /* */ /* Parametri */ /* le_interface Indicatore per una struttura contenente */ /* i seguenti campi: */ /* */ /* function_name */ /* flags */ /* exec_statement */ /* parm_data_array */ /* default_error_message */ /* le_opaque_data */ /* row */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg...... 0 */ /*--------------------------------------------------------------------*/ int dtw_initialize(dtw_lei_t *le_interface) { return rc; } /*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* dtw_execute */ /* */ /* Finalità */ /* */ /* Formato */ /* int dtw_execute(dtw_lei_t *le_interface) */ /* */ /* Parametri */ /* le_interface Indicatore per una struttura contenente */ /* i seguenti campi: */ /* */ /* function_name */ /* flags */ /* exec_statement */ /* parm_data_array */ /* default_error_message */ /* le_opaque_data */ /* row */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg...... 0 */ /*--------------------------------------------------------------------*/ int dtw_execute(dtw_lei_t *le_interface) { /*----------------------------------------------------------------*/ /* Determina se è stata specificata l'istruzione %exec */ /*----------------------------------------------------------------*/ if (le_interface->flags & DTW_STMT_EXEC) { /*------------------------------------------------------------*/ /* Esamina l'istruzione %exec */ /*------------------------------------------------------------*/ rc = processExecStmt(le_interface->exec_statement); if (rc) { } } else { /*------------------------------------------------------------*/ /* Esamina i dati in linea */ /*------------------------------------------------------------*/ rc = processInlineData(le_interface->exec_statement); if (rc) { } } /*----------------------------------------------------------------*/ /* Esamina i parametri di immissione */ /*----------------------------------------------------------------*/ rc = processInputParms(le_interface->parm_data_array); if (rc) { } /*----------------------------------------------------------------*/ /* Esamina la richiesta */ /*----------------------------------------------------------------*/ rc = processRequest(); if (rc) { } /*----------------------------------------------------------------*/ /* Esamina i dati di emissione */ /*----------------------------------------------------------------*/ rc = processOutputParms(le_interface->parm_data_array); if (rc) { } /*----------------------------------------------------------------*/ /* Esamina il codice di ritorno e il messaggio di errore predef. */ /*----------------------------------------------------------------*/ if (rc) { setErrorMessage(rc, &(le_interface->default_error_message)); } /*----------------------------------------------------------------*/ /* Aggiornamento e uscita dal programma. */ /*----------------------------------------------------------------*/ return rc; } /*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* dtw_getNextRow */ /* */ /* Finalità */ /* */ /* Formato */ /* int dtw_getNextRow(dtw_lei_t *le_interface) */ /* */ /* Parametri */ /* le_interface Indicatore per una struttura contenente */ /* i seguenti campi: */ /* */ /* function_name */ /* flags */ /* exec_statement */ /* parm_data_array */ /* default_error_message */ /* le_opaque_data */ /* row */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg...... 0 */ /*--------------------------------------------------------------------*/ int dtw_getNextRow(dtw_lei_t *le_interface) { return rc; } /*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* dtw_cleanup */ /* */ /* Finalità */ /* */ /* Formato */ /* int dtw_cleanup(dtw_lei_t *le_interface) */ /* */ /* Parametri */ /* le_interface Indicatore per una struttura contenente */ /* i seguenti campi: */ /* */ /* function_name */ /* flags */ /* exec_statement */ /* parm_data_array */ /* default_error_message */ /* le_opaque_data */ /* row */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg...... 0 */ /*--------------------------------------------------------------------*/ int dtw_cleanup(dtw_lei_t *le_interface) { /*----------------------------------------------------------------*/ /* Determina se si tratta di una chiusura normale o anomala. */ /*----------------------------------------------------------------*/ if (le_interface->flags & DTW_END_ABNORMAL) { /*------------------------------------------------------------*/ /* Esegue una chiusura anomala. */ /*------------------------------------------------------------*/ } else { /*------------------------------------------------------------*/ /* Esegue una chiusura normale. */ /*------------------------------------------------------------*/ } return rc; } /*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* processInputParms */ /* */ /* Finalità */ /* */ /* Formato */ /* unsigned long processInputParms(dtw_parm_data_t *parm__data) */ /* */ /* Parametri */ /* dtw_parm_data_t *parm_data */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg.... */ /* */ /*--------------------------------------------------------------------*/ unsigned long processInputParms(dtw_parm_data_t *parm_data) { /*----------------------------------------------------------------*/ /* Scorre tutte le variabili della serie di dati del parametro. */ /* La serie termina con una voce NULL, cioè il campo parm_name */ /* è impostato su NULL, il campo parm_value è impostato su NULL e */ /* il campo parm_descriptor è impostato su 0. Tuttavia l'unico */ /* controllo valido per la chiusura della serie di dati del */ /* è parm_descriptor == 0, poichè il campo parm_name è NULL quando*/ /* viene trasferita una stringa letterale e il campo parm_value è */ /* impostato su NULL quando viene trasferita una variabile non */ /* dichiarata. */ /*----------------------------------------------------------------*/ for (; parm_data->parm_descriptor != 0; ++parm_data) { /*------------------------------------------------------------*/ /* Determinare l'uso di ogni parametro di immissione. */ /*------------------------------------------------------------*/ switch(parm_data->parm_descriptor & DTW_USAGE) { case(DTW_IN): /*----------------------------------------------------*/ /* Determinare il tipo di ogni parametro di immissione*/ /*----------------------------------------------------*/ switch (parm_data->parm_descriptor & DTW_TYPE) { case DTW_STRING: break; case DTW_TABLE: break; default: /*--------------------------------------------*/ /* Errore interno - tipo di dati sconosciuto */ /*--------------------------------------------*/ break; } break; case(DTW_OUT): break; case(DTW_INOUT): break; default: /*----------------------------------------------------*/ /* Errore interno - uso sconosciuto */ /*----------------------------------------------------*/ break; } } return rc; } /*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* processOutputParms() */ /* */ /* Finalità */ /* */ /* Formato */ /* unsigned long processOutputParms(dtw_parm_data_t *parm_data) */ /* */ /* Parametri */ /* dtw_parm_data_t *parm_data */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg.......-1 */ /* */ /*--------------------------------------------------------------------*/ unsigned long processOutputParms(dtw_parm_data_t *parm_data) { /*----------------------------------------------------------------*/ /* Richiedere i dati di emissione nel modo specifico all'ambiente * /* di linguaggio. Ciò dipende interamente dall'interfaccia */ /* dell'ambiente di linguaggio e dal modo scelto da LE. */ /*----------------------------------------------------------------*/ / /*----------------------------------------------------------------*/ /* Scorrere tutti i parametri della serie di dati del parametro, */ /* ricercando i parametri di emissione. */ /*----------------------------------------------------------------*/ for (; parm_data->parm_descriptor != 0; ++parm_data) { /*------------------------------------------------------------*/ /* Determinare l'uso di ogni parametro. */ /*------------------------------------------------------------*/ if (pd_i->parm_descriptor & DTW_OUT) { /*--------------------------------------------------------*/ /* Determinare il tipo di ogni parametro di immissione*/ /*--------------------------------------------------------*/ switch (pd_i->parm_descriptor & DTW_TYPE) { case DTW_STRING: /*------------------------------------------------*/ /* Conferire un nuovo valore a un parametro di */ /* stringa. Se il valore del parametro non è NULL,*/ /* liberare memoria utilizzando il programma di */ /* utilità dell'interfaccia LE se era stata */ /* assegnata da Net.Data. */ /*------------------------------------------------*/ if (parm_data->parm_value != NULL) dtw_free(parm_data->parm_value); parm_data->parm_value = dtw_strdup(newValue); break; case DTW_TABLE: /*------------------------------------------------*/ /* Modificare la dimensione di un parametro di */ /* tabella. Utilizzare il programma di utilità */ /* dell'interfaccia LE per modificare l'oggetto */ /* tabella. */ /*------------------------------------------------*/ /*------------------------------------------------*/ /* Richiedere prima l'indicatore dell'oggetto */ /* tabella. */ /*------------------------------------------------*/ void *myTable = (void *) parm_data->parm_value; /*------------------------------------------------*/ /* Successivamente richiede la dimensione corrente*/ /* della tabella. */ /*------------------------------------------------*/ cols = dtw_table_Cols(myTable); rows = dtw_table_Rows(myTable); /*------------------------------------------------*/ /* Impostare la nuova dimensione (si presume che */ /* i valori della nuova dimensione siano validi). */ /*------------------------------------------------*/ /*------------------------------------------------*/ /* Impostare prima le colonne. */ /*------------------------------------------------*/ if (cols > newColValue) { dtw_table_DeleteCol(myTable, newColValue + 1, cols - newColValue); } else if (cols < new_col_value) { dtw_table_InsertCol(myTable, cols, newColValue - cols); } /*------------------------------------------------*/ /* Impostare le righe. */ /*------------------------------------------------*/ if (newColValue > 0) { if (rows > newRowValue) { dtw_table_DeleteRow(myTable, newRowValue + 1, rows - newRowValue); } else if (rows < new_row_value) { dtw_table_InsertRow(myTable, rows, newRowValue - rows); } } /*------------------------------------------------*/ /* Richiedere il valore dell'ultima riga/colonna. */ /*------------------------------------------------*/ dtw_table_GetV(myTable, &myValue;, newRowValue, newColValue); /*------------------------------------------------*/ /* Cancella il valore dell'ultima riga/colonna. */ /*------------------------------------------------*/ dtw_table_SetV(myTable, NULL, newRowValue, newColValue); /*------------------------------------------------*/ /* Imposta il valore dell'ultima riga/colonna. */ /*------------------------------------------------*/ dtw_table_SetV(myTable, dtw_strdup(myNewValue), newRowValue, newColValue); break; default: /*------------------------------------------------*/ /* Errore interno - tipo di dati sconosciuto */ /*------------------------------------------------*/ break; } } } return 0; } /*--------------------------------------------------------------------*/ /* */ /* Funzione */ /* setErrorMessage() */ /* */ /* Finalità */ /* */ /* Formato */ /* unsigned long setErrorMessage(int returnCode, */ /* char **defaultErrorMessage) */ /* */ /* Parametri */ /* int returnCode */ /* char **defaultErrorMessage */ /* */ /* Codici di ritorno */ /* Esito pos...... 0 */ /* Esito neg.......-1 */ /* */ /*--------------------------------------------------------------------*/ unsigned long setErrorMessage(int returnCode, char **defaultErrorMessage) { /*----------------------------------------------------------------*/ /* Imposta il messaggio di errore predefinito in base al codice */ /* di ritorno. */ /*----------------------------------------------------------------*/ switch(returnCode) { case LE_SUCCESS: break; case LE_RC1: *defaultErrorMessage = dtw_strdup(LE_RC1_MESSAGE_TEXT); break; case LE_RC2: *defaultErrorMessage = dtw_strdup(LE_RC2_MESSAGE_TEXT); break; case LE_RC3: *defaultErrorMessage = dtw_strdup(LE_RC3_MESSAGE_TEXT); break; case LE_RC4: *defaultErrorMessage = dtw_strdup(LE_RC4_MESSAGE_TEXT); rc = LE_RC1INTERNAL; break; } return 0; } |