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"
#ifdef __MVS__
#pragma export(dtw_initialize)
#pragma export(dtw_execute)
#pragma export(dtw_getNextRow)
#pragma export(dtw_cleanup)
#endif
#ifdef _AIX_
//*--------------------------------------------------------------------*/
/* Funzione */
/* dtw_getFp */
/* */
/* Finalità */
/* Imposta gli indicatori di funzione per le routine dell'ambiente */
/* di linguaggio fonirta da questo ambiente. Se una routine della */
/* struttura non viene fornita, impostare questo campo su */
/* NULL. */
/* */
/* Formato */
/* int dtw_getFp(dtw_fp_t *func_pointer) */
/* */
/* Parametri */
/* func_pointer Un indicatore per una struttura che contiene */
/* gli indicatori della funzione per tutte le */
/* funzioni fornite dall'ambente di linguaggio */
/* */
/* Codici di ritorno */
/* Esito pos...... 0 */
/* Esito neg...... -1 */
/*--------------------------------------------------------------------*/
int dtw_getFp(dtw_fp_t *func_pointer)
{
func_pointer->dtw_initialize_fp = dtw_initialize;
func_pointer->dtw_execute_fp = dtw_execute;
func_pointer->dtw_getNextRow_fp = dtw_getNextRow;
func_pointer->dtw_cleanup_fp = dtw_cleanup;
return 0;
}
#endif
/*--------------------------------------------------------------------*/
/* */
/* 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;
}
|