|
The general format for a symbol statement is: symbol,value remark
The general coding rules are as follows: - Columns 1 through 80 are scanned.
- The symbol can start in column 1 or in any column after 1.
- A remark is optional, but if specified, must be separated from
the value by at least one blank. A remark is printed in SYMNOUT (if
specified), but otherwise not processed.
- A semicolon (;) can be used instead of a comma (,) between the
symbol and the value.
- Continuation is not allowed. Each symbol and value must be completely
specified on one line.
The specific syntax for symbol statements is:
>>-symbol,-+-constant-----+------------------------------------><
+-field--------+
'-parsed field-'
Symbol: A symbol can be 1 to 50 EBCDIC characters
consisting of uppercase letters (A-Z), lowercase letters (a-z), numbers
(0-9), the number sign (#), the dollar sign ($), the commercial at
sign (@), the underscore(_) and the hyphen(-). The first character
of a symbol must not be a number or a hyphen. Symbols are treated
as case-sensitive: Frank, FRANK and frank are three different symbols.
The following DFSORT/ICETOOL reserved words (uppercase
only as shown) are not allowed as symbols: A, AC, ADD, ADDDAYS,
ADDMONS, ADDYEARS, ALL, AND, AQ, ASL, AST, BI, CH, CLO, COPY,
COUNT, COUNT15, CSF, CSL, CST, CTO, D, DATE, DATEDIFF,
DATE1, DATE1..., DATE2, DATE2..., DATE3, DATE3..., DATE4, DATE5, DC1, DC2, DC3, DC4, DE1, DE2, DE3, DE4,
DIV, DT1, DT2, DT3, D1, D2, E, F, FI, FL, FS, H, HEX, LASTDAYM,
LASTDAYQ, LASTDAYW, LASTDAYY, LC, LN,
LS, MAX, MC, MIN, MN,
MOD, MUL, Mn, Mnn, NEXTDday, NONE, NUM, OL,
OR, OT, PAGE, PAGEHEAD, PD, PDC, PDF, PD0, PREVDday,
SEQNUM, SFF, SS, SUB, SUBCOUNT, SUBCOUNT15, SUBDAYS,
SUBMONS, SUBYEARS, TC1, TC2, TC3, TC4, TE1, TE2, TE3, TE4, TIME,
TIME1, TIME1P, TIME2, TIME2P, TIME3, TIME3P, TM1, TM2, TM3, TM4, TS, UC, UFF, UN, VALCNT, VLEN,
X, Y2x, Y2xx, Y4x, Z, ZD, ZDC, and ZDF, where
n is 0-9, day is SUN, MON, TUE, WED, THU, FRI or
SAT, and x is any character. Lower case and mixed case forms
of these words, such as None and page, can be used as symbols.
POSITION, SKIP and ALIGN (uppercase only) are treated as keywords
as discussed in Keyword statements and thus are not recognized
as symbols. However, lowercase and mixed case forms of these words,
such as Position and skip, can be used as symbols.
Some examples of valid symbols are: Account_Number, CON12, PHONE#,
count, SORT-KEY, and _Invalid.
Some examples of invalid symbols are: 123_Account (starts
with a number), COUNT (reserved word), DATE1-20 (reserved word), and
-Invalid (starts with a hyphen).
Constant: A constant can be a
character string, system symbol string, hexadecimal string, bit string,
decimal number, or two-digit year date string.
A symbol for a constant value must be used only where such a constant
is allowed and has the desired result. Otherwise, substitution of
the constant for the symbol will result in an error message or unintended
processing. For example, if the following SYMNAMES statement is specified: SYMB,B'10110001'
SYMB
can be used in this INCLUDE statement: INCLUDE COND=(12,1,BI,EQ,SYMB)
because
a bit string can be compared to a binary field. However, SYMB will
result in an error message if used in this INCLUDE statement: INCLUDE COND=(12,1,CH,EQ,SYMB)
because
a bit string cannot be compared to a character field.
Make sure the constants that will be substituted for your symbols
are appropriate. If in doubt, check the rules for constants given
in the description of the relevant operand.
A symbol can represent one of the following types of constants: - A character string in the format 'xx...x', C'xx...x' or c'xx...x'.
The
value x may be any EBCDIC character. You can specify up to 64 characters
for the string. c'xx...x' will be treated like C'xx...x'. Note: If you want to use system symbols (for example, &JOBNAME.)
in your character strings, use a system symbol string (S'string' or
s'string') as described later in this section instead
of a character string.
If you want to include
a single apostrophe in the character string, you must specify it as
two single apostrophes (each pair of apostrophes counts as two characters
towards the 64 character limit for the string). Thus: Required: O'Neill Specify: C'O''Neill'
Double-byte
data may be used in a character string (each pair of shift-in/shift-out
characters and each double-byte character counts as two characters
towards the 64 character limit for the string). See INCLUDE control statement
for details on double-byte data.
Some examples of valid character
strings are: '+0.193', c'Title', C'O''Neil', C'J62,J82,M72' and ''.
Some
examples of invalid character strings are: C'AB'' (apostrophes not
paired), c'title (ending apostrophe missing) and C'O'NEIL' (one apostrophe
after O instead of two).
You can use C'xx...x' and 'xx...x'
interchangeably. 'xx...x' will be substituted for symbols where appropriate
even if C'xx...x' is specified in SYMNAMES. Likewise, C'xx...x' will
be substituted for symbols where appropriate even if 'xx...x' is specified
in SYMNAMES. For example, if these SYMNAMES statements are specified: My_Title,c'My Report'
My_Heading,C'January'
DEPT1,'J82'
DEPT2,c'M72'
the ICETOOL operator: DISPLAY TITLE(My_Title) HEADER(My_Heading) ...
will
be transformed to: DISPLAY TITLE('My Report') HEADER('January') ...
and
the INCLUDE statement: INCLUDE COND=(5,3,EQ,DEPT1,OR,5,3,EQ,DEPT2),FORMAT=CH
will
be transformed to: INCLUDE COND=(5,3,EQ,C'J82',OR,5,3,EQ,C'M72'),FORMAT=CH
Although
the rules for character strings used as symbols generally follow the
rules for INCLUDE/OMIT character strings, keep in mind that the same
rules do not apply for character strings in all DFSORT and ICETOOL
operands, so use symbols representing character strings appropriately.
For example, ICETOOL only allows up to 50 characters for a TITLE
string, so TITLE(MYCON) would result in an error message if MYCON
is a 64-character string, even though MYCON could be used without
error in an INCLUDE statement. As another example, double-byte characters
would be recognized in a character string substituted for a symbol
in an INCLUDE statement, but would not be recognized in a character
string substituted in an OUTREC statement.
- A system symbol string in the format S'original_string'
or s'original_string'
The original_string can contain any
combination of EBCDIC characters and system symbols (&SYMBOL or &SYMBOL.)
you want to use to form a character string. DFSORT will replace each
system symbol in the system symbol string with its substitution text
to create a character string in the format C'result_string'.
For
example, you could specify the following symbol statement in SYMNAMES: Rpt_hdr,S' Job &JOBNAME. was run on Sysplex &SYSPLEX. on &LWDAY'
If
you used this symbol statement in a job named TEST2 that you ran on
sysplex MAS3 on a Thursday, DFSORT would transform it into the following
symbol statement: Rpt_hdr,C' Job TEST2 was run on Sysplex MAS3 on THU'
&JOBNAME.
was replaced with 'TEST2', &SYSPLEX. was replaced with 'MAS3'
and &LWDAY was replaced with 'THU'.
If you used this same
symbol statement in a job named BIGTEST that you ran on sysplex MAS2
on a Monday, DFSORT would transform it into the following symbol statement: Rpt_hdr,C' Job BIGTEST was run on Sysplex MAS2 on MON'
This
time &JOBNAME. was replaced with 'BIGTEST', &SYSPLEX. was
replaced with 'MAS2' and &LWDAY was replaced with 'MON'.
You
could use the Rpt_hdr symbol in an OUTFIL statement like this:
OUTFIL HEADER2=(Rpt_hdr,5X,'Page ',PAGE=(EDIT=(TTT)),/)
and
get the heading you needed based on the setting of the system symbol
values where and when the job was run.
The types of system symbols
you can use in a system symbol string are: - Dynamic system symbols like &YYMMDD, &LYYMMDD, &HHMMSS, &LHHMMSS, &DAY, &LDAY, &HR, &LHR, &JDAY, &LJDAY, &JOBNAME, &MIN, &LMIN, &MON,
&LMON, &SEC, &LSEC, &WDAY, &LWDAY, &YR2, &LYR2, &YR4,
and &LYR4.
- System-defined static system symbols like &SYSCLONE, &SYSNAME, &SYSPLEX, &SYSR1,
and &SYSALVL.
- Installation-defined static system symbols specified by your installation
in an IEASYMxx member of SYS1.PARMLIB.
Note: System symbols must be specified
using all uppercase characters. Lowercase characters are not recognized
as system symbols. For example, &JOBNAME is recognized as a system
symbol, but &jobname and &Jobname are not.
You
can use all three types of system symbols separately or in combination
within a system symbol string. You can also use all of the system
symbol string building facilities such as substring notation, concatenation,
embedded blanks, and so on, in a system symbol string. Thus, system
symbol strings can be very simple like this one: Sysname,s'&SYSNAME'
Or
more complex like this one: Dsn1,s'ACCT.&SYSNAME(3:2)..D&LJDAY'
For
more information on system symbols, see z/OS MVS Initialization and Tuning Reference. Note: JCL symbols and
IPCS symbols are not system symbols and will not be recognized or
replaced in a system symbol string.
s'original_string'
will be treated like S'original_string'.
If you want to include
a single apostrophe in the system symbol string, you must specify
it as two single apostrophes.
DFSORT uses the ASASYMBM service
to transform S'original_string' into C'result_string'. If your system
symbol string has errors involving symbol names, substring notation,
and so on, ASASYMBM transforms the symbol system string to a character
string according to its rules for substitution. For example, if you
specify these symbol statements: Ok,S'&YR4(1:2).&SYSNAME.'
Bad,S'&YR4(1.2).&SYSNAM.'
where the valid substring
notation 1:2 and the known system symbol &SYSNAME. (for example,
'ED53') are used for Ok, but the invalid substring notation 1.2 and
the unknown system symbol &SYSNAM. are used for Bad, the resulting
symbol statements are: Ok,C'20EDS3'
Bad,C'2006(1.2).&SYSNAM.'
See z/OS MVS Programming: Assembler Services Reference ABE-HSP for complete details on the ASASYMBM
service.
After a symbol statement containing a system symbol
string (S'original_string') is transformed into a symbol statement
containing the resulting character string (C'result_string'), it will
be error checked and processed like any other symbol statement containing
a character string. See the description of character string previously in this section for details.
If
a SYMNOUT data set is specified, it will show the symbol statement
containing the original system symbol string as well as the transformed
symbol statement containing the resulting character string. This
can be helpful for debugging "errors" or unexpected results in your
system symbol strings.
- A hexadecimal string in the format X'yy...yy' or x'yy...yy'.
The
value yy represents any pair of hexadecimal digits. Each hexadecimal
digit must be 0-9, A-F or a-f. You can specify up to 32 pairs of
hexadecimal digits. x'yy...yy' will be treated like X'yy...yy'. a-f
will be treated like A-F.
Some examples of valid hexadecimal
strings are: X'F2C3', x'2fa71e', and X'07'.
Some examples
of invalid hexadecimal strings are: X'F2G301' (G is not a valid hexadecimal
digit), x'bf3' (unpaired hexadecimal digits) and X'' (no hexadecimal
digits).
- A bit string in the format B'bbbbbbbb...bbbbbbbb' or b'bbbbbbbb...bbbbbbbb'.
The
value bbbbbbbb represents 8 bits that constitute a byte. Each bit
must be 1, 0 or . (period). You can specify up to 8 groups of 8 bits.
b'bbbbbbbb...bbbbbbbb' will be treated like B'bbbbbbbb...bbbbbbbb'.
Some
examples of valid bit strings are: B'01100100', b'11..00..000..111'
and B'11......'.
Some examples of invalid bit strings are:
B'0101' (not a multiple of eight bits), b'00..11....' (not a multiple
of eight bits), b'00000002' (2 is not a valid bit) and B'' (no bits).
- A decimal number in the format n, +n or -n. You can specify
from 1 to 31 significant digits.
Some examples of valid decimal
numbers are: +270, 270, 000036, +0 and -2000000.
Some
examples of invalid decimal numbers are: ++15 (too many plus signs),
280- (sign in wrong place) and 2.8 (period is not allowed).
- A two-digit year date string in the format Y'string' or y'string'.
string
can be: - yy, yyx,yyxx, yyxxx or yyxxxx where y is a hexadecimal year digit
(0-9) and x is a hexadecimal non-year digit (0-9).
- Uppercase, lowercase or mixed case forms of LOW, BLANKS,
or HIGH.
- A two-digit year date string in the format Y'datex',
Y'datex'+n or Y'datex'-n.
- datex can be uppercase, lowercase or mixed case forms of DATE1,
DATE2 or DATE3.
- n is a decimal number representing the number of days for DATE1
and DATE3, or the number of months for DATE2.
Some examples of valid two-digit year date
strings are: Y'99', y'00123', y'date2', Y'DATE1'+20, y'Date3'-1, and
Y'Blanks'.
Some examples of invalid two-digit year
date strings are: Y'9', y'AB123', Y'DATE2-3', and Y'blank'.
Field: A field can be specified as p,m,f
(position, length and format), p,m (position and length) or p (position
only).
A symbol for a field value must be used only where such a field
is allowed and has the desired result. Otherwise, substitution of
the field for the symbol will result in an error message or unintended
processing. For example, if the following SYMNAMES statement is specified: Field1,15,2,CH
Field1
can be used in a SORT statement such as: SORT FIELDS=(Field1,A)
because
a character field is allowed in a SORT statement. However, Field1
will result in an error message if used in a SUM statement such as: SUM FIELDS=(Field1)
because
a character field is not allowed in a SUM statement.
As another example, Field1: can be used in an INREC
statement such as: OUTFIL OVERLAY=(Field1:C'AB')
to
set the output column to 15, because column notation is allowed in
the BUILD, OVERLAY or PUSH operand of an INREC
or OUTREC statement and in the BUILD, OVERLAY, PUSH, TRLUPD, HEADERx, or TRAILERx operand of an OUTFIL
statement. However, Field1: will result in an error message if used
in any other operand, such as WHEN.
Make sure the fields that will be substituted for your
symbols are appropriate. If in doubt, check the rules for p, m, f,
and c: given in the description of the relevant operand.
You can specify p,m,f for your field symbols and then
use them where p,m is required because DFSORT or ICETOOL will substitute
just p,m when appropriate. You can specify p,m,f or p,m for your
field symbols and then use them where c: is required because DFSORT
will substitute just p: when appropriate. For example, if you specify
the following in SYMNAMES: First_Field,12,2,BI
Second_Field,18,6,CH
Third_Field,28,5,PD
Fourth_Field,36,3
Fifth_Field,52,4,PD
Max,200000
Outcol2,16
These DFSORT control statements: OMIT COND=(Fifth_Field,GT,Max)
SORT FIELDS=(First_Field,A,Fourth_Field,A),FORMAT=CH
SUM FIELDS=(Second_Field,ZD)
OUTFIL OUTREC=(First_Field:First_Field,
Outcol2:Third_Field,M11,
Fourth_Field)
will be transformed to: OMIT COND=(52,4,PD,GT,200000)
SORT FIELDS=(12,2,A,36,3,A),FORMAT=CH
SUM FIELDS=(18,6,ZD)
OUTFIL BUILD=(12:12,2,16:28,5,PD,M11,36,3)
Note that DFSORT
did the following substitutions: - OMIT statement: p,m,f for Fifth_Field as required by COND without
FORMAT.
- SORT statement: p,m for First_Field and Fourth_Field as required
by FIELDS with FORMAT.
- SUM statement: p,m for Second_Field as required for symbol,f
(that is, Second_Field,ZD).
- OUTFIL statement: p: for First_Field: and Outcol2:
as required by the OUTREC operand for an output column. p,m for
First_Field and Fourth_Field as required by the OUTREC operand for
an unedited field. p,m,f for Third_Field as required by the OUTREC
operand for an edited field (that is, Third_Field,M11).
The general rules for using p, m and f in symbol statements are
as follows: - p can be a number, an asterisk (*) or an
equal sign (=). A number from 1 to 32752 is allowed in p,m or p,m,f.
Because p (position only) cannot be distinguished from the constant
n, 1 to 15 significant digits are allowed for p (position only).
An
asterisk (*) can be used to assign the next position to
p. Each time a symbol for p,m,f or p,m is read, the next
position is set to p+m. Additionally, the next
position can be modified by keyword statements (see Keyword statements). When * is specified for p, the next
position is assigned to p. If the next position has
not been set when * is used for p (for example, * is used in the first
symbol), p is set to 1.
The symbol table printed in the SYMNOUT
data set (if specified) will show you the actual positions assigned
when you specify * for p.
As an example of how * can be used,
if you specify the following SYMNAMES statements: Sym1,*,5,ZD
Con1,27
Sym2,*,2,BI
Field1,8,13,CH
Field2,*,5,PD
Field3,*,2,FI
SYMNOUT will show the following symbol table: Sym1,1,5,ZD
Con1,27
Sym2,6,2,BI
Field1,8,13,CH
Field2,21,5,PD
Field3,26,2,FI
By using * for p, you can map consecutive
fields in your records without having to compute their actual positions.
You can also map fields added between other fields without having
to change the p values for the original or inserted fields. * is
also useful for creating mappings of contiguous fields using concatenated
symbol data sets. As a simple example, if you specify: //SYMNAMES DD DSN=MY.SYMPDS(RDW),DISP=SHR
// DD DSN=MY.SYMPDS(SECTION1),DISP=SHR
// DD DSN=MY.SYMPDS(SECTION2),DISP=SHR
and the RDW member
contains: RDW,1,4,BI
the SECTION1 member contains: Flag_Byte,*,1,BI
Error1,X'80'
Error2,X'40'
Count_of_Parts,*,5,ZD
and the SECTION2 member contains: New_Parts,*,5,ZD
Old_Parts,*,5,ZD
Variable_Fields,*
SYMNOUT will show the following symbol table: RDW,1,4,BI
Flag_Byte,5,1,BI
Error1,X'80'
Error2,X'40'
Count_of_Parts,6,5,ZD
New_Parts,11,5,ZD
Old_Parts,16,5,ZD
Variable_Fields,21
You might use these symbols in the following
statements: OPTION COPY
OUTFIL FNAMES=ERR1,INCLUDE=(Flag_Byte,EQ,Error1),
OUTREC=(RDW,Count_of_Parts,Variable_Fields)
OUTFIL FNAMES=ERR2,INCLUDE=(Flag_Byte,EQ,Error2),
OUTREC=(RDW,New_Parts,Old_Parts,Variable_Fields)
An
equal sign (=) can be used to assign the previous
position to p. Each time a symbol for p,m,f or p,m is read,
the previous position is set to p. Additionally,
the previous position can be modified by a
POSITION keyword statement (see later in this section).
When = is specified for p, the previous position is
assigned to p. If the previous position has
not been set when = is used for p, an error message is issued.
The
symbol table printed in the SYMNOUT data set (if specified) will show
you the actual positions assigned when you specify = for p.
As
an example of how = can be used for p, if you specify the following
SYMNAMES statements: Sym1,5,4,CH
Sym2,=,2,CH
Sym3,*,2,CH
SYMNOUT will show the following symbol table: Sym1,5,4,CH
Sym2,5,2,CH
Sym3,7,2,CH
By using = and * for p, you can easily map fields
onto other fields.
Whenever you use = for p, you must ensure
that the previous position is the one you
want. In particular, if you insert a new field symbol with the wrong
position before a symbol that uses = for p, you will need to change
= to the actual position you want.
- m can be an equal sign (=) or a number from
1 to 32752. An equal sign (=) can be used to assign the previous length to m. Each time a symbol for p,m,f
or p,m is read, the previous length is set
to m. When = is specified for m, the previous
length is assigned to m. If the previous length has
not been set when = is used for m, an error message is issued.
The
symbol table printed in the SYMNOUT data set (if specified) will show
you the actual lengths assigned when you specify = for m.
As
an example of how = can be used for m, if you specify the following
SYMNAMES statements: Flags1,5,1,BI
Error1,X'08'
Flags2,15,=,BI
Error2,X'04'
Flags3,22,=,BI
Error3,X'23'
SYMNOUT will show the following symbol table: Flags1,5,1,BI
Error1,X'08'
Flags2,15,1,BI
Error2,X'04'
Flags3,22,1,BI
Error3,X'23'
Whenever you use = for m, you must ensure
that the previous length is the one you want.
In particular, if you insert a new field symbol with the wrong length
before a symbol that uses = for m, you will need to change = to the
actual length you want.
- f can be an equal sign (=) or one of the following formats:
AC, AQ, ASL, AST, BI, CH, CLO, CSF, CSL, CST, CTO, DC1, DC2, DC3,
DE1, DE2, DE3, DT1, DT2, DT3, D1, D2, FI, FL, FS, LS, OL, OT, PD,
PD0, SFF, SS, TC1, TC2, TC3, TC4, TE1, TE2, TE3, TE4, TM1, TM2, TM3,
TM4, TS, UFF, Y2B, Y2C, Y2D, Y2DP, Y2P, Y2PP, Y2S, Y2T, Y2TP, Y2U,
Y2UP, Y2V, Y2VP, Y2W, Y2WP, Y2X, Y2XP, Y2Y, Y2YP, Y2Z, Y4T,
Y4U, Y4V, Y4W, Y4X, Y4Y or ZD.
You can specify f using uppercase
letters (for example, CH), lowercase letters (for example, ch) or
mixed case letters (for example, Ch). f specified in any case will
be treated like uppercase.
An equal sign (=) can be used to
assign the previous format to f. Each time
a symbol for p,m,f is read, the previous format is
set to f. When = is specified for f, the previous
format is assigned to f. If the previous format has
not been set when = is used for f, an error message is issued.
The
symbol table printed in the SYMNOUT data set (if specified) will show
you the actual formats assigned when you specify = for f.
As
an example of how = can be used for f, if you specify the following
SYMNAMES statements: Field1,5,8,CH
Field1a,=,3
Field2,*,12,=
Field3,*,20,=
SYMNOUT will show the following symbol table: Field1,5,8,CH
Field1a,5,3
Field2,8,12,CH
Field3,20,20,CH
Whenever you use = for f, you must ensure
that the previous format is the one you want.
In particular, if you insert a new field symbol with the wrong format
before a symbol that uses = for f, you will need to change = to the
actual format you want.
Parsed field: A
parsed field can be specified as %nnn with nnn as 000-999, %nn with
nn as 00-99 or as %n with n as 0-9. %0n will be substituted for %n
and %00n. %nn will be substitued for %0nn. A symbol for a parsed
field must be used only where such a field is allowed and has the
desired result. Otherwise, substitution of %nn for the symbol will
result in an error message. For example, if the following SYMNAMES
statement is specified: Revenue,%03
Revenue can be used
in an OUTREC statement such as: OUTREC PARSE=(Revenue=(STARTAT=C'+',FIXLEN=9)),
OVERLAY=(31:Revenue,UFF,EDIT=(III,IIT,TTT))
because
a parsed field is allowed in the PARSE operand and the OVERLAY operand.
However, Revenue will result in an error message if used in a SORT
statement such as: SORT FIELDS=(Revenue,UFF,A)
because
a parsed field is not allowed in a SORT statement.
Make sure the parsed fields that will be substituted
for your symbols are appropriate. If in doubt, check the rules for
%nn given in the description of the relevant
operand.
As an example of how parsed fields can be used, if you
specify the following SYMNAMES statements: branch,1,7
tab,X'05'
comma,','
first_name,%00
last_name,%1
date,%02
company,%03
city,%004
state,%305
SYMNOUT will show the following symbol table:
branch,1,7
tab,X'05'
comma,C','
first_name,%00
last_name,%01
date,%02
company,%03
city,%04
state,%305
This DFSORT control statement: INREC PARSE=(first_name=(ABSPOS=9,FIXLEN=12,ENDBEFR=comma),
last_name=(FIXLEN=15,ENDBEFR=comma),
%=(ENDBEFR=tab),
date=(FIXLEN=10,ENDBEFR=tab),
company=(FIXLEN=31,ENDBEFR=tab),
city=(FIXLEN=14,ENDBEFR=tab),
state=(FIXLEN=12)),
BUILD=(branch,9:first_name,22:last_name,
38:date,JFY=(SHIFT=RIGHT),
49:company,83:city,98:state)
will be transformed
to: INREC PARSE=(%00=(ABSPOS=9,FIXLEN=12,ENDBEFR=C','),%01=(FIXLEN=15,ENDB*
EFR=C','),%=(ENDBEFR=X'05'),%02=(FIXLEN=10,ENDBEFR=X'05'*
),%03=(FIXLEN=31,ENDBEFR=X'05'),%04=(FIXLEN=14,ENDBEFR=X*
'05'),%05=(FIXLEN=12)),BUILD=(1,7,9:%00,22:%01,38:%02,JF*
Y=(SHIFT=RIGHT),49:%03,83:%04,98:%305)
|