Difference between revisions of "CQDFRTVFD"

From MidrangeWiki
Jump to: navigation, search
(another version)
m (fix small bug)
 
(15 intermediate revisions by the same user not shown)
Line 22: Line 22:
  
 
<pre>
 
<pre>
 
  
 
  /* Function: This program uses the QDFRTVFD API to return the */
 
  /* Function: This program uses the QDFRTVFD API to return the */
Line 77: Line 76:
 
     char *p_iRecord;
 
     char *p_iRecord;
 
     char *p_iField;
 
     char *p_iField;
     char *p_iRow;
+
     int  *p_iNumFld;
    char *p_iCol;
 
 
     char *p_iFunc;
 
     char *p_iFunc;
  
Line 93: Line 91:
 
     int  FldDec;
 
     int  FldDec;
 
     int  EndDta;
 
     int  EndDta;
 +
    int  NumFld;
 
   } FieldData_t;
 
   } FieldData_t;
  
Line 105: Line 104:
 
         char *iRecord;
 
         char *iRecord;
 
         char *iField;
 
         char *iField;
         char *iRow;
+
         int  *iFld;
        char *iCol;
 
 
         char *iFunc;
 
         char *iFunc;
 
         FieldData_t *iOdata;
 
         FieldData_t *iOdata;
Line 126: Line 124:
  
 
     char FileName[20] = "                    ";
 
     char FileName[20] = "                    ";
    char Fldblank[3000] = { " " };
 
 
     char Format[8];
 
     char Format[8];
 
     int  EndFlds = 0;
 
     int  EndFlds = 0;
Line 155: Line 152:
 
     p_iRecord =  main_args->iRecord;
 
     p_iRecord =  main_args->iRecord;
 
     p_iField  =  main_args->iField;
 
     p_iField  =  main_args->iField;
     p_iRow    =  main_args->iRow;
+
     p_iNumFld =  main_args->iFld;
    p_iCol    =  main_args->iCol;
 
 
     p_iFunc  =  main_args->iFunc;
 
     p_iFunc  =  main_args->iFunc;
 
     Odata    =  main_args->iOdata;
 
     Odata    =  main_args->iOdata;
Line 245: Line 241:
  
 
int ProcessField(int *GotIt) {
 
int ProcessField(int *GotIt) {
 
 
       int SflCtl;
 
       int SflCtl;
 
       int SizeIdx;
 
       int SizeIdx;
Line 254: Line 249:
 
       char X01    =  0x01 ;
 
       char X01    =  0x01 ;
 
       char Functn[10] = "          ";
 
       char Functn[10] = "          ";
 +
 +
      NumFlds = 0;
  
 
       /*  record header  */
 
       /*  record header  */
Line 352: Line 349:
 
         memcpy(Odata->FldNam,
 
         memcpy(Odata->FldNam,
 
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
 
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
         memcpy(Odata->FldCom,Fldblank,3000);
+
         memset(Odata->FldCom, ' ',3000);
 
         Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
 
         Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
 
         Odata->FldDec  = p_QDFFFNAM->WDFFDEC;
 
         Odata->FldDec  = p_QDFFFNAM->WDFFDEC;
Line 366: Line 363:
 
       NumFlds += 1;
 
       NumFlds += 1;
  
 +
      Odata->NumFld = NumFlds;
 
       Odata->EndDta  = 0;
 
       Odata->EndDta  = 0;
  
Line 389: Line 387:
 
     /* We know we are about to get the NEXT record when we have */
 
     /* We know we are about to get the NEXT record when we have */
 
     /* found the record just before                            */
 
     /* found the record just before                            */
        if (!memcmp(Functn , "#NEXT"  , 5)) {
 
          if (!memcmp(p_iRecord, Odata->RecordName, sizeof(*p_iRecord))) {
 
            if(!memcmp(p_iField, Odata->FldNam,sizeof(*p_iField) ))      {
 
              if(!memcmp(p_iRow, Odata->ROW, sizeof(*p_iRow) ))          {
 
                if(!memcmp(p_iCol,Odata->COL, sizeof(*p_iCol)))          {
 
          *GotIt = 1;
 
                };
 
              };
 
            };
 
          };
 
        };
 
  
 +
      if (!memcmp(Functn , "#NEXT" , 5) &&
 +
      !memcmp(p_iRecord, Odata->RecordName, 10) &&
 +
      !memcmp(p_iField, Odata->FldNam, 10 ) &&
 +
        (*p_iNumFld  EQ  NumFlds))
 +
      *GotIt = 1;
  
  
Line 419: Line 411:
 
     if  (p_QDFFFDPD->WDFFFDOC > 0) {
 
     if  (p_QDFFFDPD->WDFFFDOC > 0) {
  
      p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
+
  /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
                                              p_QDFFFDPD->WDFFFDOC);
+
  /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */
 +
 
 +
        p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
 +
                                                p_QDFFFDPD->WDFFFDOC);
 
       cc = 0;
 
       cc = 0;
 
       for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {
 
       for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {
Line 449: Line 444:
  
 
       }
 
       }
 +
 +
 +
  
 
     }
 
     }
Line 492: Line 490:
 
         *Odata->FldIO  = p_QDFFFINF->WDFFFIOA;
 
         *Odata->FldIO  = p_QDFFFINF->WDFFFIOA;
 
   p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
 
   p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
 +
        memset(Odata->FldCom, ' ',3000);
 
         memcpy(Odata->FldCom,
 
         memcpy(Odata->FldCom,
 
                 p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
 
                 p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
Line 509: Line 508:
 
       /*  category 24  (Date, Time)                    */
 
       /*  category 24  (Date, Time)                    */
 
       /*-----------------------------------------------*/
 
       /*-----------------------------------------------*/
 +
        memcpy(Odata->FldNam,"          ",10);
 +
        memset(Odata->FldCom, ' ',3000);
 
}
 
}
 +
 +
 +
 
</pre>
 
</pre>
 
+
[[#top]]
  
 
=== RTVFLD    (RPG code  DISPINFOC driver) ===
 
=== RTVFLD    (RPG code  DISPINFOC driver) ===
Line 522: Line 526:
  
 
<pre>
 
<pre>
 
 
 
     h Option(*NODEBUGIO)  DFTACTGRP(*NO)
 
     h Option(*NODEBUGIO)  DFTACTGRP(*NO)
  
Line 539: Line 541:
 
     D oRecord                      10A  const
 
     D oRecord                      10A  const
 
     D oField                        10A  const
 
     D oField                        10A  const
     D oRow                          1A  const
+
     D oFld                          10I 0 const
    D oCol                          1A  const
 
 
     D Func                          10A  const
 
     D Func                          10A  const
 
     D Fdata                              like(RTVDATA)
 
     D Fdata                              like(RTVDATA)
Line 555: Line 556:
 
     D FldDec                        10I 0
 
     D FldDec                        10I 0
 
     D EndDta                        10I 0
 
     D EndDta                        10I 0
 +
    D NumFld                        10I 0
  
     D oRecordName                   10A
+
     D oRecordName     S            10A
     D oFldNam                       10A
+
     D oFldNam         S            10A
     D oRow                          1A
+
     D oFld            S            10I 0
    D oCol                          1A
 
  
 
       /free
 
       /free
Line 565: Line 566:
 
           *INLR = *ON;
 
           *INLR = *ON;
  
           DISPINFOC( iLib  : iFile    : '  ': '  ' : '  ': '  ':
+
           DISPINFOC( iLib  : iFile    : '  ': '  ' : :
 
                     '#FIRST' : RTVDATA  );
 
                     '#FIRST' : RTVDATA  );
  
Line 572: Line 573:
 
                     oRecordName  =    RecordName ;
 
                     oRecordName  =    RecordName ;
 
                     oFldNam      =    FldNam    ;
 
                     oFldNam      =    FldNam    ;
                     oROW         =    ROW        ;
+
                     oFld         =    NumFld    ;
                    oCOL        =    COL        ;
 
  
       // To get the next record the previous fields info is passed
+
       // To get the next record the previous fields info is also passed
 
           DISPINFOC(iLib  :  iFile    :
 
           DISPINFOC(iLib  :  iFile    :
 
                     oRecordName  :
 
                     oRecordName  :
 
                     oFldNam      :
 
                     oFldNam      :
                     oROW        :
+
                     oFld         :
                    oCOL         :
 
 
                     '#NEXT ' : RTVDATA  );
 
                     '#NEXT ' : RTVDATA  );
  
Line 586: Line 585:
  
 
       /end-free
 
       /end-free
</pre>
 
  
  
===DISPINFOC1  Version with User Space ===
 
  
  
  
<pre>
+
</pre>
 +
[[#top]]
 +
 
 +
===DISPINFOC1  Version with User Space ===
 +
 
 +
 
 +
 
 +
<pre>
 
   
 
   
 
/* Function: This program uses the QDFRTVFD API to return the */
 
/* Function: This program uses the QDFRTVFD API to return the */
Line 600: Line 604:
  
 
DISPINFOC1
 
DISPINFOC1
 
/* Function: This program uses the QDFRTVFD API to return the */
 
/* structure of a display file.  */
 
 
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
#include "QSYSINC/H/QUSEC"
 
#include "QSYSINC/H/QDFRTVFD"
 
 
#include <mispace.h>
 
#include <pointer.h>
 
#include <mispcobj.h>
 
#include <except.h>
 
#include <qtes.h>
 
 
   
 
   
 
   
 
   
 +
/* Function: This program uses the QDFRTVFD API to return the */
 +
/* structure of a display file.  */
 +
 +
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <string.h>
 +
#include "QSYSINC/H/QUSEC"
 +
#include "QSYSINC/H/QDFRTVFD"
 +
 +
#include <mispace.h>
 +
#include <pointer.h>
 +
#include <mispcobj.h>
 +
#include <except.h>
 +
#include <qtes.h>
 +
 +
 
     /* Link up the Create User Space API */
 
     /* Link up the Create User Space API */
 
     #pragma linkage(CreateUserSpace,OS)
 
     #pragma linkage(CreateUserSpace,OS)
 
     #pragma map(CreateUserSpace,"QUSCRTUS")
 
     #pragma map(CreateUserSpace,"QUSCRTUS")
+
 
 
     void    CreateUserSpace(char[20],
 
     void    CreateUserSpace(char[20],
 
                         char[10],
 
                         char[10],
Line 631: Line 636:
 
                         _TE_ERROR_CODE_T *
 
                         _TE_ERROR_CODE_T *
 
                         );
 
                         );
+
 
 
     /* Link up the Delete User Space API */
 
     /* Link up the Delete User Space API */
 
     #pragma linkage(DeleteUserSpace,OS)
 
     #pragma linkage(DeleteUserSpace,OS)
Line 638: Line 643:
 
                         _TE_ERROR_CODE_T *
 
                         _TE_ERROR_CODE_T *
 
                         );
 
                         );
+
 
 
     /* Link up the Retrieve Pointer to User Space API */
 
     /* Link up the Retrieve Pointer to User Space API */
 
     #pragma linkage(RetrievePointerToUserSpace,OS)
 
     #pragma linkage(RetrievePointerToUserSpace,OS)
Line 646: Line 651:
 
                                 _TE_ERROR_CODE_T *
 
                                 _TE_ERROR_CODE_T *
 
                                 );
 
                                 );
+
 
   
+
 
#define EQ      ==
+
  #define EQ      ==
   
+
 
#define fail() do { printf("\nLine %d FAILED in file %s", \
+
  #define fail() do { printf("\nLine %d FAILED in file %s", \
__LINE__,__FILE__); \
+
__LINE__,__FILE__); \
} while(0)
+
} while(0)
+
 
 
/* Pointers to structures required to be used by this program. */
 
/* Pointers to structures required to be used by this program. */
QDFFBASE_t *p_QDFFBASE;
+
QDFFBASE_t *p_QDFFBASE;
QDFFINFO_t *p_QDFFINFO;
+
QDFFINFO_t *p_QDFFINFO;
QDFARFTE_t *p_QDFARFTE;
+
QDFARFTE_t *p_QDFARFTE;
QDFFRINF_t *p_QDFFRINF;
+
QDFFRINF_t *p_QDFFRINF;
QDFFDPDD_t *p_QDFFDPDD;
+
QDFFDPDD_t *p_QDFFDPDD;
QDFFRDPD_t *p_QDFFRDPD;
+
QDFFRDPD_t *p_QDFFRDPD;
QDFWFLEI_t *p_QDFWFLEI;
+
QDFWFLEI_t *p_QDFWFLEI;
QDFFNTBL_t *p_QDFFNTBL;
+
QDFFNTBL_t *p_QDFFNTBL;
QDFWRCDI_t *p_QDFWRCDI;
+
QDFWRCDI_t *p_QDFWRCDI;
QDFWFLDI_t *p_QDFWFLDI;
+
QDFWFLDI_t *p_QDFWFLDI;
QDFFSFCR_t *p_QDFFSFCR;
+
QDFFSFCR_t *p_QDFFSFCR;
QDFFSFHR_t *p_QDFFSFHR;
+
QDFFSFHR_t *p_QDFFSFHR;
QDFFSCRA_t *p_QDFFSCRA;
+
QDFFSCRA_t *p_QDFFSCRA;
QDFFFITB_t *p_QDFFFITB;
+
QDFFFITB_t *p_QDFFFITB;
QDFFFINF_t *p_QDFFFINF;
+
QDFFFINF_t *p_QDFFFINF;
QDFFFCON_t *p_QDFFFCON;
+
QDFFFCON_t *p_QDFFFCON;
QDFFFDPD_t *p_QDFFFDPD;
+
QDFFFDPD_t *p_QDFFFDPD;
QDFFFNAM_t *p_QDFFFNAM;
+
QDFFFNAM_t *p_QDFFFNAM;
QDFFFDIC_t *p_QDFFFDIC;
+
QDFFFDIC_t *p_QDFFFDIC;
QDFFXFDP_t *p_QDFFXFDP;
+
QDFFXFDP_t *p_QDFFXFDP;
QDFFRCTB_t *p_QDFFRCTB;
+
QDFFRCTB_t *p_QDFFRCTB;
QDFFRCTE_t *p_QDFFRCTE;
+
QDFFRCTE_t *p_QDFFRCTE;
QDFFNTB_t  *p_QDFFNTB;
+
QDFFNTB_t  *p_QDFFNTB;
QDFFCOSA_t *p_QDFFCOSA;
+
QDFFCOSA_t *p_QDFFCOSA;
QDFFCCOA_t *p_QDFFCCOA;
+
QDFFCCOA_t *p_QDFFCCOA;
QDFKMFDK_t *p_QDFKMFDK;
+
QDFKMFDK_t *p_QDFKMFDK;
QDFKDFT_t  *p_QDFKDFT;
+
QDFKDFT_t  *p_QDFKDFT;
QDFKEDTR_t *p_QDFKEDTR;
+
QDFKEDTR_t *p_QDFKEDTR;
QDFKDFPM_t *p_QDFKDFPM;
+
QDFKDFPM_t *p_QDFKDFPM;
+
 
+
 
     /* Global variables */
+
     /* Global variables */
     char *p_iLib;
+
     char *p_iLib;
     char *p_iFile;
+
     char *p_iFile;
     char *p_iRecord;
+
     char *p_iRecord;
     char *p_iField;
+
     char *p_iField;
     char *p_iRow;
+
     int  *p_iNumFld;
     char *p_iCol;
+
     char *p_iFunc;
    char *p_iFunc;
+
 
   
+
  /* returned data  */
/* returned data  */
+
typedef struct FieldData {
typedef struct FieldData {
+
     char RecordName[10];
     char RecordName[10];
+
     char ROW[1];
     char ROW[1];
+
     char COL[1];
     char COL[1];
+
     char FldIO[1];
     char FldIO[1];
+
     char FldAtr[1];
     char FldAtr[1];
+
     char FldNam[10];
     char FldNam[10];
+
     char FldCom[3000];
     char FldCom[3000];
+
     int  FldPlen;
     int  FldPlen;
+
     int  FldDec;
     int  FldDec;
+
     int  EndDta;
     int  EndDta;
+
    int  NumFld;
   } FieldData_t;
+
   } FieldData_t;
   
+
 
FieldData_t *p_FieldData;
+
  FieldData_t *p_FieldData;
FieldData_t *Odata;
+
FieldData_t *Odata;
+
 
     typedef struct inputArguments
+
     typedef struct inputArguments
    {
 
        char *pgmname;
 
        char *iLib;
 
        char *iFile;
 
        char *iRecord;
 
        char *iField;
 
        char *iRow;
 
        char *iCol;
 
        char *iFunc;
 
        FieldData_t *iOdata;
 
    } main_args_t;
 
 
    int RtvApiDta (void);
 
    int ProcessRec (void);
 
    int ProcessField (int *);
 
    int ProcessCons(void);
 
    int ProcessCat22(void);
 
    int ProcessCat23(void);
 
    int ProcessCat24(void);
 
 
    int RecIndex;
 
 
  /* Area into which the QDFRTVFD returns  the requested data.*/
 
 
    char *pBuffer;
 
    _TE_ERROR_CODE_T errorCode;
 
 
 
    char FileName[20] = "                    ";
 
    char Format[8];
 
    int  EndFlds = 0;
 
 
    /* 4 bytes WDFFRETN Length of the returned data. */
 
    /* 4 bytes WDFFSIZE Size of the display file description */
 
    typedef struct RtvSizeInfo
 
 
     {
 
     {
         int ReturnLen;
+
        char *pgmname;
         int ReturnSiz;
+
        char *iLib;
     } RtvSizeInfo_t;
+
        char *iFile;
+
        char *iRecord;
+
        char *iField;
+
        int  *iFld;
   /* ########################################################  */
+
        char *iFunc;
int main(int argc, main_args_t *main_args)
+
        FieldData_t *iOdata;
{
+
    } main_args_t;
+
 
     char Funct[10] = "          ";
+
    int RtvApiDta (void);
+
    int ProcessRec (void);
     p_iFile  =  main_args->iFile;
+
    int ProcessField (int *);
     p_iLib    =  main_args->iLib;
+
    int ProcessCons(void);
     p_iRecord =  main_args->iRecord;
+
    int ProcessCat22(void);
     p_iField  =  main_args->iField;
+
    int ProcessCat23(void);
     p_iRow    =  main_args->iRow;
+
    int ProcessCat24(void);
    p_iCol    =  main_args->iCol;
+
 
     p_iFunc  =  main_args->iFunc;
+
    int RecIndex;
     Odata    =  main_args->iOdata;
+
 
+
  /* Area into which the QDFRTVFD returns  the requested data.*/
+
 
+
    char *pBuffer;
       /* On First pass get the API data */
+
    _TE_ERROR_CODE_T errorCode;
       memmove(Funct,p_iFunc, strlen(p_iFunc));
+
 
         if (!memcmp(Funct, "#FIRST", 6)) {
+
 
             RtvApiDta();
+
    char FileName[20] = "                    ";
             };
+
    char Format[8];
+
    int  EndFlds = 0;
         if (!memcmp(Funct, "#NEXT", 5)) {
+
 
     /*! call RetrievePointerToUserSpace - Retrieve Pointer to User Space */
+
    /* 4 bytes WDFFRETN Length of the returned data. */
           errorCode.BytesProvided = 0;
+
    /* 4 bytes WDFFSIZE Size of the display file description */
           RetrievePointerToUserSpace("RTVFDUSPC QTEMP      ",
+
    typedef struct RtvSizeInfo
                            &pBuffer,
+
    {
                            &errorCode);
+
         int ReturnLen;
      }
+
         int ReturnSiz;
+
     } RtvSizeInfo_t;
    ProcessRec();
+
 
+
 
+
 
    /*  free(ReturnVar);  */
+
   /* ########################################################  */
}
+
int main(int argc, main_args_t *main_args)
+
{
+
 
+
     char Funct[10] = "          ";
+
 
  /* ######################################### */
+
     p_iFile  =  main_args->iFile;
+
     p_iLib    =  main_args->iLib;
    RtvApiDta() {
+
     p_iRecord =  main_args->iRecord;
+
     p_iField  =  main_args->iField;
    RtvSizeInfo_t *RtvSize;
+
     p_iNumFld =  main_args->iFld;
    int  API_Len;
+
     p_iFunc  =  main_args->iFunc;
+
     Odata    =  main_args->iOdata;
    Qus_EC_t Error_Code = {0};
+
 
+
 
+
 
    /* Define the API format requested and the display file to access */
+
       /* On First pass get the API data */
    memcpy(Format,"DSPF0100",8);
+
       memmove(Funct,p_iFunc, strlen(p_iFunc));
    /* Point to your DSPF */
+
         if (!memcmp(Funct, "#FIRST", 6)) {
    memmove(FileName,p_iFile, strlen(p_iFile));
+
             RtvApiDta();
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));
+
             };
+
 
    /* Invoke the API. to get the size needed */
+
         if (!memcmp(Funct, "#NEXT", 5)) {
    RtvSize =  malloc(8);
+
     /*! call RetrievePointerToUserSpace - Retrieve Pointer to User Space */
    QDFRTVFD (RtvSize,
+
           errorCode.BytesProvided = 0;
                8,
+
           RetrievePointerToUserSpace("RTVFDUSPC QTEMP      ",
                Format,
 
                FileName,
 
                &Error_Code);
 
    if ( Error_Code.Bytes_Available != 0 ) {
 
            fail();
 
            exit (1);
 
    }
 
    API_Len  =  RtvSize->ReturnSiz;
 
    free(RtvSize);
 
 
    CreateUserSpace("RTVFDUSPC QTEMP      ",
 
                    "USRSPC    ",
 
                    API_Len,
 
                    0,
 
                    "*ALL      ",
 
                    " ",
 
                    "*YES      ",
 
                    &errorCode
 
                    );
 
 
    /*! call RetrievePointerToUserSpace - Retrieve Pointer to User Space */
 
    /*!! (pass: Name and library of user space, pointer variable */
 
    /*!! return: nothing (pointer variable is left pointing to start*/
 
    /*!! of user space) */
 
      errorCode.BytesProvided = 0;
 
      RetrievePointerToUserSpace("RTVFDUSPC QTEMP      ",
 
 
                             &pBuffer,
 
                             &pBuffer,
 
                             &errorCode);
 
                             &errorCode);
+
      }
     QDFRTVFD (pBuffer,
+
 
                API_Len,
+
     ProcessRec();
                Format,
+
 
                FileName,
+
 
                &Error_Code);
+
    /*  free(ReturnVar); */
    if ( Error_Code.Bytes_Available != 0 ) {
+
}
            fail();
+
 
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
+
 
            exit (1);
+
 
    }
+
 
}
 
 
 
 
 
 
   /* ######################################### */
 
   /* ######################################### */
int ProcessRec() {
+
 
+
    RtvApiDta() {
     int  NumRecs;
+
 
     int i;
+
     RtvSizeInfo_t *RtvSize;
     int GotIt = 0;
+
     int API_Len;
    /* Access returned structures. The base structure starts at */
+
 
     /* the begining of the returned space. */
+
     Qus_EC_t Error_Code = {0};
    p_QDFFBASE = (QDFFBASE_t *)pBuffer;
+
 
    p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
+
 
    p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
+
     /* Define the API format requested and the display file to access */
    p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
+
    memcpy(Format,"DSPF0100",8);
    p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
+
    /* Point to your DSPF */
    p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
+
    memmove(FileName,p_iFile, strlen(p_iFile));
    p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
+
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));
+
 
     /* here is the place to retreive File Keywords */
+
    /* Invoke the API. to get the size needed */
+
    RtvSize = malloc(8);
     NumRecs = p_QDFFBASE->WDFFRCS;
+
    QDFRTVFD (RtvSize,
+
                8,
    for (i=0; i< NumRecs ; ++i) {
+
                Format,
+
                FileName,
        /* Bump ptr to next record structure */
+
                &Error_Code);
      if  (i  != 0)
+
    if ( Error_Code.Bytes_Available != 0 ) {
    {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
+
            fail();
      p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));   }
+
            exit (1);
+
    }
    memcpy(Odata->RecordName,
+
    API_Len  = RtvSize->ReturnSiz;
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));
+
    free(RtvSize);
+
 
     if (i EQ NumRecs - 1) {
+
     CreateUserSpace("RTVFDUSPC QTEMP      ",
      EndFlds = 1;
+
                    "USRSPC    ",
      }
+
                    API_Len,
+
                    0,
    ProcessField(&GotIt);
+
                    "*ALL      ",
+
                    " ",
+
                    "*YES     ",
+
                    &errorCode
    }
+
                    );
+
 
}
+
    /*! call RetrievePointerToUserSpace - Retrieve Pointer to User Space */
+
    /*!! (pass: Name and library of user space, pointer variable */
   /* ######################################### */
+
    /*!! return: nothing (pointer variable is left pointing to start*/
+
    /*!! of user space) */
int ProcessField(int *GotIt) {
+
      errorCode.BytesProvided = 0;
+
      RetrievePointerToUserSpace("RTVFDUSPC QTEMP      ",
      int SflCtl;
+
                            &pBuffer,
      int SizeIdx;
+
                            &errorCode);
      int FldIdx;
+
 
      int NumFlds;
+
    QDFRTVFD (pBuffer,
      char ScrnSize[1];
+
                API_Len,
      char Attrib[1];
+
                Format,
      char X01     =  0x01 ;
+
                FileName,
      char Functn[10] = "          ";
+
                &Error_Code);
+
     if ( Error_Code.Bytes_Available != 0 ) {
      /* record header  */
+
            fail();
      p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
+
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
      /*  record dev dept  */
+
            exit (1);
      p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
+
    }
      /*  SFLCTL                                                              */
+
}
      /* 12  C      BIN(31) WDFFRFLG    Miscellaneous record contents.      */
+
 
      /* 12  C  0  BIT(1) WDFFUDDS    If on, USRDFN keyword is specified.  */
+
 
      /* 12  C  1  BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
+
 
      /* 12  C  2  BIT(1) WDFFSFLC    If on, SFLCTL keyword is specified (p*/
+
 
      SflCtl = 0;
+
   /* ######################################### */
      if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
+
int ProcessRec() {
        {  SflCtl = 1;
+
 
     p_QDFFSFCR  = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
+
    int NumRecs;
     p_QDFFSFHR  = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
+
    int i;
        }
+
    int GotIt = 0;
+
    /* Access returned structures. The base structure starts at */
    for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
+
     /* the begining of the returned space. */
     p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
+
    p_QDFFBASE = (QDFFBASE_t *)pBuffer;
                          + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
+
    p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
    *ScrnSize =  p_QDFFSCRA->WDFFSCIA ;
+
    p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
    }
+
    p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
     /* Find RowColumn table. Note: this is the first row/col table */
+
     p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
+
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
+
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
    /* correct QDFFRCTB structure if more than one screen size is */
+
 
    /* used. */
+
     /* here is the place to retreive File Keywords */
      p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);
+
 
+
    NumRecs = p_QDFFBASE->WDFFRCS;
    /********  HERE include code for Record Keywords ********/
+
 
+
    for (i=0; i< NumRecs ; ++i) {
    /* PROCESS THE RECORDS FIELDS    */
+
 
        /* Find where used section */
+
        /* Bump ptr to next record structure */
   
+
      if  (i != 0)
      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
+
    {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
+
       p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));   }
                  + ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
+
 
+
    memcpy(Odata->RecordName,
+
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));
    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {
+
 
+
     if (i EQ NumRecs - 1) {
      /* Field Header  */
+
       EndFlds = 1;
    p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);
+
      }
+
 
     if (p_QDFFFINF->WDFFFIOA EQ 0x01) {
+
     ProcessField(&GotIt);
       /* constant  */
+
 
    p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
+
 
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
+
 
 
     }
 
     }
    else {
+
 
      /* variable */
+
}
    p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
+
 
    p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
+
  /* ######################################### */
    p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
+
 
    }
+
int ProcessField(int *GotIt) {
       /* Field Extension */
+
 
    p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);
+
      int SflCtl;
+
      int SizeIdx;
       /* Row Column */
+
      int FldIdx;
    p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
+
      int NumFlds;
                    + (p_QDFWFLDI->WDFWRRDX - 1) *2);
+
      char ScrnSize[1];
    p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));
+
      char Attrib[1];
+
      char X01    = 0x01 ;
      *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
+
      char Functn[10] = "          ";
      *Odata->COL = p_QDFFRCTE->WDFFSCOL;
+
 
   
+
      NumFlds = 0;
       /*  here can extract data time flags */
+
 
+
       /*  record header  */
       /* CONSTANTS */
+
      p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
    if (p_QDFFFINF->WDFFFIOA EQ 0x01{
+
       /* record dev dept */
      /* constant */
+
      p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
      ProcessCons();
+
      /*  SFLCTL                                                              */
   
+
      /* 12  C      BIN(31) WDFFRFLG    Miscellaneous record contents.      */
    }
+
      /* 12 C  0  BIT(1) WDFFUDDS    If on, USRDFN keyword is specified. */
    else {
+
       /* 12  C  1   BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
        /*  Field Name  */
+
       /* 12 C  2  BIT(1)  WDFFSFLC    If on, SFLCTL keyword is specified (p*/
+
      SflCtl = 0;
      p_QDFFNTB = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
+
      if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
                           + 10 * (p_QDFWFLDI->WDFWNMEI -1) );
+
        { SflCtl = 1;
   
+
    p_QDFFSFCR = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
+
    p_QDFFSFHR = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
      /*Field attribute. */
+
        }
      /*X'01' indicates Constant (see structure QDFFFCON, Constant Field  */
+
 
      /*X'02' indicates Output (O), */
+
    for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
      /*X'03' indicates Message (M), h (B), */
+
    p_QDFFSCRA = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
      /*X'04' indicates Input (I),  (P)  */
+
                           + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
      /*X'05' indicates Both (B), */
+
    *ScrnSize = p_QDFFSCRA->WDFFSCIA ;
      /*X'06' indicates Hidden (H), and */
+
    }
      /*X'07' indicates Program to System (P) */
+
    /* Find RowColumn table. Note: this is the first row/col table */
      *Odata->FldIO     = p_QDFFFINF->WDFFFIOA;
+
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
+
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
      /* Keyboard shift and data type. */
+
    /* correct QDFFRCTB structure if more than one screen size is */
       /* X'00' indicates Alpha shift/character (A), */
+
     /* used. */
+
       p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);
+
 
        *Odata->FldAtr  = p_QDFFFNAM->WDFFKBDT;
+
     /********  HERE include code for Record Keywords ********/
        memcpy(Odata->FldNam,
+
 
              p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
+
    /*  PROCESS THE RECORDS FIELDS    */
        memset(Odata->FldCom,' ',3000);
+
        /* Find where used section */
        Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
+
 
        Odata->FldDec  = p_QDFFFNAM->WDFFDEC;
+
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
     }
+
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
+
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
  /***********  HERE include code for Field KEYWORDS **********/
+
 
       if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
+
 
      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
+
    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
+
 
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
+
      /* Field Header */
      }
+
    p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);
+
 
      NumFlds += 1;
+
    if (p_QDFFFINF->WDFFFIOA EQ 0x01{
+
      /* constant */
      Odata->EndDta  = 0;
+
    p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
+
    p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
  /* End ofthe Fields */
+
    }
      if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
+
     else {
        Odata->EndDta  = 1;
+
      /* variable */
        *GotIt = 1;
+
    p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
        DeleteUserSpace("RTVFDUSPC QTEMP      ",
+
    p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
                        &errorCode);
+
     p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
      };
 
   
 
      /* Return the requested Field */
 
      memmove(Functn,p_iFunc, strlen(p_iFunc));
 
 
        if (!memcmp(Functn , "#FIRST", 6)) {
 
            *GotIt = 1;
 
          };
 
 
        if (*GotIt) {
 
            *GotIt  = 0;
 
            exit(0);
 
          };
 
 
     /* We know we are about to get the NEXT record when we have */
 
    /* found the record just before                            */
 
        if (!memcmp(Functn , "#NEXT"  , 5)) {
 
          if (!memcmp(p_iRecord, Odata->RecordName, sizeof(*p_iRecord))) {
 
            if(!memcmp(p_iField, Odata->FldNam,sizeof(*p_iField) ))      {
 
              if(!memcmp(p_iRow, Odata->ROW, sizeof(*p_iRow) ))          {
 
                if(!memcmp(p_iCol,Odata->COL, sizeof(*p_iCol)))         {
 
          *GotIt = 1;
 
                };
 
              };
 
            };
 
          };
 
        };
 
 
 
 
 
     }
 
     }
   
+
      /* Field Extension */
}
+
    p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);
+
 
  /* ######################################### */
+
      /* Row Column  */
+
    p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
int ProcessCons() {
+
                    + (p_QDFWFLDI->WDFWRRDX - 1) *2);
      /*------------------------------------------------*/
+
    p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));
       /* This loops through all keyword categories      */
+
 
       /*  for a constant field (text on the screen.)   */
+
      *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
       /*------------------------------------------------*/
+
      *Odata->COL  =  p_QDFFRCTE->WDFFSCOL;
+
 
  int cc;
+
       /*   here can extract data time flags */
+
 
    if  (p_QDFFFDPD->WDFFFDOC > 0) {
+
       /* CONSTANTS */
+
    if (p_QDFFFINF->WDFFFIOA EQ 0x01) {
  /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
+
       /* constant  */
  /* p_QDFFRINF = p_QDFFINFO + QDFARFTE.WDFARFOF */
+
      ProcessCons();
+
 
        p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
+
    }
                                                p_QDFFFDPD->WDFFFDOC);
+
    else {
       cc = 0;
+
        /*   Field Name  */
      for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {
+
 
   
+
      p_QDFFNTB  = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
          p_QDFFCCOA  = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
+
                          +  10 * (p_QDFWFLDI->WDFWNMEI -1) );
                            sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);
+
 
+
 
+
      /*Field attribute.  */
          if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
+
      /*X'01' indicates Constant (see structure QDFFFCON, Constant Field */
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF  +
+
      /*X'02' indicates Output (O), */
                                                p_QDFFCCOA->WDFFCAOF);
+
      /*X'03' indicates Message (M), h (B), */
              ProcessCat22();
+
      /*X'04' indicates Input (I)(P)  */
            }
+
      /*X'05' indicates Both (B), */
+
      /*X'06' indicates Hidden (H), and */
   
+
      /*X'07' indicates Program to System (P) */
          if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
+
       *Odata->FldIO    = p_QDFFFINF->WDFFFIOA;
              p_QDFKDFT  = (QDFKDFT_t *)((char *) p_QDFFFINF  +
+
 
                                                p_QDFFCCOA->WDFFCAOF);
+
      /* Keyboard shift and data type. */
              ProcessCat23();
+
      /* X'00' indicates Alpha shift/character (A), */
            }
+
 
+
 
+
        *Odata->FldAtr  = p_QDFFFNAM->WDFFKBDT;
          if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
+
        memcpy(Odata->FldNam,
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
+
              p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
                                                p_QDFFCCOA->WDFFCAOF);
+
        memset(Odata->FldCom,' ',3000);
              ProcessCat24();
+
        Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
            }
+
        Odata->FldDec  = p_QDFFFNAM->WDFFDEC;
+
    }
 +
 
 +
  /*********** HERE include code for Field KEYWORDS **********/
 +
      if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
 +
      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
 +
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
 +
                  +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
 
       }
 
       }
   
+
 
+
      NumFlds += 1;
+
 
+
      Odata->NumFld  = NumFlds;
     }
+
      Odata->EndDta  = 0;
+
 
+
  /* End ofthe Fields */
}
+
      if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
+
        Odata->EndDta  = 1;
  /* ######################################### */
+
        *GotIt = 1;
+
        DeleteUserSpace("RTVFDUSPC QTEMP     ",
int ProcessCat22() {
+
                        &errorCode);
      /*-----------------------------------------------*/
+
      };
      /* This loops through all keywords that fall into*/
+
 
      /* category 22                                  */
+
      /* Return the requested Field  */
       /*-----------------------------------------------*/
+
      memmove(Functn,p_iFunc, strlen(p_iFunc));
}
+
 
   
+
        if (!memcmp(Functn , "#FIRST", 6)) {
   /* ######################################### */
+
            *GotIt = 1;
+
          };
int ProcessCat23() {
+
 
 +
        if (*GotIt)  {
 +
            *GotIt  = 0;
 +
            exit(0);
 +
          };
 +
 
 +
    /* We know we are about to get the NEXT record when we have */
 +
    /* found the record just before                            */
 +
       if (!memcmp(Functn , "#NEXT" , 5) &&
 +
      !memcmp(p_iRecord, Odata->RecordName, 10) &&
 +
      !memcmp(p_iField, Odata->FldNam, 10 ) &&
 +
        (*p_iNumFld  EQ  NumFlds))
 +
      *GotIt = 1;
 +
 
 +
 
 +
 
 +
 
 +
    }
 +
 
 +
  }
 +
 
 +
   /* ######################################### */
 +
 
 +
int ProcessCons() {
 
       /*------------------------------------------------*/
 
       /*------------------------------------------------*/
       /* This loops through all keywords that fall into */
+
       /* This loops through all keyword categories      */
       /*  category 23 (DFT, MSGCON, DFTVAL, HTML)       */
+
       /*  for a constant field (text on the screen.)   */
 
       /*------------------------------------------------*/
 
       /*------------------------------------------------*/
typedef _Packed struct  KwdData {
+
 
    char Temp[3000];
+
  int cc;
} KwdData_t;
+
 
+
    if  (p_QDFFFDPD->WDFFFDOC > 0) {
  KwdData_t  *p_KwdData;
+
 
  int       ck;
+
  /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
+
  /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */
  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {
+
 
+
        p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
    if  (ck EQ 1 ) {
+
                                                p_QDFFFDPD->WDFFFDOC);
    p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t)); }
+
       cc = 0;
    else
+
      for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t)); }
+
 
+
          p_QDFFCCOA = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
        if (p_QDFKDFPM->WDFKDFID EQ 0x01) {
+
                            sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);
   
+
 
        memcpy(Odata->FldNam,"          ",10);
+
 
+
          if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
        Odata->FldPlen  = p_QDFKDFPM->WDFKDFLN;
+
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF +
        *Odata->FldIO  = p_QDFFFINF->WDFFFIOA;
+
                                                p_QDFFCCOA->WDFFCAOF);
  p_KwdData = (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
+
              ProcessCat22();
        memcpy(Odata->FldCom,
+
            }
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
+
 
+
 
        }
+
          if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
+
              p_QDFKDFT = (QDFKDFT_t *)((char *) p_QDFFFINF  +
    }
+
                                                p_QDFFCCOA->WDFFCAOF);
+
              ProcessCat23();
   
+
            }
}
+
 
+
 
   /* ######################################### */
+
          if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
+
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
int ProcessCat24() {
+
                                                p_QDFFCCOA->WDFFCAOF);
 +
              ProcessCat24();
 +
            }
 +
 
 +
      }
 +
 
 +
 
 +
 
 +
 
 +
    }
 +
 
 +
 
 +
  }
 +
 
 +
   /* ######################################### */
 +
 
 +
int ProcessCat22() {
 
       /*-----------------------------------------------*/
 
       /*-----------------------------------------------*/
 
       /* This loops through all keywords that fall into*/
 
       /* This loops through all keywords that fall into*/
       /*  category 24  (Date, Time)                    */
+
       /*  category 22                                  */
 
       /*-----------------------------------------------*/
 
       /*-----------------------------------------------*/
 
}
 
}
 
 
 
 
RTVFLD1
 
    h Option(*NODEBUGIO)  DFTACTGRP(*NO)
 
 
    D RTVFLD1        PR
 
    D                              10A
 
    D                              10A
 
 
    D RTVFLD1        PI
 
    D iLib                          10A
 
    D iFile                        10A
 
 
    D DISPINFOC1      PR                  ExtPgm('DISPINFOC1')
 
    D Lib                          10A  const
 
    D File                          10A  const
 
    D oRecord                      10A  const
 
    D oField                        10A  const
 
    D oRow                          1A  const
 
    D oCol                          1A  const
 
    D Func                          10A  const
 
    D Fdata                              like(RTVDATA)
 
          // returned data
 
    D RTVDATA        DS
 
    D RecordName                    10A
 
    D ROW                            1A
 
    D COL                            1A
 
    D FldIO                          1A
 
    D FldAtr                        1A
 
    D FldNam                        10A
 
    D FldCom                      3000A
 
    D FLdPlen                      10I 0
 
    D FldDec                        10I 0
 
    D EndDta                        10I 0
 
 
    D oRecordName                  10A
 
    D oFldNam                      10A
 
    D oRow                          1A
 
    D oCol                          1A
 
 
      /free
 
 
          *INLR = *ON;
 
 
          DISPINFOC1( iLib  : iFile    : '  ': '  ' : '  ': '  ':
 
                    '#FIRST' : RTVDATA  );
 
 
        DOW (EndDta = 0);
 
 
                    oRecordName  =    RecordName ;
 
                    oFldNam      =    FldNam    ;
 
                    oROW        =    ROW        ;
 
                    oCOL        =    COL        ;
 
 
      // To get the next record the previous fields info is also passed
 
          DISPINFOC1(iLib  :  iFile    :
 
                    oRecordName  :
 
                    oFldNam      :
 
                    oROW        :
 
                    oCOL        :
 
                    '#NEXT ' : RTVDATA  );
 
 
        ENDDO;
 
 
      /end-free
 
 
 
 
 
  
 +
  /* ######################################### */
 +
 +
int ProcessCat23() {
 +
      /*------------------------------------------------*/
 +
      /* This loops through all keywords that fall into */
 +
      /*  category 23 (DFT, MSGCON, DFTVAL, HTML)      */
 +
      /*------------------------------------------------*/
 +
typedef _Packed struct  KwdData {
 +
    char Temp[3000];
 +
} KwdData_t;
 +
 +
  KwdData_t  *p_KwdData;
 +
  int        ck;
 +
 +
  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {
 +
 +
    if  (ck EQ 1 )  {
 +
    p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
 +
    else
 +
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM  + sizeof(QDFKDFPM_t)); }
 +
 +
        if (p_QDFKDFPM->WDFKDFID EQ 0x01)  {
 +
 +
        memcpy(Odata->FldNam,"          ",10);
 +
 +
        Odata->FldPlen  = p_QDFKDFPM->WDFKDFLN;
 +
        *Odata->FldIO  = p_QDFFFINF->WDFFFIOA;
 +
  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
 +
        memset(Odata->FldCom, ' ',3000);
 +
        memcpy(Odata->FldCom,
 +
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
 +
 +
        }
 +
 +
    }
  
  
</pre>
+
}
  
 +
  /* ######################################### */
  
===DISPINFOC2 Version with C Module ===
+
int ProcessCat24() {
 +
      /*-----------------------------------------------*/
 +
      /* This loops through all keywords that fall into*/
 +
      /* category 24  (Date, Time)                    */
 +
      /*-----------------------------------------------*/
 +
        memcpy(Odata->FldNam,"          ",10);
 +
        memset(Odata->FldCom, ' ',3000);
 +
}
  
I needed to drive this fron a CLLE (code is below) because I need a RCLACTGRP DISPINFO2.
 
  
Reason is I did a return from the C module, rathen than an exit.
+
RTVFLD1
  
 +
    h Option(*NODEBUGIO)  DFTACTGRP(*NO)
 +
 +
    D RTVFLD1        PR
 +
    D                              10A
 +
    D                              10A
 +
 +
    D RTVFLD1        PI
 +
    D iLib                          10A
 +
    D iFile                        10A
 +
 +
    D DISPINFOC1      PR                  ExtPgm('DISPINFOC1')
 +
    D Lib                          10A  const
 +
    D File                          10A  const
 +
    D oRecord                      10A  const
 +
    D oField                        10A  const
 +
    D oFld                          10I 0 const
 +
    D Func                          10A  const
 +
    D Fdata                              like(RTVDATA)
 +
          // returned data
 +
    D RTVDATA        DS
 +
    D RecordName                    10A
 +
    D ROW                            1A
 +
    D COL                            1A
 +
    D FldIO                          1A
 +
    D FldAtr                        1A
 +
    D FldNam                        10A
 +
    D FldCom                      3000A
 +
    D FLdPlen                      10I 0
 +
    D FldDec                        10I 0
 +
    D EndDta                        10I 0
 +
    D NumFld                        10I 0
 +
 +
    D oRecordName    S            10A
 +
    D oFldNam        S            10A
 +
    D oFld            S            10I 0
 +
 +
      /free
 +
 +
          *INLR = *ON;
 +
 +
          DISPINFOC1( iLib  : iFile    : '  ': '  ' : 0 :
 +
                    '#FIRST' : RTVDATA  );
 +
 +
        DOW (EndDta = 0);
 +
 +
                    oRecordName  =    RecordName ;
 +
                    oFldNam      =    FldNam    ;
 +
                    oFld        =    NumFld    ;
 +
 +
      // To get the next record the previous fields info is also passed
 +
          DISPINFOC1(iLib  :  iFile    :
 +
                    oRecordName  :
 +
                    oFldNam      :
 +
                    oFld        :
 +
                    '#NEXT ' : RTVDATA  );
 +
 +
        ENDDO;
 +
 +
      /end-free
  
<pre>
 
  
DISPINFOC2
 
 
/* Function: This module  uses the QDFRTVFD API to return the */
 
/* structure of a display file.  */
 
 
/* CRTCMOD MODULE(urlib/DISPINFOC2) SRCFILE(urlib/C) SRCMBR(DISPINFOC2) */
 
/*        REPLACE(*yes)                                                */
 
 
/* bind into your program with                                          */
 
/* CRTPGM PGM(urlib/RTVFLD2)                                        */
 
/*      MODULE(urlib/RTVFLD2 urlib/DISPINFOC2)                  */
 
/*      ACTGRP(DISPINFO2)                                              */
 
 
 
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
#include "QSYSINC/H/QUSEC"
 
#include "QSYSINC/H/QDFRTVFD"
 
 
 
 
#define EQ      ==
 
 
#define fail() do { printf("\nLine %d FAILED in file %s", \
 
__LINE__,__FILE__); \
 
} while(0)
 
 
/* Pointers to structures required to be used by this program. */
 
QDFFBASE_t *p_QDFFBASE;
 
QDFFINFO_t *p_QDFFINFO;
 
QDFARFTE_t *p_QDFARFTE;
 
QDFFRINF_t *p_QDFFRINF;
 
QDFFDPDD_t *p_QDFFDPDD;
 
QDFFRDPD_t *p_QDFFRDPD;
 
QDFWFLEI_t *p_QDFWFLEI;
 
QDFFNTBL_t *p_QDFFNTBL;
 
QDFWRCDI_t *p_QDFWRCDI;
 
QDFWFLDI_t *p_QDFWFLDI;
 
QDFFSFCR_t *p_QDFFSFCR;
 
QDFFSFHR_t *p_QDFFSFHR;
 
QDFFSCRA_t *p_QDFFSCRA;
 
QDFFFITB_t *p_QDFFFITB;
 
QDFFFINF_t *p_QDFFFINF;
 
QDFFFCON_t *p_QDFFFCON;
 
QDFFFDPD_t *p_QDFFFDPD;
 
QDFFFNAM_t *p_QDFFFNAM;
 
QDFFFDIC_t *p_QDFFFDIC;
 
QDFFXFDP_t *p_QDFFXFDP;
 
QDFFRCTB_t *p_QDFFRCTB;
 
QDFFRCTE_t *p_QDFFRCTE;
 
QDFFNTB_t  *p_QDFFNTB;
 
QDFFCOSA_t *p_QDFFCOSA;
 
QDFFCCOA_t *p_QDFFCCOA;
 
QDFKMFDK_t *p_QDFKMFDK;
 
QDFKDFT_t  *p_QDFKDFT;
 
QDFKEDTR_t *p_QDFKEDTR;
 
QDFKDFPM_t *p_QDFKDFPM;
 
 
 
    /* Global variables */
 
    char *p_iLib;
 
    char *p_iFile;
 
    char *p_iRecord;
 
    char *p_iField;
 
    char *p_iRow;
 
    char *p_iCol;
 
    char *p_iFunc;
 
 
/* returned data  */
 
typedef struct FieldData {
 
    char RecordName[10];
 
    char ROW[1];
 
    char COL[1];
 
    char FldIO[1];
 
    char FldAtr[1];
 
    char FldNam[10];
 
    char FldCom[3000];
 
    int  FldPlen;
 
    int  FldDec;
 
    int  EndDta;
 
  } FieldData_t;
 
 
   
 
   
FieldData_t *p_FieldData;
+
 
FieldData_t *Odata;
+
</pre>
+
 
+
[[#top]]
    int RtvApiDta (void);
+
 
    int ProcessRec (void);
+
===DISPINFOC2 Version with C Module ===
    int ProcessField (int *);
+
 
    int ProcessCons(void);
+
I needed to drive this fron a CLLE (code is below) because I need a RCLACTGRP DISPINFO2.
    int ProcessCat22(void);
+
 
    int ProcessCat23(void);
+
Reason is I did a return from the C module, rather than an exit.
    int ProcessCat24(void);
+
 
+
 
    int RecIndex;
+
<pre>
+
 
+
DISPINFOC2
    char *ReturnVar;
 
 
 
 
    char FileName[20] = "                    ";
 
    char Format[8];
 
    int  EndFlds = 0;
 
 
    /* 4 bytes WDFFRETN Length of the returned data. */
 
    /* 4 bytes WDFFSIZE Size of the display file description */
 
    typedef struct RtvSizeInfo
 
    {
 
        int ReturnLen;
 
        int ReturnSiz;
 
    } RtvSizeInfo_t;
 
 
 
 
  /* ########################################################  */
 
int DISPINFOC2
 
  (  char *p_pLib  ,
 
      char *p_pFile ,
 
      char *p_pRecord ,
 
      char *p_pField ,
 
      char *p_pRow ,
 
      char *p_pCol ,
 
      char *p_pFunc ,
 
    FieldData_t *pOdata)
 
{
 
 
      char Funct[10] = "          ";
 
 
    p_iLib    = p_pLib;
 
    p_iFile  = p_pFile;
 
    p_iRecord = p_pRecord;
 
    p_iField = p_pField;
 
    p_iRow    = p_pRow;
 
    p_iCol    = p_pCol;
 
    p_iFunc  = p_pFunc;
 
    Odata    =  pOdata;
 
 
 
      /* On First pass get the API data */
 
      memmove(Funct,p_iFunc, strlen(p_iFunc));
 
        if (!memcmp(Funct, "#FIRST", 6)) {
 
            RtvApiDta();
 
            };
 
 
 
    ProcessRec();
 
 
}
 
 
 
 
 
  /* ######################################### */
 
 
    RtvApiDta() {
 
 
    RtvSizeInfo_t *RtvSize;
 
    int  API_Len;
 
 
    Qus_EC_t Error_Code = {0};
 
 
 
    /* Define the API format requested and the display file to access */
 
    memcpy(Format,"DSPF0100",8);
 
    /* Point to your DSPF */
 
    memmove(FileName,p_iFile, strlen(p_iFile));
 
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));
 
 
    /* Invoke the API. to get the size needed */
 
    RtvSize =  malloc(8);
 
    QDFRTVFD (RtvSize,
 
                8,
 
                Format,
 
                FileName,
 
                &Error_Code);
 
    if ( Error_Code.Bytes_Available != 0 ) {
 
            fail();
 
            exit (1);
 
    }
 
    API_Len  =  RtvSize->ReturnSiz;
 
    free(RtvSize);
 
 
    ReturnVar =  malloc(API_Len);
 
    QDFRTVFD (ReturnVar,
 
                API_Len,
 
                Format,
 
                FileName,
 
                &Error_Code);
 
    if ( Error_Code.Bytes_Available != 0 ) {
 
            fail();
 
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
 
            exit (1);
 
    }
 
}
 
 
 
 
 
  /* ######################################### */
 
int ProcessRec() {
 
 
    int  NumRecs;
 
    int i;
 
    int GotIt = 0;
 
    /* Access returned structures. The base structure starts at */
 
    /* the begining of the returned space. */
 
    p_QDFFBASE = (QDFFBASE_t *)ReturnVar;
 
    p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
 
    p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
 
    p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
 
    p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
 
    p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
 
    p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
 
 
    /*  here is the place to retreive File Keywords */
 
 
    NumRecs = p_QDFFBASE->WDFFRCS;
 
 
    for (i=0; i< NumRecs ; ++i) {
 
 
        /* Bump ptr to next record structure */
 
      if  (i  != 0)
 
    {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
 
      p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));  }
 
 
    memcpy(Odata->RecordName,
 
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));
 
 
    if  (i EQ NumRecs - 1) {
 
      EndFlds = 1;
 
      }
 
 
    ProcessField(&GotIt);
 
 
        if (GotIt EQ 1)  {
 
            return(0);
 
          };
 
 
 
    }
 
 
}
 
 
   
 
   
 +
 +
/* Function: This module  uses the QDFRTVFD API to return the */
 +
/* structure of a display file.  */
 +
 +
/* CRTCMOD MODULE(urlib/DISPINFOC2) SRCFILE(urlib/C) SRCMBR(DISPINFOC2) */
 +
/*        REPLACE(*yes)                                                */
 +
 +
/* bind into your program with                                          */
 +
/* CRTPGM PGM(urlib/RTVFLD2)                                        */
 +
/*      MODULE(urlib/RTVFLD2 urlib/DISPINFOC2)                  */
 +
/*      ACTGRP(DISPINFO2)                                              */
 +
 +
 +
 +
#include <stdio.h>
 +
#include <stdlib.h>
 +
#include <string.h>
 +
#include "QSYSINC/H/QUSEC"
 +
#include "QSYSINC/H/QDFRTVFD"
 +
 +
 +
 +
#define EQ      ==
 +
 +
#define fail() do { printf("\nLine %d FAILED in file %s", \
 +
__LINE__,__FILE__); \
 +
} while(0)
 +
 +
/* Pointers to structures required to be used by this program. */
 +
QDFFBASE_t *p_QDFFBASE;
 +
QDFFINFO_t *p_QDFFINFO;
 +
QDFARFTE_t *p_QDFARFTE;
 +
QDFFRINF_t *p_QDFFRINF;
 +
QDFFDPDD_t *p_QDFFDPDD;
 +
QDFFRDPD_t *p_QDFFRDPD;
 +
QDFWFLEI_t *p_QDFWFLEI;
 +
QDFFNTBL_t *p_QDFFNTBL;
 +
QDFWRCDI_t *p_QDFWRCDI;
 +
QDFWFLDI_t *p_QDFWFLDI;
 +
QDFFSFCR_t *p_QDFFSFCR;
 +
QDFFSFHR_t *p_QDFFSFHR;
 +
QDFFSCRA_t *p_QDFFSCRA;
 +
QDFFFITB_t *p_QDFFFITB;
 +
QDFFFINF_t *p_QDFFFINF;
 +
QDFFFCON_t *p_QDFFFCON;
 +
QDFFFDPD_t *p_QDFFFDPD;
 +
QDFFFNAM_t *p_QDFFFNAM;
 +
QDFFFDIC_t *p_QDFFFDIC;
 +
QDFFXFDP_t *p_QDFFXFDP;
 +
QDFFRCTB_t *p_QDFFRCTB;
 +
QDFFRCTE_t *p_QDFFRCTE;
 +
QDFFNTB_t  *p_QDFFNTB;
 +
QDFFCOSA_t *p_QDFFCOSA;
 +
QDFFCCOA_t *p_QDFFCCOA;
 +
QDFKMFDK_t *p_QDFKMFDK;
 +
QDFKDFT_t  *p_QDFKDFT;
 +
QDFKEDTR_t *p_QDFKEDTR;
 +
QDFKDFPM_t *p_QDFKDFPM;
 +
 +
 +
    /* Global variables */
 +
    char *p_iLib;
 +
    char *p_iFile;
 +
    char *p_iRecord;
 +
    char *p_iField;
 +
    int  *p_iFld;
 +
    char *p_iFunc;
 +
 +
/* returned data  */
 +
typedef struct FieldData {
 +
    char RecordName[10];
 +
    char ROW[1];
 +
    char COL[1];
 +
    char FldIO[1];
 +
    char FldAtr[1];
 +
    char FldNam[10];
 +
    char FldCom[3000];
 +
    int  FldPlen;
 +
    int  FldDec;
 +
    int  EndDta;
 +
    int  NumFld;
 +
  } FieldData_t;
 +
 +
FieldData_t *p_FieldData;
 +
FieldData_t *Odata;
 +
 +
 +
    int RtvApiDta (void);
 +
    int ProcessRec (void);
 +
    int ProcessField (int *);
 +
    int ProcessCons(void);
 +
    int ProcessCat22(void);
 +
    int ProcessCat23(void);
 +
    int ProcessCat24(void);
 +
 +
    int RecIndex;
 +
 +
 +
    char *ReturnVar;
 +
 +
 +
 +
    char FileName[20] = "                    ";
 +
    char Format[8];
 +
    int  EndFlds = 0;
 +
 +
    /* 4 bytes WDFFRETN Length of the returned data. */
 +
    /* 4 bytes WDFFSIZE Size of the display file description */
 +
    typedef struct RtvSizeInfo
 +
    {
 +
        int ReturnLen;
 +
        int ReturnSiz;
 +
    } RtvSizeInfo_t;
 +
 +
 +
 +
  /* ########################################################  */
 +
int DISPINFOC2
 +
  (  char *p_pLib  ,
 +
      char *p_pFile ,
 +
      char *p_pRecord ,
 +
      char *p_pField ,
 +
      int  *p_pFld ,
 +
      char *p_pFunc ,
 +
    FieldData_t *pOdata)
 +
{
 +
 +
      char Funct[10] = "          ";
 +
 +
    p_iLib    = p_pLib;
 +
    p_iFile  = p_pFile;
 +
    p_iRecord = p_pRecord;
 +
    p_iField  = p_pField;
 +
    p_iFld    = p_pFld;
 +
    p_iFunc  = p_pFunc;
 +
    Odata    =  pOdata;
 +
 +
 +
      /* On First pass get the API data */
 +
      memmove(Funct,p_iFunc, strlen(p_iFunc));
 +
        if (!memcmp(Funct, "#FIRST", 6)) {
 +
            RtvApiDta();
 +
            };
 +
 +
 +
    ProcessRec();
 +
 +
}
 +
 +
 +
 +
 
   /* ######################################### */
 
   /* ######################################### */
+
 
int ProcessField(int *GotIt) {
+
    RtvApiDta() {
+
 
      int SflCtl;
+
    RtvSizeInfo_t *RtvSize;
      int SizeIdx;
+
    int API_Len;
      int FldIdx;
+
 
      int NumFlds;
+
     Qus_EC_t Error_Code = {0};
      char ScrnSize[1];
+
 
      char Attrib[1];
+
 
      char X01     = 0x01 ;
+
    /* Define the API format requested and the display file to access */
      char Functn[10] = "          ";
+
    memcpy(Format,"DSPF0100",8);
+
    /* Point to your DSPF */
      /* record header  */
+
    memmove(FileName,p_iFile, strlen(p_iFile));
      p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
+
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));
      /* record dev dept  */
+
 
      p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
+
    /* Invoke the API. to get the size needed */
      /* SFLCTL                                                              */
+
    RtvSize = malloc(8);
      /* 12 C      BIN(31) WDFFRFLG    Miscellaneous record contents.      */
+
    QDFRTVFD (RtvSize,
      /* 12  C  0  BIT(1)  WDFFUDDS    If on, USRDFN keyword is specified.  */
+
                8,
      /* 12  C  1  BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
+
                Format,
      /* 12  C  2  BIT(1)  WDFFSFLC    If on, SFLCTL keyword is specified (p*/
+
                FileName,
      SflCtl = 0;
+
                &Error_Code);
      if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
+
    if ( Error_Code.Bytes_Available != 0 ) {
        {  SflCtl = 1;
+
            fail();
    p_QDFFSFCR = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
+
            exit (1);
    p_QDFFSFHR = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
+
    }
        }
+
    API_Len = RtvSize->ReturnSiz;
+
    free(RtvSize);
    for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
+
 
    p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
+
    ReturnVar = malloc(API_Len);
                          + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
+
    QDFRTVFD (ReturnVar,
     *ScrnSize =  p_QDFFSCRA->WDFFSCIA ;
+
                API_Len,
    }
+
                Format,
    /* Find RowColumn table. Note: this is the first row/col table */
+
                FileName,
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
+
                &Error_Code);
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
+
    if ( Error_Code.Bytes_Available != 0 ) {
    /* correct QDFFRCTB structure if more than one screen size is */
+
            fail();
    /* used. */
+
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
      p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);
+
            exit (1);
   
+
     }
     /********  HERE include code for Record Keywords ********/
+
}
+
 
     /* PROCESS THE RECORDS FIELDS    */
+
 
        /* Find where used section */
+
 
+
 
      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
+
  /* ######################################### */
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
+
int ProcessRec() {
                  +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
+
 
+
    int NumRecs;
+
     int i;
    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {
+
    int GotIt = 0;
+
     /* Access returned structures. The base structure starts at */
      /* Field Header  */
+
    /* the begining of the returned space. */
     p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);
+
    p_QDFFBASE = (QDFFBASE_t *)ReturnVar;
+
    p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
+
     p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
      /* constant  */
+
     p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
     p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
+
     p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
+
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
    }
+
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
    else {
+
 
      /*  variable */
+
     /*  here is the place to retreive File Keywords */
     p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
+
 
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
+
     NumRecs = p_QDFFBASE->WDFFRCS;
    p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
+
 
     }
+
    for (i=0; i< NumRecs ; ++i) {
      /* Field Extension */
+
 
     p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);
+
        /* Bump ptr to next record structure */
+
      if  (i  != 0)
      /* Row Column  */
+
     {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
     p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
+
      p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));   }
                    + (p_QDFWFLDI->WDFWRRDX - 1) *2);
+
 
    p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));
+
    memcpy(Odata->RecordName,
+
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));
      *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
+
 
      *Odata->COL  =  p_QDFFRCTE->WDFFSCOL;
+
    if (i EQ NumRecs - 1) {
   
+
      EndFlds = 1;
       /*  here can extract data time flags */
+
       }
+
 
      /* CONSTANTS  */
+
    ProcessField(&GotIt);
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
+
 
      /* constant  */
+
        if (GotIt EQ 1)  {
      ProcessCons();
+
            return(0);
+
          };
 +
 
 +
 
 
     }
 
     }
     else {
+
 
         /*  Field Name  */
+
}
+
 
       p_QDFFNTB  = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
+
  /* ######################################### */
                           +  10 * (p_QDFWFLDI->WDFWNMEI -1) );
+
 
+
int ProcessField(int *GotIt) {
+
 
       /*Field attribute.  */
+
      int SflCtl;
       /*X'01' indicates Constant (see structure QDFFFCON, Constant Field  */
+
      int SizeIdx;
       /*X'02' indicates Output (O), */
+
      int FldIdx;
       /*X'03' indicates Message (M), h (B), */
+
      int NumFlds;
       /*X'04' indicates Input (I),  (P)  */
+
      char ScrnSize[1];
       /*X'05' indicates Both (B), */
+
      char Attrib[1];
       /*X'06' indicates Hidden (H), and */
+
      char X01    =  0x01 ;
       /*X'07' indicates Program to System (P) */
+
      char Functn[10] = "          ";
       *Odata->FldIO    = p_QDFFFINF->WDFFFIOA;
+
 
+
      NumFlds = 0;
       /* Keyboard shift and data type.  */
+
 
       /* X'00' indicates Alpha shift/character (A), */
+
      /*  record header  */
+
      p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
+
      /*  record dev dept  */
         *Odata->FldAtr  = p_QDFFFNAM->WDFFKBDT;
+
      p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
         memcpy(Odata->FldNam,
+
      /*  SFLCTL                                                              */
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
+
      /* 12  C      BIN(31) WDFFRFLG    Miscellaneous record contents.      */
         memset(Odata->FldCom, ' ',3000);
+
      /* 12  C  0  BIT(1)  WDFFUDDS    If on, USRDFN keyword is specified.  */
         Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
+
      /* 12  C  1  BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
         Odata->FldDec  = p_QDFFFNAM->WDFFDEC;
+
      /* 12  C  2  BIT(1)  WDFFSFLC    If on, SFLCTL keyword is specified (p*/
     }
+
      SflCtl = 0;
+
      if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
   /***********  HERE include code for Field KEYWORDS **********/
+
        {  SflCtl = 1;
       if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
+
    p_QDFFSFCR  = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
+
    p_QDFFSFHR  = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
+
        }
 +
 
 +
    for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
 +
    p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
 +
                          + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
 +
    *ScrnSize =  p_QDFFSCRA->WDFFSCIA ;
 +
    }
 +
    /* Find RowColumn table. Note: this is the first row/col table */
 +
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
 +
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
 +
    /* correct QDFFRCTB structure if more than one screen size is */
 +
    /* used. */
 +
      p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);
 +
 
 +
    /********  HERE include code for Record Keywords ********/
 +
 
 +
    /*  PROCESS THE RECORDS FIELDS    */
 +
        /* Find where used section */
 +
 
 +
      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
 +
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
 +
                  +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
 +
 
 +
 
 +
    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {
 +
 
 +
      /* Field Header  */
 +
    p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);
 +
 
 +
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
 +
      /* constant  */
 +
    p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
 +
    p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
 +
    }
 +
    else {
 +
      /*  variable */
 +
    p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
 +
    p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
 +
    p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
 +
    }
 +
      /* Field Extension  */
 +
    p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);
 +
 
 +
      /* Row Column  */
 +
    p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
 +
                    + (p_QDFWFLDI->WDFWRRDX - 1) *2);
 +
    p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));
 +
 
 +
      *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
 +
      *Odata->COL  =  p_QDFFRCTE->WDFFSCOL;
 +
 
 +
      /*  here can extract data time flags */
 +
 
 +
      /* CONSTANTS  */
 +
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
 +
      /* constant  */
 +
      ProcessCons();
 +
 
 +
    }
 +
     else {
 +
         /*  Field Name  */
 +
 
 +
       p_QDFFNTB  = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
 +
                           +  10 * (p_QDFWFLDI->WDFWNMEI -1) );
 +
 
 +
 
 +
       /*Field attribute.  */
 +
       /*X'01' indicates Constant (see structure QDFFFCON, Constant Field  */
 +
       /*X'02' indicates Output (O), */
 +
       /*X'03' indicates Message (M), h (B), */
 +
       /*X'04' indicates Input (I),  (P)  */
 +
       /*X'05' indicates Both (B), */
 +
       /*X'06' indicates Hidden (H), and */
 +
       /*X'07' indicates Program to System (P) */
 +
       *Odata->FldIO    = p_QDFFFINF->WDFFFIOA;
 +
 
 +
       /* Keyboard shift and data type.  */
 +
       /* X'00' indicates Alpha shift/character (A), */
 +
 
 +
 
 +
         *Odata->FldAtr  = p_QDFFFNAM->WDFFKBDT;
 +
         memcpy(Odata->FldNam,
 +
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
 +
         memset(Odata->FldCom, ' ',3000);
 +
         Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
 +
         Odata->FldDec  = p_QDFFFNAM->WDFFDEC;
 +
     }
 +
 
 +
   /***********  HERE include code for Field KEYWORDS **********/
 +
       if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
 +
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
 +
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
 
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
 
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
 
       }
 
       }
+
 
       NumFlds += 1;
+
       NumFlds += 1;
+
 
       Odata->EndDta  = 0;
+
      Odata->NumFld  = NumFlds;
+
       Odata->EndDta  = 0;
   /* End ofthe Fields  */
+
 
       if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
+
   /* End ofthe Fields  */
         Odata->EndDta  = 1;
+
       if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
        *GotIt = 2;
+
         Odata->EndDta  = 1;
         free(ReturnVar);
+
        *GotIt = 2;
       };
+
         free(ReturnVar);
+
       };
       /* Return the requested Field  */
+
 
       memmove(Functn,p_iFunc, strlen(p_iFunc));
+
       /* Return the requested Field  */
+
       memmove(Functn,p_iFunc, strlen(p_iFunc));
         if ( (!memcmp(Functn , "#FIRST", 6)) || (*GotIt EQ 2))  {
+
 
             *GotIt = 1;
+
         if ( (!memcmp(Functn , "#FIRST", 6)) || (*GotIt EQ 2))  {
             return(0);
+
             *GotIt = 1;
           };
+
             return(0);
+
           };
+
 
     /* We know we are about to get the NEXT record when we have */
+
 
     /* found the record just before                            */
+
     /* We know we are about to get the NEXT record when we have */
        if (!memcmp(Functn , "#NEXT" , 5)) {
+
     /* found the record just before                            */
          if (!memcmp(p_iRecord, Odata->RecordName, sizeof(*p_iRecord))) {
+
      if (!memcmp(Functn , "#NEXT" , 5) &&
            if(!memcmp(p_iField, Odata->FldNam,sizeof(*p_iField) ))      {
+
      !memcmp(p_iRecord, Odata->RecordName, 10) &&
              if(!memcmp(p_iRow, Odata->ROW, sizeof(*p_iRow) ))          {
+
      !memcmp(p_iField, Odata->FldNam, 10 ) &&
                if(!memcmp(p_iCol,Odata->COL, sizeof(*p_iCol)))          {
+
         (*p_iFld EQ NumFlds))
          *GotIt = 2;
+
       *GotIt = 2;
                };
+
 
              };
+
 
            };
+
 
          };
+
    }
         };
+
 
+
  }
+
 
 
    }
 
 
}
 
 
  /* ######################################### */
 
 
int ProcessCons() {
 
      /*------------------------------------------------*/
 
      /* This loops through all keyword categories      */
 
      /for a constant field (text on the screen.)    */
 
      /*------------------------------------------------*/
 
   
 
  int cc;
 
 
    if  (p_QDFFFDPD->WDFFFDOC > 0) {
 
 
  /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
 
  /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */
 
 
        p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
 
                                                p_QDFFFDPD->WDFFFDOC);
 
      cc = 0;
 
       for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {
 
 
          p_QDFFCCOA  = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
 
                            sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);
 
 
 
          if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
 
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF  +
 
                                                p_QDFFCCOA->WDFFCAOF);
 
              ProcessCat22();
 
            }
 
 
 
          if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
 
              p_QDFKDFT  = (QDFKDFT_t *)((char *) p_QDFFFINF  +
 
                                                p_QDFFCCOA->WDFFCAOF);
 
              ProcessCat23();
 
            }
 
 
   
 
          if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
 
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
 
                                                p_QDFFCCOA->WDFFCAOF);
 
              ProcessCat24();
 
            }
 
 
      }
 
 
 
 
 
    }
 
 
 
}
 
 
  /* ######################################### */
 
 
int ProcessCat22() {
 
      /*-----------------------------------------------*/
 
      /* This loops through all keywords that fall into*/
 
      /*  category 22                                  */
 
      /*-----------------------------------------------*/
 
}
 
 
 
   /* ######################################### */
 
   /* ######################################### */
+
 
int ProcessCat23() {
+
int ProcessCons() {
 
       /*------------------------------------------------*/
 
       /*------------------------------------------------*/
       /* This loops through all keywords that fall into */
+
       /* This loops through all keyword categories      */
       /*  category 23 (DFT, MSGCON, DFTVAL, HTML)       */
+
       /*  for a constant field (text on the screen.)   */
 
       /*------------------------------------------------*/
 
       /*------------------------------------------------*/
typedef _Packed struct  KwdData {
 
    char Temp[3000];
 
} KwdData_t;
 
 
  KwdData_t  *p_KwdData;
 
  int        ck;
 
 
  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {
 
 
    if  (ck EQ 1 )  {
 
    p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
 
    else
 
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM  + sizeof(QDFKDFPM_t)); }
 
 
        if (p_QDFKDFPM->WDFKDFID EQ 0x01)  {
 
 
        memcpy(Odata->FldNam,"          ",10);
 
 
        Odata->FldPlen  = p_QDFKDFPM->WDFKDFLN;
 
        *Odata->FldIO  = p_QDFFFINF->WDFFFIOA;
 
  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
 
        memcpy(Odata->FldCom,
 
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
 
 
        }
 
 
    }
 
 
 
}
 
 
  /* ######################################### */
 
 
int ProcessCat24() {
 
      /*-----------------------------------------------*/
 
      /* This loops through all keywords that fall into*/
 
      /*  category 24  (Date, Time)                    */
 
      /*-----------------------------------------------*/
 
}
 
  
RTVFLDCL2
+
  int cc;
PGM   (&LIB  &FILE)
+
 
+
    if   (p_QDFFFDPD->WDFFFDOC > 0) {
/* CRTBNDCL  PGM(urlib/RTVFLDCL2)   SRCFILE(urlib/C) */
+
 
/*           SRCMBR(RTVFLDCL2) REPLACE(*YES)         */
+
  /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
+
  /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */
+
 
DCL  &LIB *CHAR 10
+
        p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
DCL  &FILE *CHAR 10
+
                                                p_QDFFFDPD->WDFFFDOC);
+
      cc = 0;
CALL  RTVFLD2 (&LIB  &FILE)
+
      for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {
   
+
 
RCLACTGRP ACTGRP(DISPINFO2)
+
          p_QDFFCCOA = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
+
                            sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);
+
 
ENDPGM
+
 
 +
          if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
 +
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF +
 +
                                                p_QDFFCCOA->WDFFCAOF);
 +
              ProcessCat22();
 +
            }
 +
 
  
RTVFLD2
+
          if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
    /* CRTRPGMOD MODULE(urlib/RTVFLD2) SRCFILE(urlib/C)                     */
+
              p_QDFKDFT  = (QDFKDFT_t *)((char *) p_QDFFFINF  +
    /*        SRCMBR(RTVFLD2) REPLACE(*YES)                                 */
+
                                                p_QDFFCCOA->WDFFCAOF);
     /* CRTPGM PGM(urlib/RTVFLD2)                                          */
+
              ProcessCat23();
    /*         MODULE(urlib/RTVFLD2 urlib/DSPINFOC2)                      */
+
            }
    /*         ENTMOD(*FIRST)                                              */
+
 
    /* CRTPGM PGM(urlib/RTVFLD2)                                        */
+
 
    /*      MODULE(urlib/RTVFLD2 urlib/DISPINFOC2)                   */
+
          if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
    /*       ACTGRP(DISPINFO2)                                              */
+
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
   
+
                                                p_QDFFCCOA->WDFFCAOF);
   
+
              ProcessCat24();
     h Option(*NODEBUGIO)
+
            }
   
+
 
    D RTVFLD2         PR
+
      }
    D                              10A
+
 
    D                              10A
+
 
   
+
 
    D RTVFLD2         PI
+
 
    D iLib                          10A
+
     }
    D iFile                        10A
+
 
   
+
 
    D DISPINFOC      PR                  EXTPROC('DISPINFOC2')
+
}
    D Lib                          10A  const
+
 
    D File                          10A  const
+
  /* ######################################### */
    D oRecord                      10A  const
+
 
    D oField                        10A  const
+
int ProcessCat22() {
    D oRow                          1A  const
+
      /*-----------------------------------------------*/
    D oCol                          1A   const
+
      /* This loops through all keywords that fall into*/
    D Func                          10A  const
+
      /*  category 22                                  */
    D Fdata                              like(RTVDATA)
+
      /*-----------------------------------------------*/
          // returned data
+
}
   
+
 
    D RTVDATA         DS
+
  /* ######################################### */
    D RecordName                    10A
+
 
    D ROW                            1A
+
int ProcessCat23() {
    D COL                            1A
+
      /*------------------------------------------------*/
    D FldIO                          1A
+
      /* This loops through all keywords that fall into */
    D FldAtr                        1A
+
       /*  category 23 (DFT, MSGCON, DFTVAL, HTML)       */
    D FldNam                        10A
+
      /*------------------------------------------------*/
    D FldCom                      3000A
+
  typedef _Packed struct  KwdData {
    D FLdPlen                      10I 0
+
    char Temp[3000];
    D FldDec                        10I 0
+
} KwdData_t;
    D EndDta                        10I 0
+
 
   
+
  KwdData_t  *p_KwdData;
    D oRecordName                  10A
+
  int        ck;
    D oFldNam                      10A
+
 
    D oRow                          1A
+
  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {
    D oCol                          1A
+
 
 +
    if  (ck EQ 1 ) {
 +
     p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
 +
    else
 +
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t)); }
 +
 
 +
         if (p_QDFKDFPM->WDFKDFID EQ 0x01)  {
 +
 
 +
        memcpy(Odata->FldNam,"          ",10);
 +
 
 +
        Odata->FldPlen = p_QDFKDFPM->WDFKDFLN;
 +
         *Odata->FldIO  = p_QDFFFINF->WDFFFIOA;
 +
  p_KwdData = (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
 +
        memset(Odata->FldCom, ' ',3000);
 +
        memcpy(Odata->FldCom,
 +
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
 +
 
 +
        }
 +
 
 +
    }
 +
 
 +
 
 +
}
 +
 
 +
   /* ######################################### */
 +
 
 +
int ProcessCat24() {
 +
      /*-----------------------------------------------*/
 +
      /* This loops through all keywords that fall into*/
 +
      /* category 24  (Date, Time)                    */
 +
      /*-----------------------------------------------*/
 +
        memcpy(Odata->FldNam,"          ",10);
 +
         memset(Odata->FldCom, ' ',3000);
 +
}
 +
 
 +
 
 +
 
 +
RTVFLDCL2
 +
PGM  (&LIB  &FILE)
 +
 +
/* CRTBNDCL  PGM(urlib/RTVFLDCL2)  SRCFILE(urlib/C)  */
 +
/*            SRCMBR(RTVFLDCL2)  REPLACE(*YES)        */
 +
 +
 +
DCL  &LIB  *CHAR 10
 +
DCL &FILE *CHAR 10
 +
 +
CALL  RTVFLD2 (&LIB  &FILE)
 +
 +
RCLACTGRP ACTGRP(DISPINFO2)
 
   
 
   
 
   
 
   
 +
ENDPGM
 +
 +
RTVFLD2
 +
 +
    /* CRTRPGMOD MODULE(urlib/RTVFLD2) SRCFILE(urlib/C)                    */
 +
    /*        SRCMBR(RTVFLD2) REPLACE(*YES)                                */
 +
 +
 +
 +
    /* CRTPGM PGM(urlib/RTVFLD2)                                        */
 +
    /*      MODULE(urlib/RTVFLD2 urlib/DISPINFOC2)                  */
 +
    /*      ACTGRP(DISPINFO2)                                              */
 +
 +
 +
    h Option(*NODEBUGIO)
 +
 +
    D RTVFLD2        PR
 +
    D                              10A
 +
    D                              10A
 +
 +
    D RTVFLD2        PI
 +
    D iLib                          10A
 +
    D iFile                        10A
 +
 +
    D DISPINFOC      PR                  EXTPROC('DISPINFOC2')
 +
    D Lib                          10A  const
 +
    D File                          10A  const
 +
    D oRecord                      10A  const
 +
    D oField                        10A  const
 +
    D oFld                          10I 0 const
 +
    D Func                          10A  const
 +
    D Fdata                              like(RTVDATA)
 +
          // returned data
 +
 +
    D RTVDATA        DS
 +
    D RecordName                    10A
 +
    D ROW                            1A
 +
    D COL                            1A
 +
    D FldIO                          1A
 +
    D FldAtr                        1A
 +
    D FldNam                        10A
 +
    D FldCom                      3000A
 +
    D FLdPlen                      10I 0
 +
    D FldDec                        10I 0
 +
    D EndDta                        10I 0
 +
    D NumFld                        10I 0
 +
 +
    D oRecordName    S            10A
 +
    D oFldNam        S            10A
 +
    D oFld            S            10I 0
 +
 +
 
       /free
 
       /free
+
 
           *INLR = *ON;
+
           *INLR = *ON;
+
 
         CALLP  DISPINFOC( iLib  : iFile    : '  ': '  ' : '  ': '  ':
+
         CALLP  DISPINFOC( iLib  : iFile    : '  ': '  ' : 0 :
                   '#FIRST    ' : RTVDATA  );
+
                   '#FIRST    ' : RTVDATA  );
+
 
         DOW (EndDta = 0);
+
         DOW (EndDta = 0);
+
 
                     oRecordName  =    RecordName ;
+
                     oRecordName  =    RecordName ;
                     oFldNam      =    FldNam    ;
+
                     oFldNam      =    FldNam    ;
                     oROW         =    ROW        ;
+
                     oFld         =    NumFld    ;
                    oCOL        =    COL        ;
+
 
+
       // To get the next record the previous fields info is also passed
       // To get the next record the previous fields info is also passed
+
         CALLP  DISPINFOC(iLib  :  iFile    :
         CALLP  DISPINFOC(iLib  :  iFile    :
+
                         oRecordName  :
                         oRecordName  :
+
                         oFldNam      :
                         oFldNam      :
+
                         oFld         :
                         oROW        :
+
                       '#NEXT    ' : RTVDATA  );
                        oCOL         :
+
 
                       '#NEXT    ' : RTVDATA  );
+
         ENDDO;
+
 
         ENDDO;
+
       /end-free
+
 
       /end-free
+
 
+
 
 
+
 
 
+
</pre>
 
+
[[#top]]
 
 
<pre>
 
  
  
 
+
http://wiki.midrange.com/images/5/5c/QDFRTVDS_links.jpg
 
 
</pre>
 

Latest revision as of 00:36, 4 November 2014


Introduction

C version of the RPG prpgram DSPINFO. This program works differently to the RPG version. I coded it to return only one field or constant at a time. So to see all the fields in a DSPF it needs to loop.

DISPINFOC is coded quite inefficiently but it still works quite fast. It retreives the API data for every time it is called then iterates though all the fields. I coded it this way so as to hide the API retreival within DISPINFOC.

The 2 versions below are more efficient.

I did not include any of the logic to retreive FILE, RECORD, or FIELD attributes. Also there is no logic for any other caterories (eg Date/Time) other than Cat 23 (Conatants)


DISPINFOC


 /* Function: This program uses the QDFRTVFD API to return the */
 /* structure of a display file.  */


 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "QSYSINC/H/QUSEC"
 #include "QSYSINC/H/QDFRTVFD"

 #define EQ      ==

 #define fail() do { printf("\nLine %d FAILED in file %s", \
 __LINE__,__FILE__); \
 } while(0)

/* Pointers to structures required to be used by this program. */
 QDFFBASE_t *p_QDFFBASE;
 QDFFINFO_t *p_QDFFINFO;
 QDFARFTE_t *p_QDFARFTE;
 QDFFRINF_t *p_QDFFRINF;
 QDFFDPDD_t *p_QDFFDPDD;
 QDFFRDPD_t *p_QDFFRDPD;
 QDFWFLEI_t *p_QDFWFLEI;
 QDFFNTBL_t *p_QDFFNTBL;
 QDFWRCDI_t *p_QDFWRCDI;
 QDFWFLDI_t *p_QDFWFLDI;
 QDFFSFCR_t *p_QDFFSFCR;
 QDFFSFHR_t *p_QDFFSFHR;
 QDFFSCRA_t *p_QDFFSCRA;
 QDFFFITB_t *p_QDFFFITB;
 QDFFFINF_t *p_QDFFFINF;
 QDFFFCON_t *p_QDFFFCON;
 QDFFFDPD_t *p_QDFFFDPD;
 QDFFFNAM_t *p_QDFFFNAM;
 QDFFFDIC_t *p_QDFFFDIC;
 QDFFXFDP_t *p_QDFFXFDP;
 QDFFRCTB_t *p_QDFFRCTB;
 QDFFRCTE_t *p_QDFFRCTE;
 QDFFNTB_t  *p_QDFFNTB;
 QDFFCOSA_t *p_QDFFCOSA;
 QDFFCCOA_t *p_QDFFCCOA;
 QDFKMFDK_t *p_QDFKMFDK;
 QDFKDFT_t  *p_QDFKDFT;
 QDFKEDTR_t *p_QDFKEDTR;
 QDFKDFPM_t *p_QDFKDFPM;


    /* Global variables */
    char *p_iLib;
    char *p_iFile;
    char *p_iRecord;
    char *p_iField;
    int  *p_iNumFld;
    char *p_iFunc;

 /* returned data   */
typedef struct FieldData {
    char RecordName[10];
    char ROW[1];
    char COL[1];
    char FldIO[1];
    char FldAtr[1];
    char FldNam[10];
    char FldCom[3000];
    int  FldPlen;
    int  FldDec;
    int  EndDta;
    int  NumFld;
  } FieldData_t;

 FieldData_t *p_FieldData;
 FieldData_t *Odata;

    typedef struct inputArguments
    {
        char *pgmname;
        char *iLib;
        char *iFile;
        char *iRecord;
        char *iField;
        int  *iFld;
        char *iFunc;
        FieldData_t *iOdata;
    } main_args_t;


    int ProcessRec (void);
    int ProcessField (int *);
    int ProcessCons(void);
    int ProcessCat22(void);
    int ProcessCat23(void);
    int ProcessCat24(void);

    int RecIndex;

   /* Area into which the QDFRTVFD returns  the requested data.*/
    char *ReturnVar;


    char FileName[20] = "                    ";
    char Format[8];
    int  EndFlds = 0;

    /* 4 bytes WDFFRETN Length of the returned data. */
    /* 4 bytes WDFFSIZE Size of the display file description */
    typedef struct RtvSizeInfo
    {
        int ReturnLen;
        int ReturnSiz;
    } RtvSizeInfo_t;



   /* ########################################################  */
 int main(int argc, main_args_t *main_args)
 {

    RtvSizeInfo_t *RtvSize;
    Qus_EC_t Error_Code = {0};



    int  API_Len;

    p_iFile   =  main_args->iFile;
    p_iLib    =  main_args->iLib;
    p_iRecord =  main_args->iRecord;
    p_iField  =  main_args->iField;
    p_iNumFld =  main_args->iFld;
    p_iFunc   =  main_args->iFunc;
    Odata     =  main_args->iOdata;

/* Define the API format requested and the display file to access */
    memcpy(Format,"DSPF0100",8);

/* Point to your DSPF */
    memmove(FileName,p_iFile, strlen(p_iFile));
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));


 /* Invoke the API. */
    RtvSize =  malloc(8);
    QDFRTVFD (RtvSize,
                8,
                Format,
                FileName,
                &Error_Code);
    if ( Error_Code.Bytes_Available != 0 ) {
            fail();
            exit (1);
    }
    API_Len  =  RtvSize->ReturnSiz;
    free(RtvSize);

    ReturnVar =  malloc(API_Len);
    QDFRTVFD (ReturnVar,
                API_Len,
                Format,
                FileName,
                &Error_Code);
    if ( Error_Code.Bytes_Available != 0 ) {
            fail();
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
            exit (1);
    }


    ProcessRec();


   free(ReturnVar);
 }
  /* ######################################### */
int ProcessRec() {

    int  NumRecs;
    int i;
    int GotIt = 0;
    /* Access returned structures. The base structure starts at */
    /* the begining of the returned space. */
     p_QDFFBASE = (QDFFBASE_t *)ReturnVar;
     p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
     p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
     p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
     p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);

    /*  here is the place to retreive File Keywords */

     NumRecs = p_QDFFBASE->WDFFRCS;

     for (i=0; i< NumRecs ; ++i) {

         /* Bump ptr to next record structure */
      if  (i  != 0)
     {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
      p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));   }

     memcpy(Odata->RecordName,
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));

    if  (i EQ NumRecs - 1) {
      EndFlds = 1;
      }

     ProcessField(&GotIt);



    }

 }

  /* ######################################### */

int ProcessField(int *GotIt) {
      int SflCtl;
      int SizeIdx;
      int FldIdx;
      int NumFlds;
      char ScrnSize[1];
      char Attrib[1];
      char X01     =  0x01 ;
      char Functn[10] = "          ";

       NumFlds = 0;

      /*  record header   */
       p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
      /*  record dev dept  */
       p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
      /*  SFLCTL                                                              */
      /* 12  C       BIN(31) WDFFRFLG    Miscellaneous record contents.       */
      /* 12  C   0   BIT(1)  WDFFUDDS    If on, USRDFN keyword is specified.  */
      /* 12  C   1   BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
      /* 12  C   2   BIT(1)  WDFFSFLC    If on, SFLCTL keyword is specified (p*/
       SflCtl = 0;
       if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
        {  SflCtl = 1;
     p_QDFFSFCR  = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
     p_QDFFSFHR  = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
         }

     for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
     p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
                          + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
    *ScrnSize =  p_QDFFSCRA->WDFFSCIA ;
     }
    /* Find RowColumn table. Note: this is the first row/col table */
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
    /* correct QDFFRCTB structure if more than one screen size is */
    /* used. */
      p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);

    /********  HERE include code for Record Keywords ********/

    /*  PROCESS THE RECORDS FIELDS    */
        /* Find where used section */

      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));


    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {

       /* Field Header  */
     p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);

    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
      /* constant  */
     p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
    }
    else {
      /*  variable */
     p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
     p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
    }
      /* Field Extension  */
     p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);

      /* Row Column  */
     p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
                     + (p_QDFWFLDI->WDFWRRDX - 1) *2);
     p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));

       *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
       *Odata->COL  =  p_QDFFRCTE->WDFFSCOL;

      /*   here can extract data time flags */

      /* CONSTANTS  */
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
      /* constant  */
      ProcessCons();

    }
    else {
        /*   Field Name   */

       p_QDFFNTB  = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
                          +  10 * (p_QDFWFLDI->WDFWNMEI -1) );


      /*Field attribute.  */
      /*X'01' indicates Constant (see structure QDFFFCON, Constant Field  */
      /*X'02' indicates Output (O), */
      /*X'03' indicates Message (M), h (B), */
      /*X'04' indicates Input (I),  (P)  */
      /*X'05' indicates Both (B), */
      /*X'06' indicates Hidden (H), and */
      /*X'07' indicates Program to System (P) */
       *Odata->FldIO     = p_QDFFFINF->WDFFFIOA;

      /* Keyboard shift and data type.  */
      /* X'00' indicates Alpha shift/character (A), */


        *Odata->FldAtr   = p_QDFFFNAM->WDFFKBDT;
        memcpy(Odata->FldNam,
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
        memset(Odata->FldCom, ' ',3000);
        Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
        Odata->FldDec   = p_QDFFFNAM->WDFFDEC;
    }

   /***********  HERE include code for Field KEYWORDS **********/
      if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
       }

      NumFlds += 1;

       Odata->NumFld = NumFlds;
       Odata->EndDta   = 0;

   /* End ofthe Fields  */
      if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
        Odata->EndDta   = 1;
         *GotIt = 1;
       };

       /* Return the requested Field  */
       memmove(Functn,p_iFunc, strlen(p_iFunc));

        if (!memcmp(Functn , "#FIRST", 6)) {
            *GotIt = 1;
          };

        if (*GotIt)  {
            *GotIt  = 0;
            free(ReturnVar);
            exit(0);
          };

    /* We know we are about to get the NEXT record when we have */
    /* found the record just before                             */

      if (!memcmp(Functn , "#NEXT" , 5) &&
       !memcmp(p_iRecord, Odata->RecordName, 10) &&
       !memcmp(p_iField, Odata->FldNam, 10 ) &&
        (*p_iNumFld  EQ  NumFlds))
       *GotIt = 1;


    }

 }

  /* ######################################### */

int ProcessCons() {
      /*------------------------------------------------*/
      /* This loops through all keyword categories      */
      /*  for a constant field (text on the screen.)    */
      /*------------------------------------------------*/

   int cc;

     if   (p_QDFFFDPD->WDFFFDOC > 0) {

   /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
   /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */

         p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
                                                p_QDFFFDPD->WDFFFDOC);
       cc = 0;
       for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {

          p_QDFFCCOA  = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
                             sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);


           if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat22();
            }


           if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
              p_QDFKDFT  = (QDFKDFT_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat23();
            }


           if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat24();
            }

       }




     }


 }

  /* ######################################### */

int ProcessCat22() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 22                                  */
      /*-----------------------------------------------*/
}

  /* ######################################### */

int ProcessCat23() {
      /*------------------------------------------------*/
      /* This loops through all keywords that fall into */
      /*  category 23 (DFT, MSGCON, DFTVAL, HTML)       */
      /*------------------------------------------------*/
 typedef _Packed struct  KwdData {
    char Temp[3000];
} KwdData_t;

   KwdData_t  *p_KwdData;
   int        ck;

  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {

    if   (ck EQ 1 )  {
     p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
    else
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM  + sizeof(QDFKDFPM_t)); }

        if (p_QDFKDFPM->WDFKDFID EQ 0x01)  {

        memcpy(Odata->FldNam,"          ",10);

        Odata->FldPlen  = p_QDFKDFPM->WDFKDFLN;
        *Odata->FldIO   = p_QDFFFINF->WDFFFIOA;
  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
        memset(Odata->FldCom, ' ',3000);
        memcpy(Odata->FldCom,
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);

        }

    }


}

  /* ######################################### */

int ProcessCat24() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 24  (Date, Time)                    */
      /*-----------------------------------------------*/
        memcpy(Odata->FldNam,"          ",10);
        memset(Odata->FldCom, ' ',3000);
}


 

#top

RTVFLD (RPG code DISPINFOC driver)

RPG Driver program for DISPINFOC This program is coded to loop to invoke DISPINFOC for one field at a time.

It needs to pass a parameter (#FIRST | #NEXT) to tell DISPINFOC what to do.

     h Option(*NODEBUGIO)  DFTACTGRP(*NO)

     D RTVFLD          PR
     D                               10A
     D                               10A

     D RTVFLD          PI
     D iLib                          10A
     D iFile                         10A

     D DISPINFOC       PR                  ExtPgm('DISPINFOC')
     D Lib                           10A   const
     D File                          10A   const
     D oRecord                       10A   const
     D oField                        10A   const
     D oFld                          10I 0 const
     D Func                          10A   const
     D Fdata                               like(RTVDATA)
           // returned data
     D RTVDATA         DS
     D RecordName                    10A
     D ROW                            1A
     D COL                            1A
     D FldIO                          1A
     D FldAtr                         1A
     D FldNam                        10A
     D FldCom                      3000A
     D FLdPlen                       10I 0
     D FldDec                        10I 0
     D EndDta                        10I 0
     D NumFld                        10I 0

     D oRecordName     S             10A
     D oFldNam         S             10A
     D oFld            S             10I 0

      /free

          *INLR = *ON;

          DISPINFOC( iLib  : iFile    : '  ': '  ' : 0   :
                    '#FIRST' : RTVDATA   );

        DOW (EndDta = 0);

                    oRecordName  =    RecordName ;
                    oFldNam      =    FldNam     ;
                    oFld         =    NumFld     ;

       // To get the next record the previous fields info is also passed
          DISPINFOC(iLib   :  iFile    :
                    oRecordName  :
                    oFldNam      :
                    oFld         :
                    '#NEXT ' : RTVDATA   );

        ENDDO;

      /end-free





#top

DISPINFOC1 Version with User Space

 
/* Function: This program uses the QDFRTVFD API to return the */
/* structure of a display file.  */
 

DISPINFOC1
 
 
 /* Function: This program uses the QDFRTVFD API to return the */
 /* structure of a display file.  */


 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "QSYSINC/H/QUSEC"
 #include "QSYSINC/H/QDFRTVFD"

 #include <mispace.h>
 #include <pointer.h>
 #include <mispcobj.h>
 #include <except.h>
 #include <qtes.h>


    /* Link up the Create User Space API */
    #pragma linkage(CreateUserSpace,OS)
    #pragma map(CreateUserSpace,"QUSCRTUS")

    void    CreateUserSpace(char[20],
                        char[10],
                        long int,
                        char,
                        char[10],
                        char[50],
                        char[10],
                        _TE_ERROR_CODE_T *
                        );

    /* Link up the Delete User Space API */
    #pragma linkage(DeleteUserSpace,OS)
    #pragma map(DeleteUserSpace,"QUSDLTUS")
    void    DeleteUserSpace(char[20],
                        _TE_ERROR_CODE_T *
                        );

    /* Link up the Retrieve Pointer to User Space API */
    #pragma linkage(RetrievePointerToUserSpace,OS)
    #pragma map(RetrievePointerToUserSpace,"QUSPTRUS")
    void RetrievePointerToUserSpace(char[20],
                                char **,
                                _TE_ERROR_CODE_T *
                                );


 #define EQ      ==

 #define fail() do { printf("\nLine %d FAILED in file %s", \
 __LINE__,__FILE__); \
 } while(0)

/* Pointers to structures required to be used by this program. */
 QDFFBASE_t *p_QDFFBASE;
 QDFFINFO_t *p_QDFFINFO;
 QDFARFTE_t *p_QDFARFTE;
 QDFFRINF_t *p_QDFFRINF;
 QDFFDPDD_t *p_QDFFDPDD;
 QDFFRDPD_t *p_QDFFRDPD;
 QDFWFLEI_t *p_QDFWFLEI;
 QDFFNTBL_t *p_QDFFNTBL;
 QDFWRCDI_t *p_QDFWRCDI;
 QDFWFLDI_t *p_QDFWFLDI;
 QDFFSFCR_t *p_QDFFSFCR;
 QDFFSFHR_t *p_QDFFSFHR;
 QDFFSCRA_t *p_QDFFSCRA;
 QDFFFITB_t *p_QDFFFITB;
 QDFFFINF_t *p_QDFFFINF;
 QDFFFCON_t *p_QDFFFCON;
 QDFFFDPD_t *p_QDFFFDPD;
 QDFFFNAM_t *p_QDFFFNAM;
 QDFFFDIC_t *p_QDFFFDIC;
 QDFFXFDP_t *p_QDFFXFDP;
 QDFFRCTB_t *p_QDFFRCTB;
 QDFFRCTE_t *p_QDFFRCTE;
 QDFFNTB_t  *p_QDFFNTB;
 QDFFCOSA_t *p_QDFFCOSA;
 QDFFCCOA_t *p_QDFFCCOA;
 QDFKMFDK_t *p_QDFKMFDK;
 QDFKDFT_t  *p_QDFKDFT;
 QDFKEDTR_t *p_QDFKEDTR;
 QDFKDFPM_t *p_QDFKDFPM;


    /* Global variables */
    char *p_iLib;
    char *p_iFile;
    char *p_iRecord;
    char *p_iField;
    int  *p_iNumFld;
    char *p_iFunc;

 /* returned data   */
typedef struct FieldData {
    char RecordName[10];
    char ROW[1];
    char COL[1];
    char FldIO[1];
    char FldAtr[1];
    char FldNam[10];
    char FldCom[3000];
    int  FldPlen;
    int  FldDec;
    int  EndDta;
    int  NumFld;
  } FieldData_t;

 FieldData_t *p_FieldData;
 FieldData_t *Odata;

    typedef struct inputArguments
    {
        char *pgmname;
        char *iLib;
        char *iFile;
        char *iRecord;
        char *iField;
        int  *iFld;
        char *iFunc;
        FieldData_t *iOdata;
    } main_args_t;

    int RtvApiDta (void);
    int ProcessRec (void);
    int ProcessField (int *);
    int ProcessCons(void);
    int ProcessCat22(void);
    int ProcessCat23(void);
    int ProcessCat24(void);

    int RecIndex;

   /* Area into which the QDFRTVFD returns  the requested data.*/

    char *pBuffer;
    _TE_ERROR_CODE_T errorCode;


    char FileName[20] = "                    ";
    char Format[8];
    int  EndFlds = 0;

    /* 4 bytes WDFFRETN Length of the returned data. */
    /* 4 bytes WDFFSIZE Size of the display file description */
    typedef struct RtvSizeInfo
    {
        int ReturnLen;
        int ReturnSiz;
    } RtvSizeInfo_t;



   /* ########################################################  */
 int main(int argc, main_args_t *main_args)
 {

    char Funct[10] = "          ";

    p_iFile   =  main_args->iFile;
    p_iLib    =  main_args->iLib;
    p_iRecord =  main_args->iRecord;
    p_iField  =  main_args->iField;
    p_iNumFld =  main_args->iFld;
    p_iFunc   =  main_args->iFunc;
    Odata     =  main_args->iOdata;



       /* On First pass get the API data */
       memmove(Funct,p_iFunc, strlen(p_iFunc));
         if (!memcmp(Funct, "#FIRST", 6)) {
            RtvApiDta();
            };

         if (!memcmp(Funct, "#NEXT", 5)) {
    /*! call RetrievePointerToUserSpace - Retrieve Pointer to User Space */
           errorCode.BytesProvided = 0;
           RetrievePointerToUserSpace("RTVFDUSPC QTEMP      ",
                            &pBuffer,
                            &errorCode);
       }

    ProcessRec();


     /*  free(ReturnVar);  */
 }




  /* ######################################### */

    RtvApiDta() {

    RtvSizeInfo_t *RtvSize;
    int  API_Len;

    Qus_EC_t Error_Code = {0};


    /* Define the API format requested and the display file to access */
    memcpy(Format,"DSPF0100",8);
    /* Point to your DSPF */
    memmove(FileName,p_iFile, strlen(p_iFile));
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));

    /* Invoke the API. to get the size needed */
    RtvSize =  malloc(8);
    QDFRTVFD (RtvSize,
                8,
                Format,
                FileName,
                &Error_Code);
    if ( Error_Code.Bytes_Available != 0 ) {
            fail();
            exit (1);
    }
    API_Len  =  RtvSize->ReturnSiz;
    free(RtvSize);

    CreateUserSpace("RTVFDUSPC QTEMP      ",
                    "USRSPC    ",
                    API_Len,
                    0,
                    "*ALL      ",
                    " ",
                    "*YES      ",
                    &errorCode
                    );

    /*! call RetrievePointerToUserSpace - Retrieve Pointer to User Space */
    /*!! (pass: Name and library of user space, pointer variable */
    /*!! return: nothing (pointer variable is left pointing to start*/
    /*!! of user space) */
       errorCode.BytesProvided = 0;
       RetrievePointerToUserSpace("RTVFDUSPC QTEMP      ",
                            &pBuffer,
                            &errorCode);

    QDFRTVFD (pBuffer,
                API_Len,
                Format,
                FileName,
                &Error_Code);
    if ( Error_Code.Bytes_Available != 0 ) {
            fail();
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
            exit (1);
    }
}




  /* ######################################### */
int ProcessRec() {

    int  NumRecs;
    int i;
    int GotIt = 0;
    /* Access returned structures. The base structure starts at */
    /* the begining of the returned space. */
     p_QDFFBASE = (QDFFBASE_t *)pBuffer;
     p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
     p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
     p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
     p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);

    /*  here is the place to retreive File Keywords */

     NumRecs = p_QDFFBASE->WDFFRCS;

     for (i=0; i< NumRecs ; ++i) {

         /* Bump ptr to next record structure */
      if  (i  != 0)
     {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
      p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));   }

     memcpy(Odata->RecordName,
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));

    if  (i EQ NumRecs - 1) {
      EndFlds = 1;
      }

     ProcessField(&GotIt);



    }

 }

  /* ######################################### */

int ProcessField(int *GotIt) {

      int SflCtl;
      int SizeIdx;
      int FldIdx;
      int NumFlds;
      char ScrnSize[1];
      char Attrib[1];
      char X01     =  0x01 ;
      char Functn[10] = "          ";

      NumFlds = 0;

      /*  record header   */
       p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
      /*  record dev dept  */
       p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
      /*  SFLCTL                                                              */
      /* 12  C       BIN(31) WDFFRFLG    Miscellaneous record contents.       */
      /* 12  C   0   BIT(1)  WDFFUDDS    If on, USRDFN keyword is specified.  */
      /* 12  C   1   BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
      /* 12  C   2   BIT(1)  WDFFSFLC    If on, SFLCTL keyword is specified (p*/
       SflCtl = 0;
       if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
        {  SflCtl = 1;
     p_QDFFSFCR  = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
     p_QDFFSFHR  = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
         }

     for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
     p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
                          + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
    *ScrnSize =  p_QDFFSCRA->WDFFSCIA ;
     }
    /* Find RowColumn table. Note: this is the first row/col table */
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
    /* correct QDFFRCTB structure if more than one screen size is */
    /* used. */
      p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);

    /********  HERE include code for Record Keywords ********/

    /*  PROCESS THE RECORDS FIELDS    */
        /* Find where used section */

      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));


    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {

       /* Field Header  */
     p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);

    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
      /* constant  */
     p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
    }
    else {
      /*  variable */
     p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
     p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
    }
      /* Field Extension  */
     p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);

      /* Row Column  */
     p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
                     + (p_QDFWFLDI->WDFWRRDX - 1) *2);
     p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));

       *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
       *Odata->COL  =  p_QDFFRCTE->WDFFSCOL;

      /*   here can extract data time flags */

      /* CONSTANTS  */
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
      /* constant  */
      ProcessCons();

    }
    else {
        /*   Field Name   */

       p_QDFFNTB  = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
                          +  10 * (p_QDFWFLDI->WDFWNMEI -1) );


      /*Field attribute.  */
      /*X'01' indicates Constant (see structure QDFFFCON, Constant Field  */
      /*X'02' indicates Output (O), */
      /*X'03' indicates Message (M), h (B), */
      /*X'04' indicates Input (I),  (P)  */
      /*X'05' indicates Both (B), */
      /*X'06' indicates Hidden (H), and */
      /*X'07' indicates Program to System (P) */
       *Odata->FldIO     = p_QDFFFINF->WDFFFIOA;

      /* Keyboard shift and data type.  */
      /* X'00' indicates Alpha shift/character (A), */


        *Odata->FldAtr   = p_QDFFFNAM->WDFFKBDT;
        memcpy(Odata->FldNam,
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
        memset(Odata->FldCom,' ',3000);
        Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
        Odata->FldDec   = p_QDFFFNAM->WDFFDEC;
    }

   /***********  HERE include code for Field KEYWORDS **********/
      if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
       }

      NumFlds += 1;

       Odata->NumFld   = NumFlds;
       Odata->EndDta   = 0;

   /* End ofthe Fields  */
      if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
        Odata->EndDta   = 1;
         *GotIt = 1;
        DeleteUserSpace("RTVFDUSPC QTEMP      ",
                        &errorCode);
       };

       /* Return the requested Field  */
       memmove(Functn,p_iFunc, strlen(p_iFunc));

        if (!memcmp(Functn , "#FIRST", 6)) {
            *GotIt = 1;
          };

        if (*GotIt)  {
            *GotIt  = 0;
            exit(0);
          };

    /* We know we are about to get the NEXT record when we have */
    /* found the record just before                             */
      if (!memcmp(Functn , "#NEXT" , 5) &&
       !memcmp(p_iRecord, Odata->RecordName, 10) &&
       !memcmp(p_iField, Odata->FldNam, 10 ) &&
        (*p_iNumFld  EQ  NumFlds))
       *GotIt = 1;




    }

 }

  /* ######################################### */

int ProcessCons() {
      /*------------------------------------------------*/
      /* This loops through all keyword categories      */
      /*  for a constant field (text on the screen.)    */
      /*------------------------------------------------*/

   int cc;

     if   (p_QDFFFDPD->WDFFFDOC > 0) {

   /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
   /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */

         p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
                                                p_QDFFFDPD->WDFFFDOC);
       cc = 0;
       for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {

          p_QDFFCCOA  = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
                             sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);


           if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat22();
            }


           if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
              p_QDFKDFT  = (QDFKDFT_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat23();
            }


           if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat24();
            }

       }




     }


 }

  /* ######################################### */

int ProcessCat22() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 22                                  */
      /*-----------------------------------------------*/
}

  /* ######################################### */

int ProcessCat23() {
      /*------------------------------------------------*/
      /* This loops through all keywords that fall into */
      /*  category 23 (DFT, MSGCON, DFTVAL, HTML)       */
      /*------------------------------------------------*/
 typedef _Packed struct  KwdData {
    char Temp[3000];
} KwdData_t;

   KwdData_t  *p_KwdData;
   int        ck;

  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {

    if   (ck EQ 1 )  {
     p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
    else
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM  + sizeof(QDFKDFPM_t)); }

        if (p_QDFKDFPM->WDFKDFID EQ 0x01)  {

        memcpy(Odata->FldNam,"          ",10);

        Odata->FldPlen  = p_QDFKDFPM->WDFKDFLN;
        *Odata->FldIO   = p_QDFFFINF->WDFFFIOA;
  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
        memset(Odata->FldCom, ' ',3000);
        memcpy(Odata->FldCom,
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);

        }

    }


}

  /* ######################################### */

int ProcessCat24() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 24  (Date, Time)                    */
      /*-----------------------------------------------*/
        memcpy(Odata->FldNam,"          ",10);
        memset(Odata->FldCom, ' ',3000);
}


RTVFLD1

     h Option(*NODEBUGIO)  DFTACTGRP(*NO)

     D RTVFLD1         PR
     D                               10A
     D                               10A

     D RTVFLD1         PI
     D iLib                          10A
     D iFile                         10A

     D DISPINFOC1      PR                  ExtPgm('DISPINFOC1')
     D Lib                           10A   const
     D File                          10A   const
     D oRecord                       10A   const
     D oField                        10A   const
     D oFld                          10I 0 const
     D Func                          10A   const
     D Fdata                               like(RTVDATA)
           // returned data
     D RTVDATA         DS
     D RecordName                    10A
     D ROW                            1A
     D COL                            1A
     D FldIO                          1A
     D FldAtr                         1A
     D FldNam                        10A
     D FldCom                      3000A
     D FLdPlen                       10I 0
     D FldDec                        10I 0
     D EndDta                        10I 0
     D NumFld                        10I 0

     D oRecordName     S             10A
     D oFldNam         S             10A
     D oFld            S             10I 0

      /free

          *INLR = *ON;

          DISPINFOC1( iLib  : iFile    : '  ': '  ' : 0 :
                    '#FIRST' : RTVDATA   );

        DOW (EndDta = 0);

                    oRecordName  =    RecordName ;
                    oFldNam      =    FldNam     ;
                    oFld         =    NumFld     ;

       // To get the next record the previous fields info is also passed
          DISPINFOC1(iLib   :  iFile    :
                    oRecordName  :
                    oFldNam      :
                    oFld         :
                    '#NEXT ' : RTVDATA   );

        ENDDO;

      /end-free


 

#top

DISPINFOC2 Version with C Module

I needed to drive this fron a CLLE (code is below) because I need a RCLACTGRP DISPINFO2.

Reason is I did a return from the C module, rather than an exit.



DISPINFOC2
 

 /* Function: This module  uses the QDFRTVFD API to return the */
 /* structure of a display file.  */

 /* CRTCMOD MODULE(urlib/DISPINFOC2) SRCFILE(urlib/C) SRCMBR(DISPINFOC2) */
 /*         REPLACE(*yes)                                                */

 /* bind into your program with                                          */
 /* CRTPGM PGM(urlib/RTVFLD2)                                         */
 /*       MODULE(urlib/RTVFLD2 urlib/DISPINFOC2)                   */
 /*       ACTGRP(DISPINFO2)                                              */



 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "QSYSINC/H/QUSEC"
 #include "QSYSINC/H/QDFRTVFD"



 #define EQ      ==

 #define fail() do { printf("\nLine %d FAILED in file %s", \
 __LINE__,__FILE__); \
 } while(0)

/* Pointers to structures required to be used by this program. */
 QDFFBASE_t *p_QDFFBASE;
 QDFFINFO_t *p_QDFFINFO;
 QDFARFTE_t *p_QDFARFTE;
 QDFFRINF_t *p_QDFFRINF;
 QDFFDPDD_t *p_QDFFDPDD;
 QDFFRDPD_t *p_QDFFRDPD;
 QDFWFLEI_t *p_QDFWFLEI;
 QDFFNTBL_t *p_QDFFNTBL;
 QDFWRCDI_t *p_QDFWRCDI;
 QDFWFLDI_t *p_QDFWFLDI;
 QDFFSFCR_t *p_QDFFSFCR;
 QDFFSFHR_t *p_QDFFSFHR;
 QDFFSCRA_t *p_QDFFSCRA;
 QDFFFITB_t *p_QDFFFITB;
 QDFFFINF_t *p_QDFFFINF;
 QDFFFCON_t *p_QDFFFCON;
 QDFFFDPD_t *p_QDFFFDPD;
 QDFFFNAM_t *p_QDFFFNAM;
 QDFFFDIC_t *p_QDFFFDIC;
 QDFFXFDP_t *p_QDFFXFDP;
 QDFFRCTB_t *p_QDFFRCTB;
 QDFFRCTE_t *p_QDFFRCTE;
 QDFFNTB_t  *p_QDFFNTB;
 QDFFCOSA_t *p_QDFFCOSA;
 QDFFCCOA_t *p_QDFFCCOA;
 QDFKMFDK_t *p_QDFKMFDK;
 QDFKDFT_t  *p_QDFKDFT;
 QDFKEDTR_t *p_QDFKEDTR;
 QDFKDFPM_t *p_QDFKDFPM;


    /* Global variables */
    char *p_iLib;
    char *p_iFile;
    char *p_iRecord;
    char *p_iField;
    int  *p_iFld;
    char *p_iFunc;

 /* returned data   */
typedef struct FieldData {
    char RecordName[10];
    char ROW[1];
    char COL[1];
    char FldIO[1];
    char FldAtr[1];
    char FldNam[10];
    char FldCom[3000];
    int  FldPlen;
    int  FldDec;
    int  EndDta;
    int  NumFld;
  } FieldData_t;

 FieldData_t *p_FieldData;
 FieldData_t *Odata;


    int RtvApiDta (void);
    int ProcessRec (void);
    int ProcessField (int *);
    int ProcessCons(void);
    int ProcessCat22(void);
    int ProcessCat23(void);
    int ProcessCat24(void);

    int RecIndex;


    char *ReturnVar;



    char FileName[20] = "                    ";
    char Format[8];
    int  EndFlds = 0;

    /* 4 bytes WDFFRETN Length of the returned data. */
    /* 4 bytes WDFFSIZE Size of the display file description */
    typedef struct RtvSizeInfo
    {
        int ReturnLen;
        int ReturnSiz;
    } RtvSizeInfo_t;



   /* ########################################################  */
 int DISPINFOC2
  (   char *p_pLib  ,
      char *p_pFile ,
      char *p_pRecord ,
      char *p_pField ,
      int  *p_pFld ,
      char *p_pFunc ,
     FieldData_t *pOdata)
 {

       char Funct[10] = "          ";

     p_iLib    = p_pLib;
     p_iFile   = p_pFile;
     p_iRecord = p_pRecord;
     p_iField  = p_pField;
     p_iFld    = p_pFld;
     p_iFunc   = p_pFunc;
     Odata     =   pOdata;


       /* On First pass get the API data */
       memmove(Funct,p_iFunc, strlen(p_iFunc));
         if (!memcmp(Funct, "#FIRST", 6)) {
            RtvApiDta();
            };


    ProcessRec();

 }




  /* ######################################### */

    RtvApiDta() {

    RtvSizeInfo_t *RtvSize;
    int  API_Len;

    Qus_EC_t Error_Code = {0};


    /* Define the API format requested and the display file to access */
    memcpy(Format,"DSPF0100",8);
    /* Point to your DSPF */
    memmove(FileName,p_iFile, strlen(p_iFile));
    memmove(FileName + 10 ,p_iLib, strlen(p_iLib ));

    /* Invoke the API. to get the size needed */
    RtvSize =  malloc(8);
    QDFRTVFD (RtvSize,
                8,
                Format,
                FileName,
                &Error_Code);
    if ( Error_Code.Bytes_Available != 0 ) {
            fail();
            exit (1);
    }
    API_Len  =  RtvSize->ReturnSiz;
    free(RtvSize);

    ReturnVar =  malloc(API_Len);
    QDFRTVFD (ReturnVar,
                API_Len,
                Format,
                FileName,
                &Error_Code);
    if ( Error_Code.Bytes_Available != 0 ) {
            fail();
            printf( "\nExcId: %s" , Error_Code.Exception_Id );
            exit (1);
    }
}




  /* ######################################### */
int ProcessRec() {

    int  NumRecs;
    int i;
    int GotIt = 0;
    /* Access returned structures. The base structure starts at */
    /* the begining of the returned space. */
     p_QDFFBASE = (QDFFBASE_t *)ReturnVar;
     p_QDFFINFO = (QDFFINFO_t *)((char *) p_QDFFBASE + p_QDFFBASE->WDFFINOF);
     p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
     p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
     p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);

    /*  here is the place to retreive File Keywords */

     NumRecs = p_QDFFBASE->WDFFRCS;

     for (i=0; i< NumRecs ; ++i) {

         /* Bump ptr to next record structure */
      if  (i  != 0)
     {p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
      p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));   }

     memcpy(Odata->RecordName,
            p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));

    if  (i EQ NumRecs - 1) {
      EndFlds = 1;
      }

     ProcessField(&GotIt);

        if (GotIt EQ 1)  {
            return(0);
          };


    }

 }

  /* ######################################### */

int ProcessField(int *GotIt) {

      int SflCtl;
      int SizeIdx;
      int FldIdx;
      int NumFlds;
      char ScrnSize[1];
      char Attrib[1];
      char X01     =  0x01 ;
      char Functn[10] = "          ";

       NumFlds = 0;

      /*  record header   */
       p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
      /*  record dev dept  */
       p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
      /*  SFLCTL                                                              */
      /* 12  C       BIN(31) WDFFRFLG    Miscellaneous record contents.       */
      /* 12  C   0   BIT(1)  WDFFUDDS    If on, USRDFN keyword is specified.  */
      /* 12  C   1   BIT(1)  WDFFSFL If on, SFL keyword is specified (next rec*/
      /* 12  C   2   BIT(1)  WDFFSFLC    If on, SFLCTL keyword is specified (p*/
       SflCtl = 0;
       if (p_QDFFRINF->WDFFRFLG.WDFFSFLC)
        {  SflCtl = 1;
     p_QDFFSFCR  = (QDFFSFCR_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
     p_QDFFSFHR  = (QDFFSFHR_t *)((char *) p_QDFFSFCR + sizeof(QDFFSFCR_t));
         }

     for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
     p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
                          + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
    *ScrnSize =  p_QDFFSCRA->WDFFSCIA ;
     }
    /* Find RowColumn table. Note: this is the first row/col table */
    /* so this code only works for the PRIMARY DISPLAY SIZE. */
    /* See QDFFRDPD.WDFFDRCO field description for finding the */
    /* correct QDFFRCTB structure if more than one screen size is */
    /* used. */
      p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO);

    /********  HERE include code for Record Keywords ********/

    /*  PROCESS THE RECORDS FIELDS    */
        /* Find where used section */

      p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
      p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));


    for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {

       /* Field Header  */
     p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);

    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
      /* constant  */
     p_QDFFFCON = (QDFFFCON_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFCON->WDFFFAOC);
    }
    else {
      /*  variable */
     p_QDFFFNAM = (QDFFFNAM_t *)((char *) p_QDFFFINF + sizeof(QDFFFINF_t));
     p_QDFFFDPD = (QDFFFDPD_t *)((char *) p_QDFFFINF + p_QDFFFNAM->WDFFFAOF);
     p_QDFFFDIC = (QDFFFDIC_t *)((char *) p_QDFFFDPD + sizeof(QDFFFDPD_t));
    }
      /* Field Extension  */
     p_QDFFXFDP = (QDFFXFDP_t *)((char *) p_QDFFFINF + p_QDFFFDPD->WDFFXFDO);

      /* Row Column  */
     p_QDFFRCTB = (QDFFRCTB_t *)((char *) p_QDFFRINF + p_QDFFRDPD->WDFFDRCO
                     + (p_QDFWFLDI->WDFWRRDX - 1) *2);
     p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));

       *Odata->ROW  =  p_QDFFRCTE->WDFFSROW;
       *Odata->COL  =  p_QDFFRCTE->WDFFSCOL;

      /*   here can extract data time flags */

      /* CONSTANTS  */
    if (p_QDFFFINF->WDFFFIOA EQ 0x01)  {
      /* constant  */
      ProcessCons();

    }
    else {
        /*   Field Name   */

       p_QDFFNTB  = (QDFFNTB_t *)((char *) p_QDFFNTBL + sizeof(QDFFNTBL_t)
                          +  10 * (p_QDFWFLDI->WDFWNMEI -1) );


      /*Field attribute.  */
      /*X'01' indicates Constant (see structure QDFFFCON, Constant Field  */
      /*X'02' indicates Output (O), */
      /*X'03' indicates Message (M), h (B), */
      /*X'04' indicates Input (I),  (P)  */
      /*X'05' indicates Both (B), */
      /*X'06' indicates Hidden (H), and */
      /*X'07' indicates Program to System (P) */
       *Odata->FldIO     = p_QDFFFINF->WDFFFIOA;

      /* Keyboard shift and data type.  */
      /* X'00' indicates Alpha shift/character (A), */


        *Odata->FldAtr   = p_QDFFFNAM->WDFFKBDT;
        memcpy(Odata->FldNam,
               p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
        memset(Odata->FldCom, ' ',3000);
        Odata->FldPlen  = p_QDFFFNAM->WDFFPLEN;
        Odata->FldDec   = p_QDFFFNAM->WDFFDEC;
    }

   /***********  HERE include code for Field KEYWORDS **********/
      if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
                   +  ( p_QDFWFLDI->WDFWRRDX -1) * sizeof(QDFFFITB_t));
       }

      NumFlds += 1;

       Odata->NumFld   = NumFlds;
       Odata->EndDta   = 0;

   /* End ofthe Fields  */
      if ((EndFlds EQ 1) && (FldIdx EQ p_QDFFRINF->WDFFFLD -1) ) {
        Odata->EndDta   = 1;
         *GotIt = 2;
         free(ReturnVar);
       };

       /* Return the requested Field  */
       memmove(Functn,p_iFunc, strlen(p_iFunc));

        if ( (!memcmp(Functn , "#FIRST", 6)) || (*GotIt EQ 2))  {
            *GotIt = 1;
             return(0);
          };


    /* We know we are about to get the NEXT record when we have */
    /* found the record just before                             */
      if (!memcmp(Functn , "#NEXT" , 5) &&
       !memcmp(p_iRecord, Odata->RecordName, 10) &&
       !memcmp(p_iField, Odata->FldNam, 10 ) &&
        (*p_iFld  EQ  NumFlds))
       *GotIt = 2;



    }

 }

  /* ######################################### */

int ProcessCons() {
      /*------------------------------------------------*/
      /* This loops through all keyword categories      */
      /*  for a constant field (text on the screen.)    */
      /*------------------------------------------------*/

   int cc;

     if   (p_QDFFFDPD->WDFFFDOC > 0) {

   /* p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFFFINF );*/
   /* p_QDFFRINF  = p_QDFFINFO + QDFARFTE.WDFARFOF */

         p_QDFFCOSA = (QDFFCOSA_t *) ((char *) p_QDFFFINF +
                                                p_QDFFFDPD->WDFFFDOC);
       cc = 0;
       for (cc=0; cc<=p_QDFFCOSA->WDFFCCT -1 ; ++cc) {

          p_QDFFCCOA  = (QDFFCCOA_t *)((char *) p_QDFFCOSA +
                             sizeof(QDFFCOSA_t) + sizeof(QDFFCCOA_t) * cc);


           if (p_QDFFCCOA->WDFFCAID EQ 0x22) {
              p_QDFKMFDK = (QDFKMFDK_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat22();
            }


           if (p_QDFFCCOA->WDFFCAID EQ 0x23) {
              p_QDFKDFT  = (QDFKDFT_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat23();
            }


           if (p_QDFFCCOA->WDFFCAID EQ 0x24) {
              p_QDFKEDTR = (QDFKEDTR_t *)((char *) p_QDFFFINF  +
                                                p_QDFFCCOA->WDFFCAOF);
              ProcessCat24();
            }

       }




     }


 }

  /* ######################################### */

int ProcessCat22() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 22                                  */
      /*-----------------------------------------------*/
}

  /* ######################################### */

int ProcessCat23() {
      /*------------------------------------------------*/
      /* This loops through all keywords that fall into */
      /*  category 23 (DFT, MSGCON, DFTVAL, HTML)       */
      /*------------------------------------------------*/
 typedef _Packed struct  KwdData {
    char Temp[3000];
} KwdData_t;

   KwdData_t  *p_KwdData;
   int        ck;

  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {

    if   (ck EQ 1 )  {
     p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
    else
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM  + sizeof(QDFKDFPM_t)); }

        if (p_QDFKDFPM->WDFKDFID EQ 0x01)  {

        memcpy(Odata->FldNam,"          ",10);

        Odata->FldPlen  = p_QDFKDFPM->WDFKDFLN;
        *Odata->FldIO   = p_QDFFFINF->WDFFFIOA;
  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) );
        memset(Odata->FldCom, ' ',3000);
        memcpy(Odata->FldCom,
                p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);

        }

    }


}

  /* ######################################### */

int ProcessCat24() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 24  (Date, Time)                    */
      /*-----------------------------------------------*/
        memcpy(Odata->FldNam,"          ",10);
        memset(Odata->FldCom, ' ',3000);
}



RTVFLDCL2
PGM   (&LIB   &FILE)
 
/* CRTBNDCL   PGM(urlib/RTVFLDCL2)   SRCFILE(urlib/C)  */
/*            SRCMBR(RTVFLDCL2)  REPLACE(*YES)         */
 
 
DCL  &LIB  *CHAR 10
DCL  &FILE *CHAR 10
 
CALL  RTVFLD2 (&LIB  &FILE)
 
RCLACTGRP ACTGRP(DISPINFO2)
 
 
ENDPGM

RTVFLD2

     /* CRTRPGMOD MODULE(urlib/RTVFLD2) SRCFILE(urlib/C)                     */
     /*        SRCMBR(RTVFLD2) REPLACE(*YES)                                 */



     /* CRTPGM PGM(urlib/RTVFLD2)                                         */
     /*       MODULE(urlib/RTVFLD2 urlib/DISPINFOC2)                   */
     /*       ACTGRP(DISPINFO2)                                              */


     h Option(*NODEBUGIO)

     D RTVFLD2         PR
     D                               10A
     D                               10A

     D RTVFLD2         PI
     D iLib                          10A
     D iFile                         10A

     D DISPINFOC       PR                  EXTPROC('DISPINFOC2')
     D Lib                           10A   const
     D File                          10A   const
     D oRecord                       10A   const
     D oField                        10A   const
     D oFld                          10I 0 const
     D Func                          10A   const
     D Fdata                               like(RTVDATA)
           // returned data

     D RTVDATA         DS
     D RecordName                    10A
     D ROW                            1A
     D COL                            1A
     D FldIO                          1A
     D FldAtr                         1A
     D FldNam                        10A
     D FldCom                      3000A
     D FLdPlen                       10I 0
     D FldDec                        10I 0
     D EndDta                        10I 0
     D NumFld                        10I 0

     D oRecordName     S             10A
     D oFldNam         S             10A
     D oFld            S             10I 0


      /free

          *INLR = *ON;

        CALLP  DISPINFOC( iLib  : iFile    : '  ': '  ' : 0 :
                   '#FIRST    ' : RTVDATA   );

        DOW (EndDta = 0);

                    oRecordName  =    RecordName ;
                    oFldNam      =    FldNam     ;
                    oFld         =    NumFld     ;

       // To get the next record the previous fields info is also passed
         CALLP  DISPINFOC(iLib   :  iFile    :
                        oRecordName  :
                        oFldNam      :
                        oFld         :
                       '#NEXT     ' : RTVDATA   );

        ENDDO;

      /end-free

 


#top


http://wiki.midrange.com/images/5/5c/QDFRTVDS_links.jpg