Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1808 lines (1219 sloc) 11.8 KB
/**
This grammar is generated with antlrworks in order to parse an asm source
code.First of all the lexical rules established here do not replace the ones
generated in JFlex we used in EditorASM to color the tokens, instead they are used
to provide the necessary tokens for the parser.
**/
/*
Ported to Antlr4 by Tom Everett <tom@khubla.com>
*/
grammar MASM;
@ header{
package com.Ostermiller.Syntax;
}
compilationUnit
: (segments | directive_exp1)* 'end' Identifier
;
segments
: Identifier 'segments' 'para' 'public' (code | proc)* Identifier 'ends'
;
proc
: Identifier 'proc' (code)* 'ret' Identifier 'endp'
;
code
: binary_exp1
| binary_exp10
| binary_exp11
| binary_exp12
| binary_exp2
| binary_exp3
| binary_exp4
| binary_exp5
| binary_exp6
| binary_exp7
| binary_exp8
| binary_exp9
| unuary_exp1
| unuary_exp2
| unuary_exp3
| unuary_exp4
| unuary_exp5
| notarguments
| variabledeclaration
| directive_exp1
;
binary_exp1
: o register Separator (register | Integer | memory)
| o memory Separator (register | Integer)
;
unuary_exp1
: op (Integer | register | memory)
;
unuary_exp2
: ope (register | memory)
;
binary_exp2
: oper register Separator (register | memory)
| oper memory Separator register
;
notarguments
: opera
;
binary_exp3
: operat (register | memory) Separator (register | Integer | memory)
;
unuary_exp3
: operato Identifier
;
binary_exp4
: operator register Separator (register | memory)
;
binary_exp5
: l register Separator memory
;
binary_exp6
: x (register | memory) Separator register
;
binary_exp7
: s (register | memory) Separator (Integer | register)
;
binary_exp8
: sh (register | memory) Separator register Separator (register | Integer)
;
binary_exp9
: b (register | memory) Separator (register | memory)
;
unuary_exp4
: call (register | memory | Integer)
;
unuary_exp5
: interruption Integer
;
binary_exp10
: in register Separator (register | Integer)
;
binary_exp11
: out (register | Integer) Separator register
;
binary_exp12
: re opera
;
directive_exp1
: (directives Identifier | directives)
;
variabledeclaration
: Identifier ty (question | String | Integer)
;
memory
: '[' (register | Identifier) ('+' ((register ('+' (Integer | Hexnum | Octalnum))?) | Integer | Hexnum | Octalnum))? ']'
;
segmentos
: DS
| ES
| CS
| SS
| GS
| FS
;
register
: AH
| AL
| AX
| BH
| BL
| BX
| CH
| CL
| CX
| DH
| DL
| DX
| SI
| DI
| SP
| BP
| EAX
| EBX
| ECX
| EDX
| ESI
| EDI
| ESP
| EBP
;
o
: MOV
| CMP
| TEST
;
op
: PUSH
;
ope
: POP
| IDIV
| INC
| DEC
| NEG
| MUL
| DIV
| IMUL
| NOT
| SETPO
| SETAE
| SETNLE
| SETC
| SETNO
| SETNB
| SETP
| SETNGE
| SETL
| SETGE
| SETPE
| SETNL
| SETNZ
| SETNE
| SETNC
| SETBE
| SETNP
| SETNS
| SETO
| SETNA
| SETNAE
| SETZ
| SETLE
| SETNBE
| SETS
| SETE
| SETB
| SETA
| SETG
| SETNG
;
oper
: XCHG
;
opera
: POPAD
| AAA
| POPA
| POPFD
| CWD
| LAHF
| PUSHAD
| PUSHF
| AAS
| BSWAP
| PUSHFD
| CBW
| CWDE
| XLAT
| AAM
| AAD
| CDQ
| DAA
| SAHF
| DAS
| INTO
| IRET
| CLC
| STC
| CMC
| CLD
| STD
| CLI
| STI
| MOVSB
| MOVSW
| MOVSD
| LODS
| LODSB
| LODSW
| LODSD
| STOS
| STOSB
| STOSW
| SOTSD
| SCAS
| SCASB
| SCASW
| SCASD
| CMPS
| CMPSB
| CMPSW
| CMPSD
| INSB
| INSW
| INSD
| OUTSB
| OUTSW
| OUTSD
;
operat
: ADC
| ADD
| SUB
| CBB
| XOR
| OR
;
operato
: JNBE
| JNZ
| JPO
| JZ
| JS
| LOOPNZ
| JGE
| JB
| JNB
| JO
| JP
| JNO
| JNL
| JNAE
| LOOPZ
| JMP
| JNP
| LOOP
| JL
| JCXZ
| JAE
| JNGE
| JA
| LOOPNE
| LOOPE
| JG
| JNLE
| JE
| JNC
| JC
| JNA
| JBE
| JLE
| JPE
| JNS
| JECXZ
| JNG
;
operator
: MOVZX
| BSF
| BSR
;
l
: LES
| LEA
| LDS
| INS
| OUTS
;
x
: XADD
| CMPXCHG
;
s
: SHL
| SHR
| ROR
| ROL
| RCL
| SAL
| RCR
| SAR
;
sh
: SHRD
| SHLD
;
b
: BTR
| BT
| BTC
;
call
: CALL
;
interruption
: INT
| RETN
| RET
| RETF
;
in
: IN
;
out
: OUT
;
re
: REP
| REPE
| REPZ
| REPNE
| REPNZ
;
directives
: ALPHA
| CONST
| CREF
| XCREF
| DATA
| DATA2
| DOSSEG
| ERR
| ERR1
| ERR2
| ERRE
| ERRNZ
| ERRDEF
| ERRNDEF
| ERRB
| ERRNB
| ERRIDN
| ERRDIF
| EVEN
| LIST
| WIDTH
| MASK
| SEQ
| XLIST
| EXIT
| MODEL
;
ty
: BYTE
| SBYTE
| DB
| WORD
| SWORD
| DW
| DWORD
| SDWORD
| DD
| FWORD
| DF
| QWORD
| DQ
| TBYTE
| DT
| REAL4
| REAL8
| REAL
| FAR
| NEAR
| PROC
;
question
: QUESTION
;
time
: TIMES
;
Identifier
: Letter ('_' | Letter | Digit)*
;
DS
: 'ds'
;
ES
: 'es'
;
CS
: 'cs'
;
SS
: 'ss'
;
GS
: 'gs'
;
FS
: 'fs'
;
AH
: 'ah'
;
AL
: 'al'
;
AX
: 'ax'
;
BH
: 'bh'
;
BL
: 'bl'
;
BX
: 'bx'
;
CH
: 'ch'
;
CL
: 'cl'
;
CX
: 'cx'
;
DH
: 'dh'
;
DL
: 'dl'
;
DX
: 'dx'
;
SI
: 'si'
;
DI
: 'di'
;
SP
: 'sp'
;
BP
: 'bp'
;
EAX
: 'eax'
;
EBX
: 'ebx'
;
ECX
: 'ecx'
;
EDX
: 'edx'
;
ESI
: 'esi'
;
EDI
: 'edi'
;
ESP
: 'esp'
;
EBP
: 'ebp'
;
MOV
: 'mov'
;
CMP
: 'cmp'
;
TEST
: 'test'
;
PUSH
: 'push'
;
POP
: 'pop'
;
IDIV
: 'idiv'
;
INC
: 'inc'
;
DEC
: 'dec'
;
NEG
: 'neg'
;
MUL
: 'mul'
;
DIV
: 'div'
;
IMUL
: 'imul'
;
NOT
: 'not'
;
SETPO
: 'setpo'
;
SETAE
: 'setae'
;
SETNLE
: 'setnle'
;
SETC
: 'setc'
;
SETNO
: 'setno'
;
SETNB
: 'setnb'
;
SETP
: 'setp'
;
SETNGE
: 'setnge'
;
SETL
: 'setl'
;
SETGE
: 'setge'
;
SETPE
: 'setpe'
;
SETNL
: 'setnl'
;
SETNZ
: 'setnz'
;
SETNE
: 'setne'
;
SETNC
: 'setnc'
;
SETBE
: 'setbe'
;
SETNP
: 'setnp'
;
SETNS
: 'setns'
;
SETO
: 'seto'
;
SETNA
: 'setna'
;
SETNAE
: 'setnae'
;
SETZ
: 'setz'
;
SETLE
: 'setle'
;
SETNBE
: 'setnbe'
;
SETS
: 'sets'
;
SETE
: 'sete'
;
SETB
: 'setb'
;
SETA
: 'seta'
;
SETG
: 'setg'
;
SETNG
: 'setng'
;
XCHG
: 'xchg'
;
POPAD
: 'popad'
;
AAA
: 'aaa'
;
POPA
: 'popa'
;
POPFD
: 'popfd'
;
CWD
: 'cwd'
;
LAHF
: 'lahf'
;
PUSHAD
: 'pushad'
;
PUSHF
: 'pushf'
;
AAS
: 'aas'
;
BSWAP
: 'bswap'
;
PUSHFD
: 'pushfd'
;
CBW
: 'cbw'
;
CWDE
: 'cwde'
;
XLAT
: 'xlat'
;
AAM
: 'aam'
;
AAD
: 'aad'
;
CDQ
: 'cdq'
;
DAA
: 'daa'
;
SAHF
: 'sahf'
;
DAS
: 'das'
;
INTO
: 'into'
;
IRET
: 'iret'
;
CLC
: 'clc'
;
STC
: 'stc'
;
CMC
: 'cmc'
;
CLD
: 'cld'
;
STD
: 'std'
;
CLI
: 'cli'
;
STI
: 'sti'
;
MOVSB
: 'movsb'
;
MOVSW
: 'movsw'
;
MOVSD
: 'movsd'
;
LODS
: 'lods'
;
LODSB
: 'lodsb'
;
LODSW
: 'lodsw'
;
LODSD
: 'lodsd'
;
STOS
: 'stos'
;
STOSB
: 'stosb'
;
STOSW
: 'stosw'
;
SOTSD
: 'sotsd'
;
SCAS
: 'scas'
;
SCASB
: 'scasb'
;
SCASW
: 'scasw'
;
SCASD
: 'scasd'
;
CMPS
: 'cmps'
;
CMPSB
: 'cmpsb'
;
CMPSW
: 'cmpsw'
;
CMPSD
: 'cmpsd'
;
INSB
: 'insb'
;
INSW
: 'insw'
;
INSD
: 'insd'
;
OUTSB
: 'outsb'
;
OUTSW
: 'outsw'
;
OUTSD
: 'outsd'
;
ADC
: 'adc'
;
ADD
: 'add'
;
SUB
: 'sub'
;
CBB
: 'cbb'
;
XOR
: 'xor'
;
OR
: 'or'
;
JNBE
: 'jnbe'
;
JNZ
: 'jnz'
;
JPO
: 'jpo'
;
JZ
: 'jz'
;
JS
: 'js'
;
LOOPNZ
: 'loopnz'
;
JGE
: 'jge'
;
JB
: 'jb'
;
JNB
: 'jnb'
;
JO
: 'jo'
;
JP
: 'jp'
;
JNO
: 'jno'
;
JNL
: 'jnl'
;
JNAE
: 'jnae'
;
LOOPZ
: 'loopz'
;
JMP
: 'jmp'
;
JNP
: 'jnp'
;
LOOP
: 'loop'
;
JL
: 'jl'
;
JCXZ
: 'jcxz'
;
JAE
: 'jae'
;
JNGE
: 'jnge'
;
JA
: 'ja'
;
LOOPNE
: 'loopne'
;
LOOPE
: 'loope'
;
JG
: 'jg'
;
JNLE
: 'jnle'
;
JE
: 'je'
;
JNC
: 'jnc'
;
JC
: 'jc'
;
JNA
: 'jna'
;
JBE
: 'jbe'
;
JLE
: 'jle'
;
JPE
: 'jpe'
;
JNS
: 'jns'
;
JECXZ
: 'jecxz'
;
JNG
: 'jng'
;
MOVZX
: 'movzx'
;
BSF
: 'bsf'
;
BSR
: 'bsr'
;
LES
: 'les'
;
LEA
: 'lea'
;
LDS
: 'lds'
;
INS
: 'ins'
;
OUTS
: 'outs'
;
XADD
: 'xadd'
;
CMPXCHG
: 'cmpxchg'
;
SHL
: 'shl'
;
SHR
: 'shr'
;
ROR
: 'ror'
;
ROL
: 'rol'
;
RCL
: 'rcl'
;
SAL
: 'sal'
;
RCR
: 'rcr'
;
SAR
: 'sar'
;
SHRD
: 'shrd'
;
SHLD
: 'shld'
;
BTR
: 'btr'
;
BT
: 'bt'
;
BTC
: 'btc'
;
CALL
: 'call'
;
INT
: 'int'
;
RETN
: 'retn'
;
RET
: 'ret'
;
RETF
: 'retf'
;
IN
: 'in'
;
OUT
: 'out'
;
REP
: 'rep'
;
REPE
: 'repe'
;
REPZ
: 'repz'
;
REPNE
: 'repne'
;
REPNZ
: 'repnz'
;
ALPHA
: '.alpha'
;
CONST
: '.const'
;
CREF
: '.cref'
;
XCREF
: '.xcref'
;
DATA
: 'data'
;
DATA2
: 'data?'
;
DOSSEG
: 'dosseg'
;
ERR
: '.err'
;
ERR1
: '.err1'
;
ERR2
: '.err2'
;
ERRE
: '.erre'
;
ERRNZ
: '.errnz'
;
ERRDEF
: '.errdef'
;
ERRNDEF
: '.errndef'
;
ERRB
: '.errb'
;
ERRNB
: '.errnb'
;
ERRIDN
: '.erridn[i]'
;
ERRDIF
: '.errdif[i]'
;
EVEN
: 'even'
;
LIST
: '.list'
;
WIDTH
: 'width'
;
MASK
: 'mask'
;
SEQ
: '.seq'
;
XLIST
: '.xlist'
;
EXIT
: '.exit'
;
MODEL
: '.model'
;
BYTE
: 'byte'
;
SBYTE
: 'sbyte'
;
DB
: 'db'
;
WORD
: 'word'
;
SWORD
: 'sword'
;
DW
: 'dw'
;
DWORD
: 'dword'
;
SDWORD
: 'sdword'
;
DD
: 'dd'
;
FWORD
: 'fword'
;
DF
: 'df'
;
QWORD
: 'qword'
;
DQ
: 'dq'
;
TBYTE
: 'tbyte'
;
DT
: 'dt'
;
REAL4
: 'real4'
;
REAL8
: 'real8'
;
REAL
: 'real'
;
FAR
: 'far'
;
NEAR
: 'near'
;
PROC
: 'proc'
;
QUESTION
: '?'
;
TIMES
: 'times'
;
Hexnum
: HexDigit + ('h' | 'H')
;
Integer
: (Digit +)
;
Octalnum
: ('0' .. '7') + ('o' | 'O')
;
fragment HexDigit
: ('0' .. '9' | 'a' .. 'f' | 'A' .. 'F')
;
FloatingPointLiteral
: ('0' .. '9') + '.' ('0' .. '9')* Exponent? | '.' ('0' .. '9') + Exponent? | ('0' .. '9') + Exponent
;
fragment Exponent
: ('e' | 'E') ('+' | '-')? ('0' .. '9') +
;
String
: ' \'' ('\\' . | ~ ('\\' | '\''))* '\''
;
fragment Letter
: ('a' .. 'z' | 'A' .. 'Z')
;
fragment Digit
: '0' .. '9'
;
Etiqueta
: Identifier (':')
;
Separator
: ','
;
WS
: (' ' | '\t' | '\n' | '\r') -> skip
;
LINE_COMMENT
: ';' ~ ('\n' | '\r')* '\r'? '\n' -> skip
;
You can’t perform that action at this time.