Difference between revisions of "CQDFRTVFD"

From MidrangeWiki
Jump to: navigation, search
(Introduction)
Line 8: Line 8:
  
 
<pre>
 
<pre>
 +
 +
 +
/* Function: This program uses the QDFRTVFD API to return the */
 +
/* structure of a display file.  */
  
  
Line 31: Line 35:
 
  QDFARFTE_t *p_QDFARFTE;
 
  QDFARFTE_t *p_QDFARFTE;
 
  QDFFRINF_t *p_QDFFRINF;
 
  QDFFRINF_t *p_QDFFRINF;
 +
QDFFDPDD_t *p_QDFFDPDD;
 
  QDFFRDPD_t *p_QDFFRDPD;
 
  QDFFRDPD_t *p_QDFFRDPD;
QDFFRCTB_t *p_QDFFRCTB;
 
 
  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;
QDFFRCTE_t *p_QDFFRCTE;
 
 
  QDFFSFCR_t *p_QDFFSFCR;
 
  QDFFSFCR_t *p_QDFFSFCR;
 
  QDFFSFHR_t *p_QDFFSFHR;
 
  QDFFSFHR_t *p_QDFFSFHR;
Line 43: Line 46:
 
  QDFFFITB_t *p_QDFFFITB;
 
  QDFFFITB_t *p_QDFFFITB;
 
  QDFFFINF_t *p_QDFFFINF;
 
  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 */
 
     /* Global variables */
Line 59: Line 75:
 
     int ProcessRec (void);
 
     int ProcessRec (void);
 
     int ProcessField (void);
 
     int ProcessField (void);
 +
    int ProcessCons(void);
 +
    int ProcessCat22(void);
 +
    int ProcessCat23(void);
 +
    int ProcessCat24(void);
  
 
     int RecIndex;
 
     int RecIndex;
Line 68: Line 88:
 
     char FileName[20] = "                    ";
 
     char FileName[20] = "                    ";
 
     char RecordName[10];
 
     char RecordName[10];
 +
    char ROW[2];
 +
    char COL[2];
 +
    char FldIO[1];
 +
    char FldAtr[1];
 +
    char FldNam[10];
 +
    char FldCom[3000];
 +
    char Fldblank[30] = "                              ";
 +
    int  FldPlen;
 +
    int  FldDec;
 +
  
/* DSPF information TEST ONLY  */
 
    char MyRec[] = "C01      "; /* Test name */
 
    char MyField[] = "SRS01    "; /* Test name */
 
  
 
     /* 4 bytes WDFFRETN Length of the returned data. */
 
     /* 4 bytes WDFFRETN Length of the returned data. */
Line 133: Line 160:
 
     }
 
     }
  
    FindRec();
+
 
 
         printf("\nEnd of test");
 
         printf("\nEnd of test");
  
Line 151: Line 178:
 
     p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
 
     p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFDFLO);
 
     p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
 
     p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
     p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
+
     p_QDFFDPDD = (QDFFDPDD_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFXDOF);
 
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
 
     p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWXLEN);
 
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
 
     p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
Line 200: Line 227:
 
         }
 
         }
  
     for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR -1; ++SizeIdx) {
+
     for (SizeIdx=0; SizeIdx<p_QDFFBASE->WDFFSCR ; ++SizeIdx) {
 
     p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
 
     p_QDFFSCRA  = (QDFFSCRA_t *)((char *) p_QDFFBASE + sizeof(QDFFBASE_t)
 
                           + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
 
                           + sizeof(QDFFSCRA_t) * SizeIdx    ) ;
Line 224: Line 251:
 
     for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {
 
     for (FldIdx=0; FldIdx < p_QDFFRINF->WDFFFLD; ++FldIdx) {
  
 +
      /* Field Header  */
 
     p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);
 
     p_QDFFFINF = (QDFFFINF_t *)((char *) p_QDFFRINF + p_QDFFFITB->WDFFFOFS);
  
     memmove(Attrib,p_QDFFFINF->WDFFFIOA, 1);
+
     if (p_QDFFFINF->WDFFFIOA == 0x01)  {
     if (strncmp(Attrib,X01, 1) == 0) {
+
      /* constant  */
       NumFlds += 1;
+
    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));
 +
 
 +
      *ROW  =  p_QDFFRCTE->WDFFSROW;
 +
      *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) */
 +
      *FldIO    = p_QDFFFINF->WDFFFIOA;
  
 +
      /* Keyboard shift and data type.  */
 +
      /* X'00' indicates Alpha shift/character (A), */
  
  
 +
        *FldAtr  = p_QDFFFNAM->WDFFKBDT;
 +
        memcpy(FldNam,p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
 +
        memcpy(FldCom,"                              ",30);
 +
        FldPlen  = p_QDFFFNAM->WDFFPLEN;
 +
        FldDec  = p_QDFFFNAM->WDFFDEC;
 +
    }
  
 
   /***********  HERE include code for Field KEYWORDS **********/
 
   /***********  HERE include code for Field KEYWORDS **********/
 
 
       if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
 
       if (FldIdx < p_QDFFRINF->WDFFFLD -1) {
 
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
 
       p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
 
       p_QDFFFITB = (QDFFFITB_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFOFIT
 
       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;
 +
    }
 +
 +
}
 +
 +
 +
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();
 +
            }
 +
 
       }
 
       }
  
      NumFlds += 1;
 
  
  
  
    }
+
    }
 +
 
  
 
  }
 
  }
  
 +
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;
  
int FindRec() {
+
KwdData_t  *p_KwdData;
        int i;
+
 
    /* Access returned structures. The base structure starts at */
+
 
    /* the begining of the returned space. */
+
  int    ck;
        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);
+
  for (ck=1; ck <= p_QDFKDFT->WDFKDFS ; ++ck) {
    /* While there are records, look for the requested record name */
 
    /* in the QDFARFTE structure. */
 
    for (i=0; i<p_QDFFBASE->WDFFRCS; ++i) {
 
    if (strncmp(p_QDFARFTE->WDFARFNM,MyRec,10) == 0) {
 
        RecIndex = i + 1; /* Entry in QDFARFTE table for the requested name*/
 
  
     /* Access additional structures. */
+
     if  (ck EQ 1 ) {
        p_QDFFRINF = (QDFFRINF_t *)((char *) p_QDFFINFO + p_QDFARFTE->WDFARFOF);
+
    p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFT + sizeof(QDFKDFT_t));  }
        p_QDFFRDPD = (QDFFRDPD_t *)((char *) p_QDFFRINF + p_QDFFRINF->WDFFRAOF);
 
    /* 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);
 
            FindField(); /* Find the requested field */
 
        return(0); /* Task is done. */
 
  }
 
 
     else
 
     else
        p_QDFARFTE = (QDFARFTE_t *)((char *) p_QDFARFTE + sizeof(QDFARFTE_t));
+
    {p_QDFKDFPM = (QDFKDFPM_t *)((char *) p_QDFKDFPM  + sizeof(QDFKDFPM_t)); }
}
+
 
    /* If this point is reached, there was no match for the requested */
+
 
    /* record. */
+
         if (p_QDFKDFPM->WDFKDFID == 0x01) {
         printf("\nThe requested record was not found %s",MyRec);
+
 
         return(0);
+
        FldPlen  = p_QDFKDFPM->WDFKDFLN;
}
+
         *FldIO  = p_QDFFFINF->WDFFFIOA;
 +
 
 +
 
 +
  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) -1);
  
 +
  memcpy(FldCom, p_KwdData->Temp, sizeof(p_QDFKDFPM->WDFKDFLN));
  
int FindField () {
+
   ck=1;
    int j;
 
    int k;
 
    int NtblIndex;
 
    char *NamePtr;
 
    int RCIndex;
 
    int RecNumber;
 
    /* Find where used section */
 
      p_QDFWFLEI = (QDFWFLEI_t *)((char *) p_QDFFINFO + p_QDFFINFO->WDFFWUOF);
 
    /* Find name table. There is one entry for each unique field */
 
    /* name used in the file. A given name may be used in more than */
 
    /* one record format. */
 
      p_QDFFNTBL = (QDFFNTBL_t *)((char *) p_QDFWFLEI + p_QDFWFLEI->WDFWNTBO);
 
    /* Prepare to search table. Start search after the fixed portion. */
 
        NamePtr = (char *) p_QDFFNTBL + sizeof(QDFFNTBL_t);
 
        NtblIndex = 0;
 
    /* Find requested name */
 
    for (j=0; j<p_QDFFNTBL->WDFFNMS; ++j) {
 
        if (strncmp(NamePtr,MyField,10) == 0) {
 
            NtblIndex = j + 1;
 
    /* The requested name was found   Get first QDFWRCDI structure. */
 
  p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWFLEI +p_QDFWFLEI->WDFWXLEN);
 
            RecNumber = 1;
 
  
    /* For each record, find the first field structure.          +
+
      }
    Then, find a match for the field name table index            +
 
    If found, the field structure containing the matched index  +
 
    also contains the row/column index. */
 
  
    for (j=0; j<p_QDFFBASE->WDFFRCS; ++j) {
 
    /* Make sure the field matching is for the correct record. */
 
        if (RecNumber == RecIndex) {
 
        p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWRLEN);
 
    /* Search for the correct field structure */
 
        for (k=0; k<p_QDFFRINF->WDFFFLD; ++k) {
 
    /* Find the correct structure by finding a match for the */
 
    /* index into the field name table. */
 
        if (NtblIndex == p_QDFWFLDI->WDFWNMEI) {
 
            RCIndex = p_QDFWFLDI->WDFWRRDX; /* Row/Col index */
 
    /* Point to first Row/Col Entry */
 
    p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTB + sizeof(QDFFRCTB_t));
 
    /* Point to correct Row/Col Entry. Each entry is 2 bytes. */
 
    p_QDFFRCTE = (QDFFRCTE_t *)((char *) p_QDFFRCTE + ((RCIndex - 1) * 2 ));
 
        printf("\n%s %s Row and column (hex) %02x %02x",MyRec,MyField,
 
            *(char *) p_QDFFRCTE,*((char *) p_QDFFRCTE+1));
 
        return(0); /* Task is done */
 
 
     }
 
     }
    else
+
 
        p_QDFWFLDI = (QDFWFLDI_t *)((char *) p_QDFWFLDI + p_QDFWFLDI->WDFWFLDL);
+
 
    }
+
}
    }
+
 
    else {
+
int ProcessCat24() {
    /* Bump ptr to next record structure */
+
      /*-----------------------------------------------*/
        p_QDFWRCDI = (QDFWRCDI_t *)((char *) p_QDFWRCDI + p_QDFWRCDI->WDFWNXTR);
+
      /* This loops through all keywords that fall into*/
    RecNumber = RecNumber + 1;
+
      /* category 24  (Date, Time)                    */
        }
+
      /*-----------------------------------------------*/
    }
+
}
    }
+
 
    else
+
   
        NamePtr = NamePtr + 10; /* Size of field name*/
+
 
    }
+
 
    /* If this point is reached, the field was not found */
 
        printf("\nThe requested field was not found %s %s",MyRec,MyField);
 
    return (0);
 
  }
 
  
 
</pre>
 
</pre>

Revision as of 05:34, 2 September 2014


Contents

Introduction

C version of the RPG prpgram DSPINFO. (in development) is a work in progress



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


 /* 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 */

    typedef struct inputArguments
    {
        char *pgmname;
        char *Lib;
        char *File;
    } main_args_t;

    int FindRec (void);
    int FindField (void);

    int ProcessRec (void);
    int ProcessField (void);
    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 Format[8];
    char FileName[20] = "                    ";
    char RecordName[10];
    char ROW[2];
    char COL[2];
    char FldIO[1];
    char FldAtr[1];
    char FldNam[10];
    char FldCom[3000];
    char Fldblank[30] = "                              ";
    int  FldPlen;
    int  FldDec;



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


    char *p_file ;
    char *p_lib ;
    int  API_Len;

    p_file =  main_args->File;
    p_lib  =  main_args->Lib;


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

/* Point to your DSPF */
    memmove(FileName,p_file, strlen(p_file));
    memmove(FileName + 10 ,p_lib, strlen(p_lib ));


 /* 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);
    }


        printf("\nEnd of test");

    ProcessRec();


   free(ReturnVar);
 }

int ProcessRec() {

       int i;
    /* 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 */

     for (i=0; i<p_QDFFBASE->WDFFRCS; ++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(RecordName,p_QDFARFTE->WDFARFNM,sizeof(p_QDFARFTE->WDFARFNM));


     ProcessField();

    }

 }


int ProcessField() {

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

      /*  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 == 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));

       *ROW  =  p_QDFFRCTE->WDFFSROW;
       *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) */
       *FldIO     = p_QDFFFINF->WDFFFIOA;

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


        *FldAtr   = p_QDFFFNAM->WDFFKBDT;
        memcpy(FldNam,p_QDFFNTB->WDFFNAM,sizeof(p_QDFFNTB->WDFFNAM));
        memcpy(FldCom,"                              ",30);
        FldPlen  = p_QDFFFNAM->WDFFPLEN;
        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;
    }

 }


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 == 0x01)  {

         FldPlen  = p_QDFKDFPM->WDFKDFLN;
        *FldIO   = p_QDFFFINF->WDFFFIOA;


  p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) -1);

  memcpy(FldCom, p_KwdData->Temp, sizeof(p_QDFKDFPM->WDFKDFLN));

  ck=1;

      }

    }


}

int ProcessCat24() {
      /*-----------------------------------------------*/
      /* This loops through all keywords that fall into*/
      /*  category 24  (Date, Time)                    */
      /*-----------------------------------------------*/
}