Appendix B

BNF Grammar


This appendix provides a complete description of symbols, operators, and directives for MASM 6.1. It uses the Backus-Naur Form (BNF) for grammar notation. You can use BNF grammar to determine the exact syntax for any language component and find all available options for any MASM command.

BNF definitions consist of “nonterminals” and “terminals.” Nonterminals are placeholders within a BNF definition, defined elsewhere in the BNF grammar. Terminals are endpoints in a BNF definition, consisting of MASM 6.1 keywords. In this Appendix, all nonterminals appear in italics type and all terminals appear in bold type.

BNF Conventions

The conventions use different font attributes for different items in the BNF. The symbols and formats are as follows:

Attribute

Description

nonterminal

Italic type indicates nonterminals.

RESERVED

Terminals in boldface type are literal reserved words and symbols that must be entered as shown. Characters in this context are always case insensitive.

[[ ]]

Objects enclosed in double brackets ([[ ]]) are optional. The brackets do not actually appear in the source code.

|

A vertical bar indicates a choice between the items on each side of the bar.

.8086

Underlined items indicate the default option if one is given.

default typeface

Characters in the set described or listed can be used as terminals in MASM statements.

 

 

How to Use the BNF Grammar

To illustrate the use of the BNF, Figure B.1 diagrams the definition of the TYPEDEF directive, starting with the nonterminal typedefDir.

The entries under each horizontal brace in Figure B.1 are terminals (such as NEAR16, NEAR32, FAR16, and FAR32) or nonterminals (such as qualifier, qualifiedType, distance, and protoSpec) that can be further defined. Each italicized nonterminal in the typedefDir definition is also an entry in the BNF. Three vertical dots indicate a branching definition for a nonterminal that, for the sake of simplicity, this figure does not illustrate.

The BNF grammar allows recursive definitions. For example, the grammar uses qualifiedType as a possible definition for qualifiedType, which is also a component of the definition for qualifier.

   

Figure B.1    BNF Definition of the TYPEDEF Directive

Nonterminal

Definition

;;

endOfLine
| comment

=Dir

id = immExpr ;;

addOp

+ | -

aExpr

term
| aExpr && term

 

Nonterminal

Definition

altId

id

arbitraryText

charList

asmInstruction

mnemonic [[ exprList ]]

assumeDir

ASSUME assumeList ;;
| ASSUME NOTHING ;;

assumeList

assumeRegister
| assumeList , assumeRegister

assumeReg

register : assumeVal

assumeRegister

assumeSegReg
| assumeReg

assumeSegReg

segmentRegister : assumeSegVal

assumeSegVal

frameExpr
| NOTHING | ERROR

assumeVal

qualifiedType
| NOTHING | ERROR

bcdConst

[[ sign ]] decNumber

binaryOp

== | != | >= | <= | > | < | &

bitDef

bitFieldId : bitFieldSize [[ = constExpr ]]

bitDefList

bitDef
| bitDefList , [[ ;; ]] bitDef

bitFieldId

id

bitFieldSize

constExpr

blockStatements

directiveList
| .CONTINUE [[ .IF cExpr ]]
| .BREAK [[ .IF cExpr ]]

bool

TRUE | FALSE

byteRegister

AL | AH | BL | BH | CL | CH | DL | DH

cExpr

aExpr
| cExpr || aExpr

character

Any character with ordinal in the range 0–255
except linefeed (10)

charList

character
| charList character

className

string

commDecl

[[ nearfar ]] [[ langType ]] id : commType
[[ : constExpr ]]

commDir

COMM commList ;;

comment

; text ;;

 

Nonterminal

Definition

commentDir

COMMENT delimiter
text
text delimiter text ;;

commList

commDecl
| commList , commDecl

commType

type
| constExpr

constant

digits [[ radixOverride ]]

constExpr

expr

contextDir

PUSHCONTEXT contextItemList ;;
| POPCONTEXT contextItemList ;;

contextItem

ASSUMES | RADIX | LISTING | CPU | ALL

contextItemList

contextItem
| contextItemList , contextItem

controlBlock

whileBlock
| repeatBlock

controlDir

controlIf
| controlBlock

controlElseif

.ELSEIF cExpr ;;
directiveList
[[ controlElseif ]]

controlIf

.IF cExpr ;;
directiveList
[[ controlElseif ]]
[[ .ELSE ;;
directiveList ]]
.ENDIF ;;

coprocessor

.8087 | .287 | .387 | .NO87

crefDir

crefOption ;;

crefOption

.CREF
| .XCREF [[ idList ]]
| .NOCREF [[ idList ]]

cxzExpr

expr
| ! expr
| expr == expr
| expr != expr

dataDecl

DB | DW | DD | DF | DQ | DT | dataType | typeId

dataDir

[[ id ]] dataItem ;;

 

Nonterminal

Definition

dataItem

dataDecl scalarInstList
| structTag structInstList
| typeId structInstList
| unionTag structInstList
| recordTag recordInstList

dataType

BYTE | SBYTE | WORD | SWORD | DWORD
| SDWORD | FWORD | QWORD | TBYTE
| REAL4 | REAL8 | REAL10

decdigit

0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

decNumber

decdigit
| decNumber decdigit

delimiter

Any character except whiteSpaceCharacter

digits

decdigit
| digits decdigit
| digits hexdigit

directive

generalDir
| segmentDef

directiveList

directive
| directiveList directive

distance

nearfar
| NEAR16 | NEAR32 | FAR16 | FAR32

e01

e01 orOp e02
| e02

e02

e02 AND e03
| e03

e03

NOT e04
| e04

e04

e04 relOp e05
| e05

e05

e05 addOp e06
| e06

e06

e06 mulOp e07
| e06 shiftOp e07
| e07

e07

e07 addOp e08
| e08

e08

HIGH e09
| LOW e09
| HIGHWORD e09
| LOWWORD e09
| e09

 

Nonterminal

Definition

e09

OFFSET e10
| SEG e10
| LROFFSET e10
| TYPE e10
| THIS e10
| e09 PTR e10
| e09 : e10
| e10

e10

e10 . e11
| e10 [[ expr ]]
| e11

e11

( expr )
| [[ expr ]]
| WIDTH id
| MASK id
| SIZE sizeArg
| SIZEOF sizeArg
| LENGTH id
| LENGTHOF id
| recordConst
| string
| constant
| type
| id
| $
| segmentRegister
| register
| ST
| ST ( expr )

echoDir

ECHO arbitraryText ;;
%OUT arbitraryText ;;

elseifBlock

elseifStatement ;;
directiveList
[[ elseifBlock ]]

elseifStatement

ELSEIF constExpr
| ELSEIFE constExpr
| ELSEIFB textItem
| ELSEIFNB textItem
| ELSEIFDEF id
| ELSEIFNDEF id
| ELSEIFDIF textItem , textItem
| ELSEIFDIFI textItem , textItem
| ELSEIFIDN textItem , textItem
| ELSEIFIDNI textItem , textItem
| ELSEIF1
| ELSEIF2

 

Nonterminal

Definition

endDir

END [[ immExpr ]] ;;

endpDir

procId ENDP ;;

endsDir

id ENDS ;;

equDir

textMacroId EQU equType ;;

equType

immExpr
| textLiteral

errorDir

errorOpt ;;

errorOpt

.ERR [[ textItem ]]
| .ERRE constExpr [[ optText ]]
| .ERRNZ constExpr [[ optText ]]
| .ERRB textItem [[ optText ]]
| .ERRNB textItem [[ optText ]]
| .ERRDEF id [[ optText ]]
| .ERRNDEF id [[ optText ]]
| .ERRDIF textItem , textItem [[ optText ]]
| .ERRDIFI textItem , textItem [[ optText ]]
| .ERRIDN textItem , textItem [[ optText ]]
| .ERRIDNI textItem , textItem [[ optText ]]
| .ERR1 [[ textItem ]]
| .ERR2 [[ textItem ]]

exitDir

.EXIT [[ expr ]] ;;

exitmDir:

EXITM
| EXITM textItem

exponent

E [[ sign ]] decNumber

expr

SHORT e05
| .TYPE e01
| OPATTR e01
| e01

exprList

expr
| exprList , expr

externDef

[[ langType ]] id [[ ( altId ) ]] : externType

externDir

externKey externList ;;

externKey

EXTRN | EXTERN | EXTERNDEF

externList

externDef
| externList , [[ ;; ]] externDef

externType

ABS
| qualifiedType

fieldAlign

constExpr

fieldInit

[[ initValue ]]
| structInstance

 

Nonterminal

Definition

fieldInitList

fieldInit
| fieldInitList , [[ ;; ]] fieldInit

fileChar

delimiter

fileCharList

fileChar
| fileCharList fileChar

fileSpec

fileCharList
| textLiteral

flagName

ZERO? | CARRY? | OVERFLOW?
| SIGN? | PARITY?

floatNumber

[[ sign ]] decNumber . [[ decNumber ]] [[ exponent ]]
| digits R
| digits r

forcDir

FORC | IRPC

forDir

FOR | IRP

forParm

id [[ : forParmType ]]

forParmType

REQ
| = textLiteral

frameExpr

SEG id
| DGROUP : id
| segmentRegister : id
| id

generalDir

modelDir | segOrderDir | nameDir
| includeLibDir | commentDir
| groupDir | assumeDir
| structDir | recordDir | typedefDir
| externDir | publicDir | commDir | protoTypeDir
| equDir | =Dir | textDir
| contextDir | optionDir | processorDir
| radixDir
| titleDir | pageDir | listDir
| crefDir | echoDir
| ifDir | errorDir | includeDir
| macroDir | macroCall | macroRepeat | purgeDir
| macroWhile | macroFor | macroForc
| aliasDir

gpRegister

AX | EAX | BX | EBX | CX | ECX | DX | EDX
| BP | EBP | SP | ESP | DI | EDI | SI | ESI

groupDir

groupId GROUP segIdList

groupId

id

hexdigit

a | b | c | d | e | f
| A | B | C | D | E | F

 

Nonterminal

Definition

id

alpha
| id alpha
| id decdigit

idList

id
| idList , id

ifDir

ifStatement ;;
directiveList
[[ elseifBlock ]]
[[ ELSE ;;
directiveList ]]
ENDIF ;;

ifStatement

IF constExpr
| IFE constExpr
| IFB textItem
| IFNB textItem
| IFDEF id
| IFNDEF id
| IFDIF textItem , textItem
| IFDIFI textItem , textItem
| IFIDN textItem , textItem
| IFIDNI textItem , textItem
| IF1
| IF2

immExpr

expr

includeDir

INCLUDE fileSpec ;;

includeLibDir

INCLUDELIB fileSpec ;;

initValue

immExpr
| string
| ?
| constExpr DUP ( scalarInstList )
| floatNumber
| bcdConst

inSegDir

[[ labelDef ]] inSegmentDir

inSegDirList

inSegDir
| inSegDirList inSegDir

 

Nonterminal

Definition

inSegmentDir

instruction
| dataDir
| controlDir
| startupDir
| exitDir
| offsetDir
| labelDir
| procDir [[ localDirList ]] [[ inSegDirList ]] endpDir
| invokeDir
| generalDir

instrPrefix

REP | REPE | REPZ | REPNE | REPNZ | LOCK

instruction

[[ instrPrefix ]] asmInstruction

invokeArg

register :: register
| expr
| ADDR expr

invokeDir

INVOKE expr [[ , [[ ;; ]] invokeList ]] ;;

invokeList

invokeArg
| invokeList , [[ ;; ]] invokeArg

keyword

Any reserved word

keywordList

keyword
| keyword keywordList

labelDef

id :
| id ::
| @@:

labelDir

id LABEL qualifiedType ;;

langType

C | PASCAL | FORTRAN | BASIC
| SYSCALL | STDCALL

listDir

listOption ;;

listOption

.LIST
| .NOLIST | .XLIST
| .LISTALL
| .LISTIF | .LFCOND
| .NOLISTIF | .SFCOND
| .TFCOND
| .LISTMACROALL | .LALL
| .NOLISTMACRO | .SALL
| .LISTMACRO | .XALL

localDef

LOCAL idList ;;

localDir

LOCAL parmList ;;

localDirList

localDir
| localDirList localDir

 

Nonterminal

Definition

localList

localDef
| localList localDef

macroArg

% constExpr
| % textMacroId
| % macroFuncId ( macroArgList )
| string
| arbitraryText
| < arbitraryText >

macroArgList

macroArg
| macroArgList , macroArg

macroBody

[[ localList ]]
macroStmtList

macroCall

id macroArgList ;;
| id ( macroArgList )

macroDir

id MACRO [[ macroParmList ]] ;;
macroBody
ENDM ;;

macroFor

forDir forParm , < macroArgList > ;;
macroBody
ENDM ;;

macroForc

forcDir id , textLiteral ;;
macroBody
ENDM ;;

macroFuncId

id

macroId

macroProcId
| macroFuncId

macroIdList

macroId
| macroIdList , macroId

macroLabel

id

macroParm

id [[ : parmType ]]

macroParmList

macroParm
| macroParmList , [[ ;; ]] macroParm

macroProcId

id

macroRepeat

repeatDir constExpr ;;
macroBody
ENDM ;;

macroStmt

directive
| exitmDir
| : macroLabel
| GOTO macroLabel

 

Nonterminal

Definition

macroStmtList

macroStmt ;;
| macroStmtList macroStmt ;;

macroWhile

WHILE constExpr ;;
macroBody
ENDM ;;

mapType

ALL | NONE | NOTPUBLIC

memOption

TINY | SMALL | MEDIUM | COMPACT
| LARGE | HUGE | FLAT

mnemonic

Instruction name

modelDir

.MODEL memOption [[ , modelOptlist ]] ;;

modelOpt

langType
| stackOption

modelOptlist

modelOpt
| modelOptlist , modelOpt

module

[[ directiveList ]] endDir

mulOp

* | / | MOD

nameDir

NAME id ;;

nearfar

NEAR | FAR

nestedStruct

structHdr [[ id ]] ;;
structBody
ENDS ;;

offsetDir

offsetDirType ;;

offsetDirType

EVEN
| ORG immExpr
| ALIGN [[ constExpr ]]

offsetType

GROUP | SEGMENT | FLAT

oldRecordFieldList

[[ constExpr ]]
| oldRecordFieldList , [[ constExpr ]]

optionDir

OPTION optionList ;;

 

Nonterminal

Definition

optionItem

CASEMAP : mapType
| DOTNAME | NODOTNAME
| EMULATOR | NOEMULATOR
| EPILOGUE : macroId
| EXPR16 | EXPR32
| LANGUAGE : langType
| LJMP | NOLJMP
| M510 | NOM510
| NOKEYWORD : < keywordList >
| NOSIGNEXTEND
| OFFSET : offsetType
| OLDMACROS | NOOLDMACROS
| OLDSTRUCTS | NOOLDSTRUCTS
| PROC : oVisibility
| PROLOGUE : macroId
| READONLY | NOREADONLY
| SCOPED | NOSCOPED
| SEGMENT : segSize
| SETIF2 : bool

optionList

optionItem
| optionList , [[ ;; ]] optionItem

optText

, textItem

orOp

OR | XOR

oVisibility

PUBLIC | PRIVATE | EXPORT

pageDir

PAGE [[ pageExpr ]] ;;

pageExpr

+
| [[ pageLength ]] [[ , pageWidth ]]

pageLength

constExpr

pageWidth

constExpr

parm

parmId [[ : qualifiedType ]]
| parmId [[ constExpr ]] [[ : qualifiedType ]]

parmId

id

parmList

parm
| parmList , [[ ;; ]] parm

parmType

REQ
| = textLiteral
| VARARG

pOptions

[[ distance ]] [[ langType ]] [[ oVisibility ]]

primary

expr binaryOp expr
| flagName
| expr

 

Nonterminal

Definition

procDir

procId PROC [[ pOptions ]] [[ < macroArgList  > ]]
[[ usesRegs ]] [[ procParmList ]]

processor

.8086
| .186
| .286 | .286C | .286P
| .386 | .386C | .386P
| .486 | .486P

processorDir

processor ;;
| coprocessor ;;

procId

id

procParmList

[[ , [[ ;; ]] parmList ]]
[[ , [[ ;; ]] parmId :VARARG]]

protoArg

[[ id ]] : qualifiedType

protoArgList

[[ , [[ ;; ]] protoList ]]
[[ , [[ ;; ]] [[ id ]] :VARARG ]]

protoList

protoArg
| protoList , [[ ;; ]] protoArg

protoSpec

[[ distance ]] [[ langType ]] [[ protoArgList ]]
| typeId

protoTypeDir

id PROTO protoSpec

pubDef

[[ langType ]] id

publicDir

PUBLIC pubList ;;

pubList

pubDef
| pubList , [[ ;; ]] pubDef

purgeDir

PURGE macroIdList

qualifiedType

type
| [[ distance ]] PTR [[ qualifiedType ]]

qualifier

qualifiedType
| PROTO protoSpec

quote


|

radixDir

.RADIX constExpr ;;

radixOverride

h | o | q | t | y
| H | O | Q | T | Y

recordConst

recordTag { oldRecordFieldList }
| recordTag < oldRecordFieldList >

recordDir

recordTag RECORD bitDefList ;;

recordFieldList

[[ constExpr ]]
| recordFieldList , [[ ;; ]] [[ constExpr ]]

 

Nonterminal

Definition

recordInstance

{ [[ ;; ]]  recordFieldList [[ ;; ]] }
|  < oldRecordFieldList >
| constExpr DUP ( recordInstance )

recordInstList

recordInstance
| recordInstList , [[ ;; ]] recordInstance

recordTag

id

register

specialRegister
| gpRegister
| byteRegister

regList

register
| regList register

relOp

EQ | NE | LT | LE | GT | GE

repeatBlock

.REPEAT ;;
blockStatements ;;
untilDir ;;

repeatDir

REPEAT | REPT

scalarInstList

initValue
| scalarInstList , [[ ;; ]] initValue

segAlign

BYTE | WORD | DWORD | PARA | PAGE

segAttrib

PUBLIC
| STACK
| COMMON
| MEMORY
| AT constExpr
| PRIVATE

segDir

.CODE [[ segId ]]
| .DATA
| .DATA?
| .CONST
| .FARDATA
[[ segId ]]
| .FARDATA? [[ segId ]]
| .STACK [[ constExpr ]]

segId

id

segIdList

segId
| segIdList , segId

segmentDef

segmentDir [[ inSegDirList ]] endsDir
| simpleSegDir [[ inSegDirList ]] [[ endsDir ]]

segmentDir

segId SEGMENT [[ segOptionList ]] ;;

segmentRegister

CS | DS | ES | FS | GS | SS

 

Nonterminal

Definition

segOption

segAlign
| segRO
| segAttrib
| segSize
| className

segOptionList

segOption
| segOptionList segOption

segOrderDir

.ALPHA | .SEQ | .DOSSEG | DOSSEG

segRO

READONLY

segSize

USE16 | USE32 | FLAT

shiftOp

SHR | SHL

sign

- | +

simpleExpr

( cExpr )
| primary

simpleSegDir

segDir ;;

sizeArg

id
| type
| e10

specialChars

: | . | [[ | ]] | ( | ) | < | > | { | }
| + | - | / | * | & | % | !
| | \ | = | ; | , |
| whiteSpaceCharacter
| endOfLine

specialRegister

CR0 | CR2 | CR3
| DR0 | DR1 | DR2 | DR3 | DR6 | DR7
| TR3 | TR4 | TR5 | TR6 | TR7

stackOption

NEARSTACK | FARSTACK

startupDir

.STARTUP ;;

stext

stringChar
| stext stringChar

string

quote [[ stext ]] quote

stringChar

quote quote
| Any character except quote

structBody

structItem ;;
| structBody structItem ;;

structDir

structTag structHdr [[ fieldAlign ]]
[[, NONUNIQUE ]] ;;
structBody
structTag ENDS ;;

structHdr

STRUC | STRUCT | UNION

 

Nonterminal

Definition

structInstance

< [[ fieldInitList ]] >
| { [[ ;; ]] [[ fieldInitList ]] [[ ;; ]] }
| constExpr DUP ( structInstList )

structInstList

structInstance
| structInstList , [[ ;; ]] structInstance

structItem

dataDir
| generalDir
| offsetDir
| nestedStruct

structTag

id

term

simpleExpr
| ! simpleExpr

text

textLiteral
| text character
| ! character text
| character
| ! character

textDir

id textMacroDir ;;

textItem

textLiteral
| textMacroId
| % constExpr

textLen

constExpr

textList

textItem
| textList , [[ ;; ]] textItem

textLiteral

< text >;;

textMacroDir

CATSTR [[ textList ]]
| TEXTEQU [[ textList ]]
| SIZESTR textItem
| SUBSTR textItem , textStart [[ , textLen ]]
| INSTR [[ textStart , ]] textItem , textItem

textMacroId

id

textStart

constExpr

titleDir

titleType arbitraryText ;;

titleType

TITLE | SUBTITLE | SUBTTL

type

structTag
| unionTag
| recordTag
| distance
| dataType
| typeId

typedefDir

typeId TYPEDEF qualifier

 

Nonterminal

Definition

typeId

id

unionTag

id

untilDir

.UNTIL cExpr ;;
.UNTILCXZ [[ cxzExpr ]] ;;

usesRegs

USES regList

whileBlock

.WHILE cExpr ;;
blockStatements ;;
.ENDW

whiteSpaceCharacter

ASCII 8, 9, 11–13, 26, 32