IBM Books

Net.Data: riferimenti all'ambiente di linguaggio


Appendice A. Maschera dell'ambiente di linguaggio

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;
}


[ Inizio pagina | Pagina precedente | Pagina successiva | Indice | Indice analitico ]