Difference between revisions of "CQDFRTVFD"

From MidrangeWiki
Jump to: navigation, search
(Introduction)
m (fix)
Line 414: Line 414:
 
   p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) -1);
 
   p_KwdData =  (KwdData_t *) ((char *) p_QDFKDFPM + sizeof(QDFKDFPM_t) -1);
  
   memcpy(FldCom, p_KwdData->Temp, sizeof(p_QDFKDFPM->WDFKDFLN));
+
   memcpy(FldCom, p_KwdData->Temp, p_QDFKDFPM->WDFKDFLN);
  
 
   ck=1;
 
   ck=1;

Revision as of 11:17, 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, p_QDFKDFPM->WDFKDFLN);

  ck=1;

      }

    }


}

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