DSECT Utility options

FLAGFLD   DS   F
          ORG  FLAGFLD+0
B1FLG1    DC   0XL(B'10000000')'00'    Definition for bit 0 of 1st byte
B1FLG2    DC   0XL(B'01000000')'00'    Definition for bit 1 of 1st byte
B1FLG3    DC   0XL(B'00100000')'00'    Definition for bit 2 of 1st byte
B1FLG4    DC   0XL(B'00010000')'00'    Definition for bit 3 of 1st byte
B1FLG5    DC   0XL(B'00001000')'00'    Definition for bit 4 of 1st byte
B1FLG6    DC   0XL(B'00000100')'00'    Definition for bit 5 of 1st byte
B1FLG7    DC   0XL(B'00000010')'00'    Definition for bit 6 of 1st byte
B1FLG8    DC   0XL(B'00000001')'00'    Definition for bit 7 of 1st byte
          ORG  FLAGFLD+1
B2FLG1    DC   0XL(B'10000000')'00'    Definition for bit 0 of 2nd byte
B2FLG2    DC   0XL(B'01000000')'00'    Definition for bit 1 of 2nd byte
B2FLG3    DC   0XL(B'00100000')'00'    Definition for bit 2 of 2nd byte
B2FLG4    DC   0XL(B'00010000')'00'    Definition for bit 3 of 2nd byte

TM   FLAGFLD,L'B1FLG1          Test bit 0 of byte 1
Bx   label                     Branch if set/not set

• The field does not have a duplication factor of zero.
• The field has a length 1 - 4 bytes and does not have a bit length.
• The field does not have more than one nominal value.

• Has a Type attribute of B, C, or X.
• Has the same offset as the field (or consecutive fields have overlapping offsets).
• Has a duplication factor of zero.
• Does not have more than one nominal value.
• Has a length attribute 1 - 255 and does not have a bit length.
• The length attribute maps 1 bit or consecutive bits; for example, B'10000000' or B'11000000', but not B'10100000'.

/**< comment text */

struct IAZJSAB {
unsigned char JSABID[4];   /**< JSAB ID             */
void         *JSABNEXT;    /**< JSAB CHAIN FIELD    */
…
/* Values for field "JSABVERS" */
#define JSABVRS1 1    /**< JSAB version 1          @Z21LSYM */
#define JSABVRS2 2    /**< JSAB version 2          @Z21LSYM */
#define JSABVRSN 2    /**< Current JSAB version    @Z21LSYM */

TRACK    DSECT                                                         
FIELD_1  DS FL1   Comment with an empty continuation line not respected C
                                                                       
FIELD_2  DS FL2                                                        
FIELD_N  DS FL1                                                        
         END        

struct track {
  char           field_1; /* Comment with empty continuation line not respected */
  short int      field_1; /* Comment with empty continuation line not respected */
  char           field_n;
  };

TRACK    DSECT                                                         
FIELD_1  DS FL1   Comment with an empty continuation line not respected C
               .                                                       
FIELD_2  DS FL2                                                        
FIELD_N  DS FL1    

char           field_1; /* Comment with an empty continuation line not respected  */
  short int      field_2;
  char           field_n;
  };

#ifndef __decimal_found
     #define __decimal_found
     #ifdef __cplusplus
         #define _dec__var(w,p)  decimal<n>
             #define _dec_uvar(w,p) _decchar##w
         #include <idecimal.hpp>
             typedef char _decchar1[1];
             typedef char _decchar2[2];
             typedef char _decchar3[2];
             typedef char _decchar4[3];
             typedef char _decchar5[3];
             typedef char _decchar6[4];
             typedef char _decchar7[4];
             typedef char _decchar8[5];
             typedef char _decchar9[5];
             typedef char _decchar10[6];
             typedef char _decchar11[6];
             typedef char _decchar12[7];
             typedef char _decchar13[7];
             typedef char _decchar14[8];
             typedef char _decchar15[8];
             typedef char _decchar16[9];
             typedef char _decchar17[9];
             typedef char _decchar18[10];
             typedef char _decchar19[10];
             typedef char _decchar20[[11];
             typedef char _decchar21[11];
             typedef char _decchar22[12];
             typedef char _decchar23[12];
             typedef char _decchar24[13];
             typedef char _decchar25[13];
             typedef char _decchar26[14];
             typedef char _decchar27[14];
             typedef char _decchar28[15];
             typedef char _decchar29[15];
             typedef char _decchar30[16];
             typedef char _decchar31[16];
     #else
         #define _dec__var(w,p)  decimal(n,p)
             #define _dec_uvar(w,p) decimal(w,p)
         #include <decimal.h>
     #endif
 #endif

struct dsect_name {
  int           field1;
  struct {
    int           _subfld1;
    short int     _subfld2;
    unsigned char _subfld3[4];
    } field2;
  }
#define subfld1  field2._subfld1
#define subfld2  field2._subfld2
#define subfld3  field2._subfld3

BIT

Indicates that the value for an EQU statement is used to define the bits for a field where the field conforms to the following rules:

• The field does not have a duplication factor of zero.
• The field has a length 1 - 4 bytes and has a bit length that is a multiple of 8.
• The field does not have more than one nominal value.

And the EQU statements that follow the field conform to the following rules:

• The value for the EQU statements that follow the field mask consecutive bits (for example, X'80' followed by X'40').
• The value for an EQU statement masks 1 bit or consecutive bits, for example, B'10000000' or B'11000000', but not B'10100000'.
• Where the length of the field is greater than 1 byte, the bits for the remaining bytes can be defined by providing the EQU statements for the second byte after the EQU statement for the first byte.
• The value for the EQU statement is not a relocatable value.

Example: When you specify EQUATE(BIT), the EQU statements are converted as in the following example:

FLAGFLD  DS   H
FLAG21   EQU  X'80'
FLAG22   EQU  X'40'
FLAG23   EQU  X'20'
FLAG24   EQU  X'10'
FLAG25   EQU  X'08'
FLAG26   EQU  X'04'
FLAG27   EQU  X'02'
FLAG28   EQU  X'01'
FLAG2A   EQU  X'80'
FLAG2B   EQU  X'40'
struct dsect_name {
  unsigned int flag21   : 1,
               flag22   : 1,
               flag23   : 1,
               flag24   : 1,
               flag25   : 1,
               flag26   : 1,
               flag27   : 1,
               flag28   : 1,
               flag2a   : 1,
               flag2b   : 1,
                        : 6;
  }

BITL

Indicates that the length attribute for an EQU statement is used to define the bits for a field where the field conforms to the following rules:

• The field does not have a duplication factor of zero.
• The field has a length 1 - 4 bytes and has a bit length that is a multiple of 8.
• The field does not have more than one nominal value.

And the EQU statements that follow the field conform to the following rules:

• The value that is specified for the EQU statement has the same or overlapping offset as the field.
• The length attribute for the EQU statement is in the range 1 - 255.
• The length attribute for the EQU statement masks 1 bit or consecutive bits; for example, B'10000000' or B'11000000', but not B'10100000'.
• The value for the EQU statement is a relocatable value.

Example: When you specify EQUATE(BITL), the EQU statements are converted as in the following example:

BYTEFLD   DS   F
B1FLG1    EQU  BYTEFLD+0,B'10000000'
B1FLG2    EQU  BYTEFLD+0,B'01000000'
B1FLG3    EQU  BYTEFLD+0,B'00100000'
B1FLG4    EQU  BYTEFLD+0,B'00010000'
B1FLG5    EQU  BYTEFLD+0,B'00001000'
B1FLG6    EQU  BYTEFLD+0,B'00000100'
B1FLG7    EQU  BYTEFLD+0,B'00000010'
B1FLG8    EQU  BYTEFLD+0,B'00000001'
B2FLG1    EQU  BYTEFLD+1,B'10000000'
B2FLG2    EQU  BYTEFLD+1,B'01000000'
B2FLG3    EQU  BYTEFLD+1,B'00100000'
B2FLG4    EQU  BYTEFLD+1,B'00010000'
struct dsect_name {
  unsigned int b1flg1  : 1,
               b1flg2  : 1,
               b1flg3  : 1,
               b1flg4  : 1,
               b1flg5  : 1,
               b1flg6  : 1,
               b1flg7  : 1,
               b1flg8  : 1,
               b2flg1  : 1,
               b2flg2  : 1,
               b2flg3  : 1,
               b2flg4  : 1,
                       : 20;
  }

DEF

Indicates that the EQU statements following a field are used to build #define directives to define the possible values for a field. The #define directives are placed after the end of the structure. The EQU statements should not specify a relocatable value.

Example: When you specify EQUATE(DEF), the EQU statements are converted as in the following example:

FLAGBYTE DS   X
FLAG1    EQU  X'80'
FLAG2    EQU  X'20'
FLAG3    EQU  X'10'
FLAG4    EQU  X'08'
FLAG5    EQU  X'06'
FLAG6    EQU  X'01'
struct dsect_name {
  unsigned char flagbyte;
  }
/* Values for flagbyte field */
#define flag1 0x80
#define flag2 0x20
#define flag3 0x10
#define flag4 0x08
#define flag5 0x06
#define flag6 0x01

DEFP

Indicates that the EQU statements appearing before the first DSECT section generate appropriate #define directives. EQU(DEFP) must be specified with EQU(DEF) or EQU(DEFS); otherwise, it is ignored.

For the following code:

HEX10    EQU   C'10'
HEX11    EQU   C'11'
HEX12    EQU   C'12'
HEX13    EQU   C'13'
MYDSECT  DSECT
WORD1    DS    F
WORD2    DS    F

• If EQU(DEFS, DEFP) is specified, the DSECT utility generates the following code:

  struct MYDSECT {
    int WORD1;
    int WORD2;
  };
  
  #define HEX10 "10"
  #define HEX11 "11"
  #define HEX12 "12"
  #define HEX13 "13"
  

• If EQU(DEF, DEFP) is specified, the DSECT utility generates the following code:

  struct MYDSECT {
    int WORD1;
    int WORD2;
  };
  
  #define HEX10 0xF1F0
  #define HEX11 0xF1F1
  #define HEX12 0xF1F2
  #define HEX13 0xF1F3
  

DEFS

EQU(DEFS) is equivalent to EQU(DEF) with the exception of generating string literals as opposed to hex values for EQU asm instruction with C type operand in the range of 1 - 4 bytes. EQU(DEFS) can be specified together with other suboptions like BIT and BIFS, but not with DEF.

Example: When you specify EQUATE(DEFS), the EQU statements are converted as in the following example:

MYDSECT  DSECT         
KEYS      DS CL4       
KEY1      EQU C'KEY1'  
KEY2      EQU C'KEY2'  
KEY3      EQU C'KEY3'  
             END          
struct mydsect {                    
  unsigned char  keys;           
  };                                
/* Values for field "keys" */       
#define key1 "KEY1"                 
#define key2 "KEY2"                 
#define key3 "KEY3"

SECTNAME DSECT
PREFIX1  DS   CL4
PREFIX2  DS   CL4
FIELD1   DS   CL4
FIELD2   DS   CL4
struct sectname {
  unsigned char field1[4];
  unsigned char field2[4];
  }

TEST       DSECT
FIELD1     DS    AL1
FIELD2     DS    AL2
FIELD3     DS    AL3
DSECTEND   DS    0D
LEN        EQU   *-TEST
END

struct test {
  unsigned char  field1;
  unsigned short field2;
  unsigned int   field3 : 24;
  unsigned char  _filler1[2];
  __extension__ double         dsectend[0];
  };

struct test {
  unsigned char  field1;
  unsigned short field2;
  unsigned int   field3 : 24;
  unsigned char  _filler1[2];
  double         dsectend;
  };

ABC     DSECT
F32      DS   2X
F32A     DS   0XL(B'00000010')'00'
F32B     DS   0XL(B'00000001')'00'
         END

struct abc {
unsigned char f32[2];
__extension__ union {
unsigned char _f32a[2];
unsigned char _f32b;
} _abc_union1[0];
};

#define f32a _abc_union1[0]._f32a
#define f32b _abc_union1[0]._f32b

struct abc {
  unsigned char  f32[2];
  struct {
   unsigned char  _f32b;
   unsigned char  _filler1;
   } f32a;
  };
#define f32b     f32a._f32b

• The lines must begin with the SECT option, and only one section name must be specified. The options following determine how the structure is produced for the specified section. The section name must only be specified once.
• The lines might contain the BITF0XL, COMMENT, DEFSUB, EQUATE, HDRSKIP, INDENT, LOWERCASE, PPCOND, and UNNAMED options, which are separated by spaces or commas. These override the options that are specified on the command line for the section.

#ifndef switch
#define switch
⋮
  structure definition for section
⋮
#endif

# = unique string + 'n' + unique string
@ = unique string + 'a' + unique string
$ = unique string + 'd' + unique string

# = _n_
@ = a_
$ = _d_

//DSECTUT  EXEC PROC=EDCDSECT,                         
//         DPARM='OUTPUT(DD:MYOUT)',                   
//         OUTFILE='NULLFILE'                          
//DSECT.MYOUT    DD    SYSOUT=*