chrisly42/mc68000-asm-plugin
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: chrisly42/mc68000-asm-plugin:v0.6
Branches Tags
chrisly42/mc68000-asm-plugin:main chrisly42/mc68000-asm-plugin:feat/formatter
chrisly42/mc68000-asm-plugin:v0.9 chrisly42/mc68000-asm-plugin:v0.8 chrisly42/mc68000-asm-plugin:v0.7 chrisly42/mc68000-asm-plugin:v0.6 chrisly42/mc68000-asm-plugin:v0.5 chrisly42/mc68000-asm-plugin:v0.4 chrisly42/mc68000-asm-plugin:v0.3 chrisly42/mc68000-asm-plugin:v0.2 chrisly42/mc68000-asm-plugin:v0.1
...
compare: chrisly42/mc68000-asm-plugin:v0.9
Branches Tags
chrisly42/mc68000-asm-plugin:main chrisly42/mc68000-asm-plugin:feat/formatter
chrisly42/mc68000-asm-plugin:v0.9 chrisly42/mc68000-asm-plugin:v0.8 chrisly42/mc68000-asm-plugin:v0.7 chrisly42/mc68000-asm-plugin:v0.6 chrisly42/mc68000-asm-plugin:v0.5 chrisly42/mc68000-asm-plugin:v0.4 chrisly42/mc68000-asm-plugin:v0.3 chrisly42/mc68000-asm-plugin:v0.2 chrisly42/mc68000-asm-plugin:v0.1
24 Commits
v0.6 ... v0.9
Author SHA1 Message Date
chrisly42 87cca67049 Updated dependencies. Tests work again. Cosmetics, fixed warnings. 2022-08-16 10:54:57 +02:00
chrisly42 5e2099f019 Fixed 'Unknown op size' exception when uppercase sizes were used. 2022-04-26 10:43:07 +02:00
chrisly42 ae92da7878 Maintenance. Updated all dependencies to the latest versions. 
Fixed condition code for asr/lsr/lsl, which is has a different behaviour for V flag than asl.
 2022-04-07 10:30:12 +02:00
chrisly42 85b2596c64 Added some more settings for maximum parsed lines inside a macro and maximum displayed lines of code for documentation. 
RegisterFlow line counting fixed.
 2021-10-15 13:05:47 +02:00
chrisly42 e0bd6981e3 Full support for MC68010 ISA ('movec', 'moves' and new special registers 'SFC' and 'DFC'). 2021-10-11 11:32:13 +02:00
chrisly42 0ae17046d6 Added Language settings page with one option so far (-spaces option). Fixed lexer without -spaces option and directives. 2021-10-09 16:56:06 +02:00
chrisly42 031d5ff4ab Missing files and fix for optional values in Memory Indirect mode. 2021-10-08 18:04:15 +02:00
chrisly42 653f8dc9fc Extended ISA for 68020+ addressing modes (without adding 68020+ instructions). 2021-10-08 17:24:59 +02:00
chrisly42 a92630e5c7 Added Address Register Indirect with Base Displacement addressing mode. 2021-10-08 15:09:41 +02:00
chrisly42 3f1ef0e55a Refactored BNF for base and outer displacement to avoid ambiguity for these expressions. 2021-10-08 11:22:53 +02:00
chrisly42 722d4437ec Added missing support for size qualifiers for base and outer displacement. 2021-10-08 11:07:16 +02:00
chrisly42 f1110ac3c9 Added 68020 Memory Indirect and Program Counter Memory Indirect addressing modes. 2021-10-08 08:38:04 +02:00
chrisly42 7462c5b02d Added support for SCALE in index addressing modes. 2021-10-08 08:37:29 +02:00
chrisly42 9b93ea05fc Minor renaming & tweaks. 2021-10-07 17:11:06 +02:00
chrisly42 680b811e22 Macro definition / invocation documentation provider that even tries to expand macros. 
Moved some util classes around.
 2021-10-03 20:26:33 +02:00
chrisly42 cbffc3d841 Label documentation now also works for local labels and includes end-of-line comment for label, too. 
Symbol definition documentation now also includes comments in the same way as the label documentation does.
Refactored some code.
 2021-10-03 18:55:42 +02:00
chrisly42 435b30efc3 Bump to next version, updated docs due to Yann's first public release of his plugin. 2021-10-02 20:01:51 +02:00
chrisly42 62f7f13323 Bumped to IntelliJ/CLion 2021.2.2 2021-09-25 21:29:17 +02:00
chrisly42 c4051a0377 'END' detection was breaking parsing, causing havoc. 2021-09-25 17:20:45 +02:00
chrisly42 a03de6c394 Added documentation provider info for global labels. Shows directives and comments above. 
Fixed BNF for labels with preprocessor statements.
Bumped versions.
 2021-09-25 15:19:05 +02:00
chrisly42 1bff1a12c2 Documentation for instruction with special register shows specific register expected. 2021-09-05 18:42:20 +02:00
chrisly42 665947827b Updated build to latest versions. 2021-09-04 14:23:15 +02:00
chrisly42 3bb6165a58 Courtesy of Yann: 
Bugfix: Special registers for address mode matching only worked with lower case register names.
Bugfix: movem with pc-relative mode was missing for weird immediate mode.
Bugfix: btst with pc-relative and weird immediate mode was missing.
Enhancement: Assembler syntax with implicit immediate 1 for shifts and rotations no longer cause syntax errors.
 2021-09-04 14:08:10 +02:00
chrisly42 89bd964fe7 Minor updates to documentation. 2021-08-09 15:27:12 +02:00
122 changed files with 5108 additions and 976 deletions
Expand all files Collapse all files
README.md
+68 -23
View File
@@ -1,4 +1,4 @@
# MC68000 Assembly Language Plugin [![Build Status](https://travis-ci.com/chrisly42/mc68000-asm-plugin.svg?branch=main)](https://travis-ci.com/chrisly42/mc68000-asm-plugin) [![Coverage Status](https://coveralls.io/repos/github/chrisly42/mc68000-asm-plugin/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/chrisly42/mc68000-asm-plugin?branch=main)
# MC68000 Assembly Language Plugin [![Build Status](https://app.travis-ci.com/chrisly42/mc68000-asm-plugin.svg?branch=master)](https://app.travis-ci.com/chrisly42/mc68000-asm-plugin)
_MC68000 Assembly Language Plugin_ is plugin for Jetbrains IDEs (CLion, IntelliJ, etc.).
@@ -6,30 +6,31 @@ _MC68000 Assembly Language Plugin_ is plugin for Jetbrains IDEs (CLion, IntelliJ
## Purpose
This plugin delivers support for MC68000 assembly language files ([VAsm](http://sun.hasenbraten.de/vasm/) / DevPac-Style).
This plugin delivers support for MC680xx assembly language files ([VAsm](http://sun.hasenbraten.de/vasm/) / DevPac-Style).
It adds a language parser with syntax highlighting, referencing and refactoring support, and a few more features.
I'm an Amiga retro democoder, and the lack of a plugin for M68k was the motivation to write one. Also, diving deep into custom language plugins has a steep
learning curve.
I'm an Amiga retro democoder (among other things), and the lack of a plugin for M68k was the motivation to write one. Also, diving deep into custom language
plugins has a steep learning curve.
When I started the plugin in July 2021, I was not aware of the [M68k plugin efforts by Jetbrains employee Yann Cébron](https://github.com/YannCebron/m68kplugin)
who has been working on the same topic for quite some time. At the time of writing, his plugin however, has not been release yet. Nevertheless, it has a lot of
awesome features and is pretty advanced. Check it out. You can install both plugins at the same time and see what suits you more.
When I started the plugin in July 2021, I was unaware of the [M68k plugin efforts by Jetbrains employee Yann Cébron](https://github.com/YannCebron/m68kplugin)
who has been working on the same topic for quite some time. *On 01-Oct-21, he released
his [first public version](https://plugins.jetbrains.com/plugin/17712-motorola-68000-series-assembler).* Check it out. You can install both plugins at the same
time and see what suits you more.
Big kudos to Yann -- a few features were _inspired_ by his code.
My plugin, on the other hand, is still pretty basic and is the result of a few weeks of work. I released a really early first version it because I think it's "
good enough" to get started, and I can return to demo coding with its current state.
My plugin, on the other hand, is still pretty basic and is the result of a few weeks of work. I released the first versions because I think it's "good enough"
to get started, and I can return to demo coding with its current state.
## Features
- Parser / Lexer for MC68000 (yes, only 68000 right now!) assembly language files in VAsm / DevPac style
- Inspection for validating the syntax of the 68000 ISA.
- Parser / Lexer for MC680xx assembly language files in VAsm / DevPac style
- Validates the assembly syntax against the 68000/68010 ISA and 68020+ addressing modes (no complete >68020 support yet!)
- Syntax highlighting and Color Settings Page (you should really modify the color settings to your likings!)
- Mnemonics code completion
- Symbols / Labels / Macros code completion
- References / Refactoring support for local and global labels, symbol assignments, and macros.
- Symbols / labels / macros code completion
- References / refactoring support for local and global labels, symbol assignments, and macros.
- Simple register usage flow (hover over register or press F1 for full flow)
- Brace matching
- Quote handler
@@ -85,11 +86,20 @@ weak warnings as missing macro evaluation will not resolve symbols defined via `
### Documentation provider
#### M68kSymbolDefinitionDocumentationProvider
#### M68kSymbolDefinition
Provides the assigned value of a `=`, `set` or `equ` symbol definition when hovering over a symbol.
#### M68kRegisterFlowDocumentationProvider
#### M68kMacroDefinition
When used over a macro invocation, shows the expanded macro contents (only the \1 to \9 and \a to \z are expanded according to the parameters used).
#### M68kLabelDefinition
Shows the comments above the label (local or global) and an end-of-line comment, if available. If the first statement after the label is a directive
like `include` or `dc.b`, it will be shown, too.
#### M68kRegisterFlow
When hovering over or placing the cursor at a data or address register, the documentation will scan through the instructions backwards and forwards and will
show all read, changes of the register contents. It does this until an instruction is found that defines (sets) the contents of the register
@@ -100,7 +110,7 @@ The analysis ignores all code flow instructions and might be inaccurate for bran
The documentation will search up to 100 instructions in each direction, but only four when hovering over the register
(so if you need the whole analysis, use the documentation window).
#### M68kInstructionDocumentationProvider
#### M68kInstruction
When hovering over a mnemonic, it will show a short description of the assembly instruction.
@@ -112,13 +122,17 @@ If the current statement has no valid syntax, the instruction details of all mat
## Known issues
- `Find Usages` always shows _"Unclassified"_ though it shouldn't (?)
- `END` detection was breaking parsing, so this is disabled for now until I find a working solution.
- Macro invocations are not yet evaluated, thus no referencing to symbols defined via macros (e.g. `STRUCT`).
- No support for includes. Scoping is for global symbols and labels is currently the whole project.
- Scoping for global symbols, labels and macros is currently the whole project.
- No support for register replacement (e.g. registers replaced by `EQUR` or `EQURL` will cause syntax errors)
- While the Lexer supports the -spaces option (where a space introduces a comment), this cannot be configured yet (default is off).
- No support for other processor instructions, FPU or 68020+ address modes.
- No support for other processor instructions and FPU. Yet.
- The pretty esoteric use of `ZPC`, `ZA0-ZA7` or `ZSP` for zero (omitted) address in 68020 addressing modes is unsupported.
- Devpac allowed shuffling of (base) displacement and other parameters inside the new syntax (68020+) brackets. Well, I don't. Only strict `(bd,An,Xn*s)` or
`([bd,An],Xn*s,od)` order allowed.
- Switching the spaces option usually needs the caches to be invalidated. Find Usages word scanner always uses default settings, as it is not configurable per
project :-/
- Unit Test coverage is not as good as it could be (ahem).
- `opt` keyword needs special treatment and will currently show a parsing error.
- Missing but planned features:
- Macro evaluation on invocation
- Folding
@@ -141,12 +155,43 @@ It is probably the only plugin (besides [Cajon](https://github.com/chrisly42/caj
far (or at least the only one I'm aware of ;) ). The IntelliJ framework actually uses the JUnit 3 TestCase for plugin testing, and it took me quite a while to
make it work with JUnit 5. Feel free to use the code (in package ```de.platon42.intellij.jupiter```) for your projects (with attribution).
## Private TODO list
## Feedback
- code completion suggestion for unresolved global labels and symbols
I guess there are currently over 500 users of this plugin and while I wrote this mainly for myself, I'm only doing this in my spare time.
Feedback and [rating](https://plugins.jetbrains.com/plugin/17268-mc68000-assembly-language-support/reviews)
are appreciated. It really is keeping me motivated to continue development.
## Changelog
### V0.9 (16-Aug-22)
- Maintenance. Updated all dependencies to the latest versions.
- Bugfix: Fixed condition code for `asr/lsr/lsl`, which is has a different behaviour for V flag than `asl`.
- Bugfix: Fixed 'Unknown op size' exception when uppercase sizes were used.
- Bugfix: Refactoring was broken for newer IDE versions, at least for me, this now works again by unknown magic.
### V0.8 (15-Oct-21)
- New: Support for MC68020+ addressing modes! However, MC68020+ specific instructions have not been added yet.
- New: Full support for MC68010 ISA (`movec`, `moves` and new special registers `SFC` and `DFC`).
- Enhancement: Label documentation now also works for local labels and includes end-of-line comment for label, too.
- Enhancement: Symbol definition documentation now also includes comments in the same way as the label documentation does.
- New: Macro definition / invocation documentation provider that even tries to expand macros.
- New: Added Language settings page with one option so far (-spaces option).
- New: Added some more settings for maximum parsed lines inside a macro and maximum displayed lines of code for documentation.
### V0.7 (26-Sep-21)
- Bugfix: `btst` with pc-relative and weird immediate mode was missing (courtesy of Yann).
- Bugfix: `movem` with pc-relative mode was missing for weird immediate mode (courtesy of Yann).
- Bugfix: Special registers for address mode matching only worked with lower case register names (courtesy of Yann).
- Enhancement: Assembler syntax with implicit immediate 1 for shifts and rotations no longer cause syntax errors (courtesy of Yann).
- Enhancement: Documentation for instruction with special register shows specific register expected.
- New: Added documentation provider info for global labels. Shows directives and comments above.
- Bugfix: Fixed BNF for labels with preprocessor statements.
- Disabled: `END` detection was breaking parsing, causing havoc.
### V0.6 (09-Aug-21)
- Enhancement: `opt` and several other directives (`printt`, `fail` etc.) no longer causes a syntax error when unquoted.
@@ -188,7 +233,7 @@ make it work with JUnit 5. Feel free to use the code (in package ```de.platon42.
- Enhancement: Macro definitions are now word and stub indexed, macro calls reference to definition.
- New: Macro definition refactoring and find usages support.
- Enhancement: Structural View also shows macro definitions.
- Bugfix: Missing REPT and ENDR assembler directives added.
- Bugfix: Missing `REPT` and `ENDR` assembler directives added.
- Cosmetics: Changed or added some icons at various places.
- Performance: Reference search for global labels and symbols now uses stub index.
- Compatibility: Restored compatibility with IDE versions < 2021.1.
build.gradle
+30 -47
View File
@@ -1,13 +1,13 @@
plugins {
id 'java'
id 'org.jetbrains.intellij' version '1.1.3'
id 'org.jetbrains.kotlin.jvm' version '1.5.21'
id 'org.jetbrains.intellij' version '1.8.0'
id 'org.jetbrains.kotlin.jvm' version '1.7.10'
id 'jacoco'
id 'com.github.kt3k.coveralls' version '2.11.0'
id 'com.github.kt3k.coveralls' version '2.12.0'
}
group = 'de.platon42'
version = '0.6'
version = '0.9'
sourceCompatibility = "1.8"
targetCompatibility = "1.8"
@@ -22,11 +22,12 @@ repositories {
dependencies {
implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
testImplementation "org.assertj:assertj-core:3.20.2"
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.0-M1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0-M1'
testImplementation 'org.assertj:assertj-core:3.23.1'
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
testImplementation "org.jetbrains.kotlin:kotlin-test"
testImplementation "org.jetbrains.kotlin:kotlin-reflect"
testImplementation 'org.junit.platform:junit-platform-launcher:1.9.0'
// testImplementation "org.jetbrains.kotlin:kotlin-test-junit"
}
@@ -42,55 +43,30 @@ compileTestKotlin {
}
intellij {
setVersion("2021.2") // LATEST-EAP-SNAPSHOT
setVersion("2022.2") // LATEST-EAP-SNAPSHOT
setUpdateSinceUntilBuild(false)
// setPlugins(["com.intellij.java"])
}
runPluginVerifier {
ideVersions = ["IC-203.6682.168", "IC-212.4746.92", // 2020.3 - 2021.2
"CL-203.5981.166", "CL-203.8084.11", // 2020.3
"CL-211.6693.114", "CL-211.7628.27", // 2021.1
"CL-212.4746.93"] // 2021.2
downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea"
ideVersions = ["IC-203.6682.168", "IC-222.3345.118", // 2020.3 - 2022.2
"CL-203.8084.11", // 2020.3
"CL-211.7628.27", // 2021.1
"CL-212.5712.21", // 2021.2
"CL-213.7172.20", // 2021.3.4
"CL-221.5080.224", // 2022.1
"CL-222.3345.126"] // 2022.2
downloadDir = System.getProperty("user.home") + "/.gradle/caches/modules-2/files-2.1/com.jetbrains.intellij.idea/verifier"
}
patchPluginXml {
setChangeNotes("""
<h4>V0.6 (09-Aug-21)</h4>
<h4>V0.9 (16-Aug-22)</h4>
<ul>
<li>Enhancement: 'opt' and several other directives ('printt', 'fail' etc.) no longer causes a syntax error when unquoted.
<li>Enhancement: 'include', 'incdir' and 'incbin' and 'output' with '&lt;pathname&gt;' quotes no longer cause syntax error.
<li>New: Files in 'include' directives can be referenced and renamed/refactored.
<li>New: Code completion for local label definitions, suggesting undefined labels already referenced.
<li>New: Added inspection suppression possibility and quickfix.
<li>New: Added inspection for unresolved symbols, macros and labels.
<li>Enhancement: 'END' directive stops parsing.
</ul>
<h4>V0.5 (06-Aug-21)</h4>
<ul>
<li>Bugfix: movem ISA was wrong regarding movem.w &lt;ea&gt;,&lt;registerlist&gt; (sign extends registers).
<li>Cosmetics: Changed Register Flow Documentation wording from 'reads' to 'uses' and from 'modifies' to 'changes'.
<li>Bugfix: Minor fix for `andi/eori/ori to ccr` which were not byte sized in ISA.
<li>Bugfix: Added alternate condition code tests HS (=CC) and LO (=CS).
<li>Performance: Optimized mnemonic lookup.
<li>Enhancement: Reworked Instruction Documentation provider, now shows condition codes.
<li>Bugfix: In ISA exg is no longer treated as setting a definitive value.
<li>New: Added inspection to find dead writes to registers!
<li>New: Added inspection to warn about unexpected condition code unaffecting instructions before conditional instructions.
</ul>
<h4>V0.4 (03-Aug-21)</h4>
<ul>
<li>Notice: Due to major new API use, this plugin no longer works on IDEs &gt;=2019.3.1, but rather requires &gt;=2020.3.
<li>Enhancement: Added Structure View filters.
<li>New: Added inspection to validate the correctness of a MC68000 instruction regarding operation size and address modes.
<li>Bugfix: Added several missing assembler directives (opt, machine, etc.).
<li>Bugfix: Uppercase hexadecimal literals were not parsed (JFlex bug?).
<li>Bugfix: Interpretation of register lists was wrong in BNF.
<li>New: Added Documentation Provider for symbol definitions (shows assigned declaration).
<li>New: Added Documentation Provider for mnemonics (simple version, generated out of ISA information).
<li>Bugfix: Macro definitions with colons and without space supported (as found in P61a source).
<li>New: When asking for documentation on registers, a code flow analysis is done. Cool stuff!
<li>Maintenance. Updated all dependencies to the latest versions.
<li>Bugfix: Fixed condition code for asr/lsr/lsl, which is has a different behaviour for V flag than asl.
<li>Bugfix: Fixed 'Unknown op size' exception when uppercase sizes were used.
<li>Bugfix: Refactoring was broken for newer IDE versions, at least for me, this now works again by unknown magic.
</ul>
<p>Full changelog available at <a href="https://github.com/chrisly42/mc68000-asm-plugin#changelog">Github project site</a>.</p>
""")
@@ -103,10 +79,17 @@ test {
testLogging {
events "passed", "skipped", "failed"
}
runIde {
jvmArgs '--add-exports', 'java.base/jdk.internal.vm=ALL-UNNAMED'
}
}
tasks.coveralls {
dependsOn jacocoTestReport
}
jacoco {
toolVersion = '0.8.7'
toolVersion = '0.8.8'
}
jacocoTestReport {
gradle/wrapper/gradle-wrapper.properties
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
src/main/gen/de/platon42/intellij/plugins/m68k/lexer/_M68kLexer.java
+470 -437
View File
File diff suppressed because it is too large Load Diff
src/main/gen/de/platon42/intellij/plugins/m68k/parser/M68kParser.java
+769 -23
View File
@@ -40,8 +40,10 @@ public class M68kParser implements PsiParser, LightPsiParser {
create_token_set_(ADDRESS_REGISTER, DATA_REGISTER, REGISTER, SPECIAL_REGISTER),
create_token_set_(ABSOLUTE_ADDRESS_ADDRESSING_MODE, ADDRESSING_MODE, ADDRESS_REGISTER_DIRECT_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_ADDRESSING_MODE,
ADDRESS_REGISTER_INDIRECT_POST_INC_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_PRE_DEC_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE,
ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE, DATA_REGISTER_DIRECT_ADDRESSING_MODE, IMMEDIATE_DATA,
PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE,
ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE, DATA_REGISTER_DIRECT_ADDRESSING_MODE,
IMMEDIATE_DATA, MEMORY_INDIRECT_ADDRESSING_MODE, MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE,
PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE,
PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE, PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE, PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE,
REGISTER_LIST_ADDRESSING_MODE, SPECIAL_REGISTER_DIRECT_ADDRESSING_MODE),
create_token_set_(BINARY_ADD_EXPR, BINARY_BITWISE_AND_EXPR, BINARY_BITWISE_OR_EXPR, BINARY_BITWISE_XOR_EXPR,
BINARY_CMP_EQ_EXPR, BINARY_CMP_GE_EXPR, BINARY_CMP_GT_EXPR, BINARY_CMP_LE_EXPR,
@@ -210,6 +212,37 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// ROUND_L (internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3)? ROUND_R
public static boolean AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokenFast(b, ROUND_L);
r = r && AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3)?
private static boolean AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1")) return false;
AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1_0(b, l + 1);
return true;
}
// internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3
private static boolean AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode_1_0")) return false;
boolean r;
r = internalBaseDisplacementOption1(b, l + 1);
if (!r) r = internalBaseDisplacementOption2(b, l + 1);
if (!r) r = internalBaseDisplacementOption3(b, l + 1);
return r;
}
/* ********************************************************** */
// ROUND_L (expr SEPARATOR)? AddressRegister SEPARATOR IndexRegister ROUND_R
public static boolean AddressRegisterIndirectWithIndexNewAddressingMode(PsiBuilder b, int l) {
@@ -294,6 +327,14 @@ public class M68kParser implements PsiParser, LightPsiParser {
// | ProgramCounterIndirectWithDisplacementOldAddressingMode
// | AddressRegisterIndirectWithIndexOldAddressingMode
// | ProgramCounterIndirectWithIndexOldAddressingMode
// | AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode
// | ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode
// | MemoryIndirectAddressingMode
// | ProgramCounterMemoryIndirectAddressingMode
// | MemoryIndirectPostIndexedAddressingMode
// | ProgramCounterMemoryIndirectPostIndexedAddressingMode
// | MemoryIndirectPreIndexedAddressingMode
// | ProgramCounterMemoryIndirectPreIndexedAddressingMode
// | SpecialRegisterDirectAddressingMode
// | DataRegisterDirectAddressingMode
// | AddressRegisterDirectAddressingMode
@@ -315,6 +356,14 @@ public class M68kParser implements PsiParser, LightPsiParser {
if (!r) r = ProgramCounterIndirectWithDisplacementOldAddressingMode(b, l + 1);
if (!r) r = AddressRegisterIndirectWithIndexOldAddressingMode(b, l + 1);
if (!r) r = ProgramCounterIndirectWithIndexOldAddressingMode(b, l + 1);
if (!r) r = AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(b, l + 1);
if (!r) r = ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(b, l + 1);
if (!r) r = MemoryIndirectAddressingMode(b, l + 1);
if (!r) r = ProgramCounterMemoryIndirectAddressingMode(b, l + 1);
if (!r) r = MemoryIndirectPostIndexedAddressingMode(b, l + 1);
if (!r) r = ProgramCounterMemoryIndirectPostIndexedAddressingMode(b, l + 1);
if (!r) r = MemoryIndirectPreIndexedAddressingMode(b, l + 1);
if (!r) r = ProgramCounterMemoryIndirectPreIndexedAddressingMode(b, l + 1);
if (!r) r = SpecialRegisterDirectAddressingMode(b, l + 1);
if (!r) r = DataRegisterDirectAddressingMode(b, l + 1);
if (!r) r = AddressRegisterDirectAddressingMode(b, l + 1);
@@ -425,6 +474,25 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// expr DataWidth?
public static boolean BaseDisplacement(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "BaseDisplacement")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, BASE_DISPLACEMENT, "<base displacement>");
r = expr(b, l + 1, -1);
r = r && BaseDisplacement_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// DataWidth?
private static boolean BaseDisplacement_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "BaseDisplacement_1")) return false;
DataWidth(b, l + 1);
return true;
}
/* ********************************************************** */
// DataRegister | AddressRegister
static boolean DataOrAddressRegister(PsiBuilder b, int l) {
@@ -532,13 +600,14 @@ public class M68kParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// DataOrAddressRegister DataWidth?
// DataOrAddressRegister DataWidth? (OP_AR_MUL IndexScale)?
public static boolean IndexRegister(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IndexRegister")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, INDEX_REGISTER, "<index register>");
r = DataOrAddressRegister(b, l + 1);
r = r && IndexRegister_1(b, l + 1);
r = r && IndexRegister_2(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
@@ -550,6 +619,35 @@ public class M68kParser implements PsiParser, LightPsiParser {
return true;
}
// (OP_AR_MUL IndexScale)?
private static boolean IndexRegister_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IndexRegister_2")) return false;
IndexRegister_2_0(b, l + 1);
return true;
}
// OP_AR_MUL IndexScale
private static boolean IndexRegister_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IndexRegister_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, OP_AR_MUL);
r = r && IndexScale(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// expr
public static boolean IndexScale(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IndexScale")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, INDEX_SCALE, "<scale value>");
r = expr(b, l + 1, -1);
exit_section_(b, l, m, r, false, null);
return r;
}
/* ********************************************************** */
// AsmInstruction | MacroCall
static boolean Instruction(PsiBuilder b, int l) {
@@ -562,9 +660,13 @@ public class M68kParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// Instruction
// Instruction|PreprocessorDirective
static boolean InstructionOnly(PsiBuilder b, int l) {
return Instruction(b, l + 1);
if (!recursion_guard_(b, l, "InstructionOnly")) return false;
boolean r;
r = Instruction(b, l + 1);
if (!r) r = PreprocessorDirective(b, l + 1);
return r;
}
/* ********************************************************** */
@@ -596,18 +698,27 @@ public class M68kParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// Label Instruction
// Label (Instruction|PreprocessorDirective)
static boolean LabelWithInstruction(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelWithInstruction")) return false;
if (!nextTokenIs(b, "", GLOBAL_LABEL_DEF, LOCAL_LABEL_DEF)) return false;
boolean r;
Marker m = enter_section_(b);
r = Label(b, l + 1);
r = r && Instruction(b, l + 1);
r = r && LabelWithInstruction_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// Instruction|PreprocessorDirective
private static boolean LabelWithInstruction_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelWithInstruction_1")) return false;
boolean r;
r = Instruction(b, l + 1);
if (!r) r = PreprocessorDirective(b, l + 1);
return r;
}
/* ********************************************************** */
// LOCAL_LABEL_DEF COLON?
public static boolean LocalLabel(PsiBuilder b, int l) {
@@ -751,6 +862,193 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? AddressRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
public static boolean MemoryIndirectAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MEMORY_INDIRECT_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && MemoryIndirectAddressingMode_2(b, l + 1);
r = r && AddressRegister(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
r = r && MemoryIndirectAddressingMode_5(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean MemoryIndirectAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_2")) return false;
MemoryIndirectAddressingMode_2_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean MemoryIndirectAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR OuterDisplacement)?
private static boolean MemoryIndirectAddressingMode_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_5")) return false;
MemoryIndirectAddressingMode_5_0(b, l + 1);
return true;
}
// SEPARATOR OuterDisplacement
private static boolean MemoryIndirectAddressingMode_5_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectAddressingMode_5_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && OuterDisplacement(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L (SQUARE_L (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? ROUND_R
public static boolean MemoryIndirectPostIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokenFast(b, ROUND_L);
r = r && MemoryIndirectPostIndexedAddressingMode_1(b, l + 1);
r = r && IndexRegister(b, l + 1);
r = r && MemoryIndirectPostIndexedAddressingMode_3(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (SQUARE_L (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) SQUARE_R SEPARATOR)?
private static boolean MemoryIndirectPostIndexedAddressingMode_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1")) return false;
MemoryIndirectPostIndexedAddressingMode_1_0(b, l + 1);
return true;
}
// SQUARE_L (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) SQUARE_R SEPARATOR
private static boolean MemoryIndirectPostIndexedAddressingMode_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SQUARE_L);
r = r && MemoryIndirectPostIndexedAddressingMode_1_0_1(b, l + 1);
r = r && consumeTokens(b, 0, SQUARE_R, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2
private static boolean MemoryIndirectPostIndexedAddressingMode_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_1_0_1")) return false;
boolean r;
r = internalMemoryIndirectPostIndexedOption1(b, l + 1);
if (!r) r = internalMemoryIndirectPostIndexedOption2(b, l + 1);
return r;
}
// (SEPARATOR OuterDisplacement)?
private static boolean MemoryIndirectPostIndexedAddressingMode_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_3")) return false;
MemoryIndirectPostIndexedAddressingMode_3_0(b, l + 1);
return true;
}
// SEPARATOR OuterDisplacement
private static boolean MemoryIndirectPostIndexedAddressingMode_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPostIndexedAddressingMode_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && OuterDisplacement(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
public static boolean MemoryIndirectPreIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && MemoryIndirectPreIndexedAddressingMode_2(b, l + 1);
r = r && MemoryIndirectPreIndexedAddressingMode_3(b, l + 1);
r = r && IndexRegister(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
r = r && MemoryIndirectPreIndexedAddressingMode_6(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean MemoryIndirectPreIndexedAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_2")) return false;
MemoryIndirectPreIndexedAddressingMode_2_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean MemoryIndirectPreIndexedAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (AddressRegister SEPARATOR)?
private static boolean MemoryIndirectPreIndexedAddressingMode_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_3")) return false;
MemoryIndirectPreIndexedAddressingMode_3_0(b, l + 1);
return true;
}
// AddressRegister SEPARATOR
private static boolean MemoryIndirectPreIndexedAddressingMode_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = AddressRegister(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR OuterDisplacement)?
private static boolean MemoryIndirectPreIndexedAddressingMode_6(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_6")) return false;
MemoryIndirectPreIndexedAddressingMode_6_0(b, l + 1);
return true;
}
// SEPARATOR OuterDisplacement
private static boolean MemoryIndirectPreIndexedAddressingMode_6_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MemoryIndirectPreIndexedAddressingMode_6_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && OuterDisplacement(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// OPSIZE_BS|OPSIZE_W|OPSIZE_L
public static boolean OperandSize(PsiBuilder b, int l) {
@@ -764,6 +1062,25 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// expr DataWidth?
public static boolean OuterDisplacement(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "OuterDisplacement")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, OUTER_DISPLACEMENT, "<outer displacement>");
r = expr(b, l + 1, -1);
r = r && OuterDisplacement_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// DataWidth?
private static boolean OuterDisplacement_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "OuterDisplacement_1")) return false;
DataWidth(b, l + 1);
return true;
}
/* ********************************************************** */
// (expr|AddressingMode) (SEPARATOR (expr|AddressingMode))*
static boolean PlainOperands(PsiBuilder b, int l) {
@@ -817,28 +1134,21 @@ public class M68kParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// Label? PreprocessorKeyword PreprocessorOperands?
// PreprocessorKeyword PreprocessorOperands?
public static boolean PreprocessorDirective(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "PreprocessorDirective")) return false;
if (!nextTokenIs(b, "<preprocessor directive>", DATA_DIRECTIVE, OTHER_DIRECTIVE)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PREPROCESSOR_DIRECTIVE, "<preprocessor directive>");
r = PreprocessorDirective_0(b, l + 1);
r = r && PreprocessorKeyword(b, l + 1);
r = r && PreprocessorDirective_2(b, l + 1);
r = PreprocessorKeyword(b, l + 1);
r = r && PreprocessorDirective_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// Label?
private static boolean PreprocessorDirective_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "PreprocessorDirective_0")) return false;
Label(b, l + 1);
return true;
}
// PreprocessorOperands?
private static boolean PreprocessorDirective_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "PreprocessorDirective_2")) return false;
private static boolean PreprocessorDirective_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "PreprocessorDirective_1")) return false;
PreprocessorOperands(b, l + 1);
return true;
}
@@ -943,6 +1253,58 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// ROUND_L (BaseDisplacement SEPARATOR)? PC (SEPARATOR IndexRegister)? ROUND_R
public static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokenFast(b, ROUND_L);
r = r && ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1(b, l + 1);
r = r && consumeToken(b, PC);
r = r && ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1")) return false;
ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR IndexRegister)?
private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3")) return false;
ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3_0(b, l + 1);
return true;
}
// SEPARATOR IndexRegister
private static boolean ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && IndexRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L (expr SEPARATOR)? PC SEPARATOR IndexRegister ROUND_R
public static boolean ProgramCounterIndirectWithIndexNewAddressingMode(PsiBuilder b, int l) {
@@ -998,6 +1360,183 @@ public class M68kParser implements PsiParser, LightPsiParser {
return true;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
public static boolean ProgramCounterMemoryIndirectAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && ProgramCounterMemoryIndirectAddressingMode_2(b, l + 1);
r = r && consumeTokens(b, 0, PC, SQUARE_R);
r = r && ProgramCounterMemoryIndirectAddressingMode_5(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_2")) return false;
ProgramCounterMemoryIndirectAddressingMode_2_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean ProgramCounterMemoryIndirectAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR OuterDisplacement)?
private static boolean ProgramCounterMemoryIndirectAddressingMode_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_5")) return false;
ProgramCounterMemoryIndirectAddressingMode_5_0(b, l + 1);
return true;
}
// SEPARATOR OuterDisplacement
private static boolean ProgramCounterMemoryIndirectAddressingMode_5_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectAddressingMode_5_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && OuterDisplacement(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L (SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? ROUND_R
public static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokenFast(b, ROUND_L);
r = r && ProgramCounterMemoryIndirectPostIndexedAddressingMode_1(b, l + 1);
r = r && IndexRegister(b, l + 1);
r = r && ProgramCounterMemoryIndirectPostIndexedAddressingMode_3(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1")) return false;
ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0(b, l + 1);
return true;
}
// SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R SEPARATOR
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SQUARE_L);
r = r && ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1(b, l + 1);
r = r && consumeTokens(b, 0, PC, SQUARE_R, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1")) return false;
ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_1_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR OuterDisplacement)?
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_3")) return false;
ProgramCounterMemoryIndirectPostIndexedAddressingMode_3_0(b, l + 1);
return true;
}
// SEPARATOR OuterDisplacement
private static boolean ProgramCounterMemoryIndirectPostIndexedAddressingMode_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPostIndexedAddressingMode_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && OuterDisplacement(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SEPARATOR IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
public static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode")) return false;
if (!nextTokenIsFast(b, ROUND_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE, "<AddressingMode>");
r = consumeTokens(b, 0, ROUND_L, SQUARE_L);
r = r && ProgramCounterMemoryIndirectPreIndexedAddressingMode_2(b, l + 1);
r = r && consumeTokens(b, 0, PC, SEPARATOR);
r = r && IndexRegister(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
r = r && ProgramCounterMemoryIndirectPreIndexedAddressingMode_7(b, l + 1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, l, m, r, false, null);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_2")) return false;
ProgramCounterMemoryIndirectPreIndexedAddressingMode_2_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR OuterDisplacement)?
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_7(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_7")) return false;
ProgramCounterMemoryIndirectPreIndexedAddressingMode_7_0(b, l + 1);
return true;
}
// SEPARATOR OuterDisplacement
private static boolean ProgramCounterMemoryIndirectPreIndexedAddressingMode_7_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ProgramCounterMemoryIndirectPreIndexedAddressingMode_7_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, SEPARATOR);
r = r && OuterDisplacement(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// CURRENT_PC_SYMBOL
public static boolean ProgramCounterReference(PsiBuilder b, int l) {
@@ -1125,7 +1664,7 @@ public class M68kParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// REG_CCR | REG_SR | REG_USP | REG_VBR
// REG_CCR | REG_SR | REG_USP | REG_VBR | REG_SFC | REG_DFC
public static boolean SpecialRegister(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SpecialRegister")) return false;
boolean r;
@@ -1134,6 +1673,8 @@ public class M68kParser implements PsiParser, LightPsiParser {
if (!r) r = consumeToken(b, REG_SR);
if (!r) r = consumeToken(b, REG_USP);
if (!r) r = consumeToken(b, REG_VBR);
if (!r) r = consumeToken(b, REG_SFC);
if (!r) r = consumeToken(b, REG_DFC);
exit_section_(b, l, m, r, false, null);
return r;
}
@@ -1173,6 +1714,213 @@ public class M68kParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister
static boolean internalBaseDisplacementOption1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption1")) return false;
boolean r;
Marker m = enter_section_(b);
r = internalBaseDisplacementOption1_0(b, l + 1);
r = r && internalBaseDisplacementOption1_1(b, l + 1);
r = r && IndexRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean internalBaseDisplacementOption1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_0")) return false;
internalBaseDisplacementOption1_0_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean internalBaseDisplacementOption1_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (AddressRegister SEPARATOR)?
private static boolean internalBaseDisplacementOption1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_1")) return false;
internalBaseDisplacementOption1_1_0(b, l + 1);
return true;
}
// AddressRegister SEPARATOR
private static boolean internalBaseDisplacementOption1_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption1_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = AddressRegister(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// (BaseDisplacement SEPARATOR)? AddressRegister (SEPARATOR IndexRegister)?
static boolean internalBaseDisplacementOption2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption2")) return false;
boolean r;
Marker m = enter_section_(b);
r = internalBaseDisplacementOption2_0(b, l + 1);
r = r && AddressRegister(b, l + 1);
r = r && internalBaseDisplacementOption2_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean internalBaseDisplacementOption2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_0")) return false;
internalBaseDisplacementOption2_0_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean internalBaseDisplacementOption2_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR IndexRegister)?
private static boolean internalBaseDisplacementOption2_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_2")) return false;
internalBaseDisplacementOption2_2_0(b, l + 1);
return true;
}
// SEPARATOR IndexRegister
private static boolean internalBaseDisplacementOption2_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption2_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SEPARATOR);
r = r && IndexRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// BaseDisplacement (SEPARATOR AddressRegister)? (SEPARATOR IndexRegister)?
static boolean internalBaseDisplacementOption3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption3")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && internalBaseDisplacementOption3_1(b, l + 1);
r = r && internalBaseDisplacementOption3_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR AddressRegister)?
private static boolean internalBaseDisplacementOption3_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_1")) return false;
internalBaseDisplacementOption3_1_0(b, l + 1);
return true;
}
// SEPARATOR AddressRegister
private static boolean internalBaseDisplacementOption3_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SEPARATOR);
r = r && AddressRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR IndexRegister)?
private static boolean internalBaseDisplacementOption3_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_2")) return false;
internalBaseDisplacementOption3_2_0(b, l + 1);
return true;
}
// SEPARATOR IndexRegister
private static boolean internalBaseDisplacementOption3_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalBaseDisplacementOption3_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SEPARATOR);
r = r && IndexRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// (BaseDisplacement SEPARATOR)? AddressRegister
static boolean internalMemoryIndirectPostIndexedOption1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption1")) return false;
boolean r;
Marker m = enter_section_(b);
r = internalMemoryIndirectPostIndexedOption1_0(b, l + 1);
r = r && AddressRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (BaseDisplacement SEPARATOR)?
private static boolean internalMemoryIndirectPostIndexedOption1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption1_0")) return false;
internalMemoryIndirectPostIndexedOption1_0_0(b, l + 1);
return true;
}
// BaseDisplacement SEPARATOR
private static boolean internalMemoryIndirectPostIndexedOption1_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption1_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// BaseDisplacement (SEPARATOR AddressRegister)?
static boolean internalMemoryIndirectPostIndexedOption2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption2")) return false;
boolean r;
Marker m = enter_section_(b);
r = BaseDisplacement(b, l + 1);
r = r && internalMemoryIndirectPostIndexedOption2_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR AddressRegister)?
private static boolean internalMemoryIndirectPostIndexedOption2_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption2_1")) return false;
internalMemoryIndirectPostIndexedOption2_1_0(b, l + 1);
return true;
}
// SEPARATOR AddressRegister
private static boolean internalMemoryIndirectPostIndexedOption2_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "internalMemoryIndirectPostIndexedOption2_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SEPARATOR);
r = r && AddressRegister(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// !<<eof>> (MacroDefinition | statement) (<<eof>>|EOL)
static boolean line(PsiBuilder b, int l) {
@@ -1220,14 +1968,12 @@ public class M68kParser implements PsiParser, LightPsiParser {
/* ********************************************************** */
// Assignment
// | PreprocessorDirective
// | LabelInsts
public static boolean statement(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "statement")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, STATEMENT, "<statement>");
r = Assignment(b, l + 1);
if (!r) r = PreprocessorDirective(b, l + 1);
if (!r) r = LabelInsts(b, l + 1);
exit_section_(b, l, m, r, false, M68kParser::statement_recover);
return r;
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode.java
+17
View File
@@ -0,0 +1,17 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.Nullable;
public interface M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode extends M68kAddressingMode, M68kWithOptionalAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithOptionalIndexRegister {
@Nullable
M68kAddressRegister getAddressRegister();
@Nullable
M68kIndexRegister getIndexRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kBaseDisplacement.java
+15
View File
@@ -0,0 +1,15 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kBaseDisplacement extends M68kPsiElement {
@Nullable
M68kDataWidth getDataWidth();
@NotNull
M68kExpr getExpr();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kIndexRegister.java
+3
View File
@@ -9,6 +9,9 @@ public interface M68kIndexRegister extends M68kPsiElement {
@Nullable
M68kDataWidth getDataWidth();
@Nullable
M68kIndexScale getIndexScale();
@NotNull
M68kRegister getRegister();
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kIndexScale.java
+11
View File
@@ -0,0 +1,11 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
public interface M68kIndexScale extends M68kPsiElement {
@NotNull
M68kExpr getIndexScale();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectAddressingMode.java
+18
View File
@@ -0,0 +1,18 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kMemoryIndirectAddressingMode extends M68kAddressingMode, M68kWithAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithOuterDisplacement {
@NotNull
M68kAddressRegister getAddressRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
@Nullable
M68kOuterDisplacement getOuterDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectPostIndexedAddressingMode.java
+21
View File
@@ -0,0 +1,21 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kMemoryIndirectPostIndexedAddressingMode extends M68kAddressingMode, M68kWithOptionalAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@Nullable
M68kAddressRegister getAddressRegister();
@NotNull
M68kIndexRegister getIndexRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
@Nullable
M68kOuterDisplacement getOuterDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kMemoryIndirectPreIndexedAddressingMode.java
+21
View File
@@ -0,0 +1,21 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kMemoryIndirectPreIndexedAddressingMode extends M68kAddressingMode, M68kWithOptionalAddressRegisterIndirect, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@Nullable
M68kAddressRegister getAddressRegister();
@NotNull
M68kIndexRegister getIndexRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
@Nullable
M68kOuterDisplacement getOuterDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kOuterDisplacement.java
+15
View File
@@ -0,0 +1,15 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kOuterDisplacement extends M68kPsiElement {
@Nullable
M68kDataWidth getDataWidth();
@NotNull
M68kExpr getExpr();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kPreprocessorDirective.java
-7
View File
@@ -2,18 +2,11 @@
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public interface M68kPreprocessorDirective extends M68kPsiElement {
@Nullable
M68kGlobalLabel getGlobalLabel();
@Nullable
M68kLocalLabel getLocalLabel();
@NotNull
M68kPreprocessorKeyword getPreprocessorKeyword();
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode.java
+14
View File
@@ -0,0 +1,14 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.Nullable;
public interface M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithOptionalIndexRegister {
@Nullable
M68kIndexRegister getIndexRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectAddressingMode.java
+14
View File
@@ -0,0 +1,14 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.Nullable;
public interface M68kProgramCounterMemoryIndirectAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithOuterDisplacement {
@Nullable
M68kBaseDisplacement getBaseDisplacement();
@Nullable
M68kOuterDisplacement getOuterDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectPostIndexedAddressingMode.java
+18
View File
@@ -0,0 +1,18 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kProgramCounterMemoryIndirectPostIndexedAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@NotNull
M68kIndexRegister getIndexRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
@Nullable
M68kOuterDisplacement getOuterDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kProgramCounterMemoryIndirectPreIndexedAddressingMode.java
+18
View File
@@ -0,0 +1,18 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface M68kProgramCounterMemoryIndirectPreIndexedAddressingMode extends M68kAddressingMode, M68kWithBaseDisplacement, M68kWithIndexRegister, M68kWithOuterDisplacement {
@NotNull
M68kIndexRegister getIndexRegister();
@Nullable
M68kBaseDisplacement getBaseDisplacement();
@Nullable
M68kOuterDisplacement getOuterDisplacement();
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kTypes.java
+37
View File
@@ -18,12 +18,14 @@ public interface M68kTypes {
IElementType ADDRESS_REGISTER_INDIRECT_PRE_DEC_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_PRE_DEC_ADDRESSING_MODE");
IElementType ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE");
IElementType ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE");
IElementType ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE");
IElementType ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE");
IElementType ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE = new M68kElementType("ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE");
IElementType ADDRESS_SIZE = new M68kElementType("ADDRESS_SIZE");
IElementType ASM_INSTRUCTION = new M68kElementType("ASM_INSTRUCTION");
IElementType ASM_OP = new M68kElementType("ASM_OP");
IElementType ASSIGNMENT = new M68kElementType("ASSIGNMENT");
IElementType BASE_DISPLACEMENT = new M68kElementType("BASE_DISPLACEMENT");
IElementType BINARY_ADD_EXPR = new M68kElementType("BINARY_ADD_EXPR");
IElementType BINARY_BITWISE_AND_EXPR = new M68kElementType("BINARY_BITWISE_AND_EXPR");
IElementType BINARY_BITWISE_OR_EXPR = new M68kElementType("BINARY_BITWISE_OR_EXPR");
@@ -49,20 +51,29 @@ public interface M68kTypes {
IElementType GLOBAL_LABEL = M68kStubElementTypeFactory.stubFactory("GLOBAL_LABEL");
IElementType IMMEDIATE_DATA = new M68kElementType("IMMEDIATE_DATA");
IElementType INDEX_REGISTER = new M68kElementType("INDEX_REGISTER");
IElementType INDEX_SCALE = new M68kElementType("INDEX_SCALE");
IElementType LITERAL_EXPR = new M68kElementType("LITERAL_EXPR");
IElementType LOCAL_LABEL = new M68kElementType("LOCAL_LABEL");
IElementType MACRO_CALL = new M68kElementType("MACRO_CALL");
IElementType MACRO_DEFINITION = M68kStubElementTypeFactory.stubFactory("MACRO_DEFINITION");
IElementType MACRO_NAME_DEFINITION = new M68kElementType("MACRO_NAME_DEFINITION");
IElementType MACRO_PLAIN_LINE = new M68kElementType("MACRO_PLAIN_LINE");
IElementType MEMORY_INDIRECT_ADDRESSING_MODE = new M68kElementType("MEMORY_INDIRECT_ADDRESSING_MODE");
IElementType MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE = new M68kElementType("MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE");
IElementType MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE = new M68kElementType("MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE");
IElementType OPERAND_SIZE = new M68kElementType("OPERAND_SIZE");
IElementType OUTER_DISPLACEMENT = new M68kElementType("OUTER_DISPLACEMENT");
IElementType PAREN_EXPR = new M68kElementType("PAREN_EXPR");
IElementType PREPROCESSOR_DIRECTIVE = new M68kElementType("PREPROCESSOR_DIRECTIVE");
IElementType PREPROCESSOR_KEYWORD = new M68kElementType("PREPROCESSOR_KEYWORD");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_NEW_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE = new M68kElementType("PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE");
IElementType PROGRAM_COUNTER_REFERENCE = new M68kElementType("PROGRAM_COUNTER_REFERENCE");
IElementType REF_EXPR = new M68kElementType("REF_EXPR");
IElementType REGISTER = new M68kElementType("REGISTER");
@@ -126,6 +137,8 @@ public interface M68kTypes {
IElementType OTHER_DIRECTIVE = new M68kTokenType("OTHER_DIRECTIVE");
IElementType PC = new M68kTokenType("PC");
IElementType REG_CCR = new M68kTokenType("REG_CCR");
IElementType REG_DFC = new M68kTokenType("REG_DFC");
IElementType REG_SFC = new M68kTokenType("REG_SFC");
IElementType REG_SP = new M68kTokenType("REG_SP");
IElementType REG_SR = new M68kTokenType("REG_SR");
IElementType REG_USP = new M68kTokenType("REG_USP");
@@ -133,6 +146,8 @@ public interface M68kTypes {
IElementType ROUND_L = new M68kTokenType("ROUND_L");
IElementType ROUND_R = new M68kTokenType("ROUND_R");
IElementType SEPARATOR = new M68kTokenType("SEPARATOR");
IElementType SQUARE_L = new M68kTokenType("SQUARE_L");
IElementType SQUARE_R = new M68kTokenType("SQUARE_R");
IElementType STRINGLIT = new M68kTokenType("STRINGLIT");
IElementType SYMBOL = new M68kTokenType("SYMBOL");
IElementType SYMBOLDEF = new M68kTokenType("SYMBOLDEF");
@@ -156,6 +171,8 @@ public interface M68kTypes {
return new M68kAddressRegisterIndirectWithDisplacementNewAddressingModeImpl(node);
} else if (type == ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE) {
return new M68kAddressRegisterIndirectWithDisplacementOldAddressingModeImpl(node);
} else if (type == ADDRESS_REGISTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE) {
return new M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl(node);
} else if (type == ADDRESS_REGISTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE) {
return new M68kAddressRegisterIndirectWithIndexNewAddressingModeImpl(node);
} else if (type == ADDRESS_REGISTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE) {
@@ -168,6 +185,8 @@ public interface M68kTypes {
return new M68kAsmOpImpl(node);
} else if (type == ASSIGNMENT) {
return new M68kAssignmentImpl(node);
} else if (type == BASE_DISPLACEMENT) {
return new M68kBaseDisplacementImpl(node);
} else if (type == BINARY_ADD_EXPR) {
return new M68kBinaryAddExprImpl(node);
} else if (type == BINARY_BITWISE_AND_EXPR) {
@@ -216,6 +235,8 @@ public interface M68kTypes {
return new M68kImmediateDataImpl(node);
} else if (type == INDEX_REGISTER) {
return new M68kIndexRegisterImpl(node);
} else if (type == INDEX_SCALE) {
return new M68kIndexScaleImpl(node);
} else if (type == LITERAL_EXPR) {
return new M68kLiteralExprImpl(node);
} else if (type == LOCAL_LABEL) {
@@ -228,8 +249,16 @@ public interface M68kTypes {
return new M68kMacroNameDefinitionImpl(node);
} else if (type == MACRO_PLAIN_LINE) {
return new M68kMacroPlainLineImpl(node);
} else if (type == MEMORY_INDIRECT_ADDRESSING_MODE) {
return new M68kMemoryIndirectAddressingModeImpl(node);
} else if (type == MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE) {
return new M68kMemoryIndirectPostIndexedAddressingModeImpl(node);
} else if (type == MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE) {
return new M68kMemoryIndirectPreIndexedAddressingModeImpl(node);
} else if (type == OPERAND_SIZE) {
return new M68kOperandSizeImpl(node);
} else if (type == OUTER_DISPLACEMENT) {
return new M68kOuterDisplacementImpl(node);
} else if (type == PAREN_EXPR) {
return new M68kParenExprImpl(node);
} else if (type == PREPROCESSOR_DIRECTIVE) {
@@ -240,10 +269,18 @@ public interface M68kTypes {
return new M68kProgramCounterIndirectWithDisplacementNewAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT_OLD_ADDRESSING_MODE) {
return new M68kProgramCounterIndirectWithDisplacementOldAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE) {
return new M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_INDIRECT_WITH_INDEX_NEW_ADDRESSING_MODE) {
return new M68kProgramCounterIndirectWithIndexNewAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_INDIRECT_WITH_INDEX_OLD_ADDRESSING_MODE) {
return new M68kProgramCounterIndirectWithIndexOldAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE) {
return new M68kProgramCounterMemoryIndirectAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE) {
return new M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE) {
return new M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(node);
} else if (type == PROGRAM_COUNTER_REFERENCE) {
return new M68kProgramCounterReferenceImpl(node);
} else if (type == REF_EXPR) {
src/main/gen/de/platon42/intellij/plugins/m68k/psi/M68kVisitor.java
+68
View File
@@ -45,6 +45,13 @@ public class M68kVisitor extends PsiElementVisitor {
// visitWithDisplacement(o);
}
public void visitAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(@NotNull M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode o) {
visitAddressingMode(o);
// visitWithOptionalAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithOptionalIndexRegister(o);
}
public void visitAddressRegisterIndirectWithIndexNewAddressingMode(@NotNull M68kAddressRegisterIndirectWithIndexNewAddressingMode o) {
visitAddressingMode(o);
// visitWithAddressRegisterIndirect(o);
@@ -79,6 +86,10 @@ public class M68kVisitor extends PsiElementVisitor {
visitPsiElement(o);
}
public void visitBaseDisplacement(@NotNull M68kBaseDisplacement o) {
visitPsiElement(o);
}
public void visitDataRegister(@NotNull M68kDataRegister o) {
visitRegister(o);
}
@@ -103,6 +114,10 @@ public class M68kVisitor extends PsiElementVisitor {
visitPsiElement(o);
}
public void visitIndexScale(@NotNull M68kIndexScale o) {
visitPsiElement(o);
}
public void visitLocalLabel(@NotNull M68kLocalLabel o) {
visitNamedElement(o);
}
@@ -123,10 +138,37 @@ public class M68kVisitor extends PsiElementVisitor {
visitPsiElement(o);
}
public void visitMemoryIndirectAddressingMode(@NotNull M68kMemoryIndirectAddressingMode o) {
visitAddressingMode(o);
// visitWithAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithOuterDisplacement(o);
}
public void visitMemoryIndirectPostIndexedAddressingMode(@NotNull M68kMemoryIndirectPostIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithOptionalAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitMemoryIndirectPreIndexedAddressingMode(@NotNull M68kMemoryIndirectPreIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithOptionalAddressRegisterIndirect(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitOperandSize(@NotNull M68kOperandSize o) {
visitPsiElement(o);
}
public void visitOuterDisplacement(@NotNull M68kOuterDisplacement o) {
visitPsiElement(o);
}
public void visitPreprocessorDirective(@NotNull M68kPreprocessorDirective o) {
visitPsiElement(o);
}
@@ -145,6 +187,12 @@ public class M68kVisitor extends PsiElementVisitor {
// visitWithDisplacement(o);
}
public void visitProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(@NotNull M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithOptionalIndexRegister(o);
}
public void visitProgramCounterIndirectWithIndexNewAddressingMode(@NotNull M68kProgramCounterIndirectWithIndexNewAddressingMode o) {
visitAddressingMode(o);
// visitWithDisplacement(o);
@@ -157,6 +205,26 @@ public class M68kVisitor extends PsiElementVisitor {
// visitWithIndexRegister(o);
}
public void visitProgramCounterMemoryIndirectAddressingMode(@NotNull M68kProgramCounterMemoryIndirectAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithOuterDisplacement(o);
}
public void visitProgramCounterMemoryIndirectPostIndexedAddressingMode(@NotNull M68kProgramCounterMemoryIndirectPostIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitProgramCounterMemoryIndirectPreIndexedAddressingMode(@NotNull M68kProgramCounterMemoryIndirectPreIndexedAddressingMode o) {
visitAddressingMode(o);
// visitWithBaseDisplacement(o);
// visitWithIndexRegister(o);
// visitWithOuterDisplacement(o);
}
public void visitProgramCounterReference(@NotNull M68kProgramCounterReference o) {
visitPsiElement(o);
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl.java
+46
View File
@@ -0,0 +1,46 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl extends M68kAddressingModeImpl implements M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode {
public M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kAddressRegister getAddressRegister() {
return PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class);
}
@Override
@Nullable
public M68kIndexRegister getIndexRegister() {
return PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class);
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kBaseDisplacementImpl.java
+43
View File
@@ -0,0 +1,43 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.extapi.psi.ASTWrapperPsiElement;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kBaseDisplacement;
import de.platon42.intellij.plugins.m68k.psi.M68kDataWidth;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kBaseDisplacementImpl extends ASTWrapperPsiElement implements M68kBaseDisplacement {
public M68kBaseDisplacementImpl(@NotNull ASTNode node) {
super(node);
}
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitBaseDisplacement(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kDataWidth getDataWidth() {
return PsiTreeUtil.getChildOfType(this, M68kDataWidth.class);
}
@Override
@NotNull
public M68kExpr getExpr() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kExpr.class));
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kGlobalLabelImpl.java
+2 -2
View File
@@ -19,8 +19,8 @@ public class M68kGlobalLabelImpl extends M68kGlobalLabelMixin implements M68kGlo
super(node);
}
public M68kGlobalLabelImpl(@NotNull M68kGlobalLabelStub stub, @NotNull IStubElementType<?, ?> nodeType) {
super(stub, nodeType);
public M68kGlobalLabelImpl(@NotNull M68kGlobalLabelStub stub, @NotNull IStubElementType<?, ?> type) {
super(stub, type);
}
public void accept(@NotNull M68kVisitor visitor) {
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kIndexRegisterImpl.java
+6
View File
@@ -31,6 +31,12 @@ public class M68kIndexRegisterImpl extends ASTWrapperPsiElement implements M68kI
return PsiTreeUtil.getChildOfType(this, M68kDataWidth.class);
}
@Override
@Nullable
public M68kIndexScale getIndexScale() {
return PsiTreeUtil.getChildOfType(this, M68kIndexScale.class);
}
@Override
@NotNull
public M68kRegister getRegister() {
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kIndexScaleImpl.java
+35
View File
@@ -0,0 +1,35 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.extapi.psi.ASTWrapperPsiElement;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kIndexScale;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
public class M68kIndexScaleImpl extends ASTWrapperPsiElement implements M68kIndexScale {
public M68kIndexScaleImpl(@NotNull ASTNode node) {
super(node);
}
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitIndexScale(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kExpr getIndexScale() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kExpr.class));
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMacroDefinitionImpl.java
+2 -2
View File
@@ -19,8 +19,8 @@ public class M68kMacroDefinitionImpl extends M68kMacroDefinitionMixin implements
super(node);
}
public M68kMacroDefinitionImpl(@NotNull M68kMacroDefinitionStub stub, @NotNull IStubElementType<?, ?> nodeType) {
super(stub, nodeType);
public M68kMacroDefinitionImpl(@NotNull M68kMacroDefinitionStub stub, @NotNull IStubElementType<?, ?> type) {
super(stub, type);
}
public void accept(@NotNull M68kVisitor visitor) {
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectAddressingModeImpl.java
+46
View File
@@ -0,0 +1,46 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kMemoryIndirectAddressingModeImpl extends M68kAddressingModeImpl implements M68kMemoryIndirectAddressingMode {
public M68kMemoryIndirectAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitMemoryIndirectAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kAddressRegister getAddressRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class));
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
@Override
@Nullable
public M68kOuterDisplacement getOuterDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectPostIndexedAddressingModeImpl.java
+52
View File
@@ -0,0 +1,52 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kMemoryIndirectPostIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kMemoryIndirectPostIndexedAddressingMode {
public M68kMemoryIndirectPostIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitMemoryIndirectPostIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kAddressRegister getAddressRegister() {
return PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
@Override
@Nullable
public M68kOuterDisplacement getOuterDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kMemoryIndirectPreIndexedAddressingModeImpl.java
+52
View File
@@ -0,0 +1,52 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kMemoryIndirectPreIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kMemoryIndirectPreIndexedAddressingMode {
public M68kMemoryIndirectPreIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitMemoryIndirectPreIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kAddressRegister getAddressRegister() {
return PsiTreeUtil.getChildOfType(this, M68kAddressRegister.class);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
@Override
@Nullable
public M68kOuterDisplacement getOuterDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kOuterDisplacementImpl.java
+43
View File
@@ -0,0 +1,43 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.extapi.psi.ASTWrapperPsiElement;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kDataWidth;
import de.platon42.intellij.plugins.m68k.psi.M68kExpr;
import de.platon42.intellij.plugins.m68k.psi.M68kOuterDisplacement;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kOuterDisplacementImpl extends ASTWrapperPsiElement implements M68kOuterDisplacement {
public M68kOuterDisplacementImpl(@NotNull ASTNode node) {
super(node);
}
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitOuterDisplacement(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kDataWidth getDataWidth() {
return PsiTreeUtil.getChildOfType(this, M68kDataWidth.class);
}
@Override
@NotNull
public M68kExpr getExpr() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kExpr.class));
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kPreprocessorDirectiveImpl.java
-13
View File
@@ -6,7 +6,6 @@ import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
@@ -26,18 +25,6 @@ public class M68kPreprocessorDirectiveImpl extends M68kPreprocessorDirectiveMixi
else super.accept(visitor);
}
@Override
@Nullable
public M68kGlobalLabel getGlobalLabel() {
return PsiTreeUtil.getChildOfType(this, M68kGlobalLabel.class);
}
@Override
@Nullable
public M68kLocalLabel getLocalLabel() {
return PsiTreeUtil.getChildOfType(this, M68kLocalLabel.class);
}
@Override
@NotNull
public M68kPreprocessorKeyword getPreprocessorKeyword() {
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl.java
+43
View File
@@ -0,0 +1,43 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kBaseDisplacement;
import de.platon42.intellij.plugins.m68k.psi.M68kIndexRegister;
import de.platon42.intellij.plugins.m68k.psi.M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode {
public M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterIndirectWithIndexBaseDisplacementAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kIndexRegister getIndexRegister() {
return PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class);
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectAddressingModeImpl.java
+43
View File
@@ -0,0 +1,43 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.M68kBaseDisplacement;
import de.platon42.intellij.plugins.m68k.psi.M68kOuterDisplacement;
import de.platon42.intellij.plugins.m68k.psi.M68kProgramCounterMemoryIndirectAddressingMode;
import de.platon42.intellij.plugins.m68k.psi.M68kVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kProgramCounterMemoryIndirectAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterMemoryIndirectAddressingMode {
public M68kProgramCounterMemoryIndirectAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterMemoryIndirectAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
@Override
@Nullable
public M68kOuterDisplacement getOuterDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl.java
+46
View File
@@ -0,0 +1,46 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterMemoryIndirectPostIndexedAddressingMode {
public M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterMemoryIndirectPostIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
@Override
@Nullable
public M68kOuterDisplacement getOuterDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl.java
+46
View File
@@ -0,0 +1,46 @@
// This is a generated file. Not intended for manual editing.
package de.platon42.intellij.plugins.m68k.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import de.platon42.intellij.plugins.m68k.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl extends M68kAddressingModeImpl implements M68kProgramCounterMemoryIndirectPreIndexedAddressingMode {
public M68kProgramCounterMemoryIndirectPreIndexedAddressingModeImpl(@NotNull ASTNode node) {
super(node);
}
@Override
public void accept(@NotNull M68kVisitor visitor) {
visitor.visitProgramCounterMemoryIndirectPreIndexedAddressingMode(this);
}
@Override
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof M68kVisitor) accept((M68kVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public M68kIndexRegister getIndexRegister() {
return notNullChild(PsiTreeUtil.getChildOfType(this, M68kIndexRegister.class));
}
@Override
@Nullable
public M68kBaseDisplacement getBaseDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kBaseDisplacement.class);
}
@Override
@Nullable
public M68kOuterDisplacement getOuterDisplacement() {
return PsiTreeUtil.getChildOfType(this, M68kOuterDisplacement.class);
}
}
src/main/gen/de/platon42/intellij/plugins/m68k/psi/impl/M68kSymbolDefinitionImpl.java
+2 -2
View File
@@ -19,8 +19,8 @@ public class M68kSymbolDefinitionImpl extends M68kSymbolDefinitionMixin implemen
super(node);
}
public M68kSymbolDefinitionImpl(@NotNull M68kSymbolDefinitionStub stub, @NotNull IStubElementType<?, ?> nodeType) {
super(stub, nodeType);
public M68kSymbolDefinitionImpl(@NotNull M68kSymbolDefinitionStub stub, @NotNull IStubElementType<?, ?> type) {
super(stub, type);
}
public void accept(@NotNull M68kVisitor visitor) {
src/main/java/de/platon42/intellij/plugins/m68k/M68kFileElementType.kt
+1 -1
View File
@@ -10,7 +10,7 @@ class M68kFileElementType private constructor() : ILightStubFileElementType<PsiF
@JvmField
val INSTANCE = M68kFileElementType()
const val STUB_VERSION = 6
const val STUB_VERSION = 7
const val STUB_EXTERNAL_ID_PREFIX = "MC68000."
const val EXTERNAL_ID = STUB_EXTERNAL_ID_PREFIX + "FILE"
}
src/main/java/de/platon42/intellij/plugins/m68k/asm/M68kIsa.kt
+344 -34
View File
@@ -1,5 +1,7 @@
package de.platon42.intellij.plugins.m68k.asm
import java.util.*
enum class Machine {
MC68000,
MC68010,
@@ -9,6 +11,10 @@ enum class Machine {
MC68060
}
private val MC68000_ONLY = EnumSet.of(Machine.MC68000)
private val MC68020_PLUS = EnumSet.range(Machine.MC68020, Machine.MC68060)
private val ALL_MACHINES = EnumSet.allOf(Machine::class.java)
enum class Register(val regname: String, val num: Int) {
D0("d0", 0),
D1("d1", 1),
@@ -43,8 +49,18 @@ enum class AddressMode(val description: String, val syntax: String) {
ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT("address register indirect with displacement", "(d16,An)"),
PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT("program counter indirect with displacement", "(d16,PC)"),
ADDRESS_REGISTER_INDIRECT_WITH_INDEX("address register indirect with index", "(d8,An,Xn)"),
ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX("address register indirect with scaled index", "(d8,An,Xn*s)"),
ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT("address register indirect with index (base displacement)", "(bd,An,Xn*s)"),
PROGRAM_COUNTER_INDIRECT_WITH_INDEX("program counter indirect with index", "(d8,PC,Xn)"),
SPECIAL_REGISTER_DIRECT("special register", "ccr|usp|vbr"),
PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX("program counter indirect with scaled index", "(d8,PC,Xn*s)"),
PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT("program counter indirect with index (base displacement)", "(bd,PC,Xn*s)"),
MEMORY_INDIRECT("memory indirect", "([bd,An],od)"),
MEMORY_INDIRECT_POSTINDEXED("memory indirect postindexed", "([bd,An],Xn*s,od)"),
MEMORY_INDIRECT_PREINDEXED("memory indirect preindexed", "([bd,An,Xn*s],od)"),
PROGRAM_COUNTER_MEMORY_INDIRECT("program counter memory indirect", "([bd,PC],od)"),
PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED("program counter memory indirect postindexed", "([bd,PC],Xn*s,od)"),
PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED("program counter memory indirect preindexed", "([bd,PC,Xn*s],od)"),
SPECIAL_REGISTER_DIRECT("special register", "sr|ccr|usp|vbr"),
REGISTER_LIST("register list", "list"),
IMMEDIATE_DATA("immediate", "#<xxx>"),
ABSOLUTE_ADDRESS("absolute short/long", "(xxx).w|l")
@@ -128,7 +144,7 @@ data class AllowedAdrMode(
data class IsaData(
val mnemonic: String,
val description: String,
val machine: Set<Machine> = setOf(Machine.MC68000),
val machine: Set<Machine> = MC68000_ONLY,
val altMnemonics: List<String> = emptyList(),
val conditionCodes: List<String> = emptyList(),
val id: String = mnemonic,
@@ -156,6 +172,21 @@ object M68kIsa {
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX,
)
private val ALL_68020_MODES = ALL_68000_MODES.plus(
setOf(
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX,
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT,
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX,
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT,
AddressMode.MEMORY_INDIRECT,
AddressMode.MEMORY_INDIRECT_POSTINDEXED,
AddressMode.MEMORY_INDIRECT_PREINDEXED,
AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT,
AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED,
AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED
)
)
private val ALL_EXCEPT_IMMEDIATE_AND_PC_REL = setOf(
AddressMode.DATA_REGISTER_DIRECT,
AddressMode.ADDRESS_REGISTER_DIRECT,
@@ -167,6 +198,16 @@ object M68kIsa {
AddressMode.ABSOLUTE_ADDRESS
)
private val ALL_68020_MODES_EXCEPT_IMMEDIATE_AND_PC_REL = ALL_EXCEPT_IMMEDIATE_AND_PC_REL.plus(
setOf(
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX,
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT,
AddressMode.MEMORY_INDIRECT,
AddressMode.MEMORY_INDIRECT_POSTINDEXED,
AddressMode.MEMORY_INDIRECT_PREINDEXED,
)
)
private val ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL = setOf(
AddressMode.DATA_REGISTER_DIRECT,
AddressMode.ADDRESS_REGISTER_INDIRECT,
@@ -202,6 +243,18 @@ object M68kIsa {
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX,
)
private val ALL_EXCEPT_AREG_AND_DREG = setOf(
AddressMode.ADDRESS_REGISTER_INDIRECT,
AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC,
AddressMode.ADDRESS_REGISTER_INDIRECT_PRE_DEC,
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT,
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX,
AddressMode.ABSOLUTE_ADDRESS,
AddressMode.IMMEDIATE_DATA,
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT,
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX,
)
private val INDIRECT_MODES = setOf(
AddressMode.ADDRESS_REGISTER_INDIRECT,
AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC,
@@ -213,6 +266,7 @@ object M68kIsa {
private val AREG_ONLY = setOf(AddressMode.ADDRESS_REGISTER_DIRECT)
private val DREG_ONLY = setOf(AddressMode.DATA_REGISTER_DIRECT)
private val DREG_AREG = setOf(AddressMode.ADDRESS_REGISTER_DIRECT, AddressMode.DATA_REGISTER_DIRECT)
private val ADD_SUB_MODES = listOf(
AllowedAdrMode(
@@ -253,36 +307,50 @@ object M68kIsa {
)
)
private val ASD_LSD_MODES = listOf(
private val ASL_MODES = listOf(
AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("*****")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("*****")),
AllowedAdrMode(INDIRECT_MODES, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****")),
AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****")),
// not an official address mode, but supported by assembler (implicit #1)
AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("*****"))
)
private val ASR_LSD_MODES = listOf(
AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*")),
AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*")),
// not an official address mode, but supported by assembler (implicit #1)
AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"))
)
private val ROD_MODES = listOf(
AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**0*")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**0*")),
AllowedAdrMode(INDIRECT_MODES, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**0*")),
AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**0*")),
// not an official address mode, but supported by assembler (implicit #1)
AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**0*")),
)
private val ROXD_MODES = listOf(
AllowedAdrMode(DREG_ONLY, DREG_ONLY, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, modInfo = RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
AllowedAdrMode(INDIRECT_MODES, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
AllowedAdrMode(INDIRECT_MODES, null, size = OP_SIZE_W, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
// not an official address mode, but supported by assembler (implicit #1)
AllowedAdrMode(DREG_ONLY, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("***0*"), testedCc = cc("?----")),
)
private val BCHG_BCLR_BSET_MODES = listOf(
AllowedAdrMode(DREG_ONLY, DREG_ONLY, OP_SIZE_L, modInfo = RWM_READ_OP1_B or RWM_MODIFY_OP2_L, affectedCc = cc("--*--")),
AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_READ_OP1_B or RWM_MODIFY_OP2_B, affectedCc = cc("--*--")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, OP_SIZE_L, modInfo = RWM_MODIFY_OP2_L, affectedCc = cc("--*--")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_MODIFY_OP2_B, affectedCc = cc("--*--")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), ALL_EXCEPT_AREG_AND_DREG, OP_SIZE_B, modInfo = RWM_MODIFY_OP2_B, affectedCc = cc("--*--")),
)
private val BTST_MODES = listOf(
AllowedAdrMode(DREG_ONLY, DREG_ONLY, OP_SIZE_L, modInfo = RWM_READ_OP1_B or RWM_READ_OP2_L, affectedCc = cc("--*--")),
AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_READ_OP1_B or RWM_READ_OP2_B, affectedCc = cc("--*--")),
AllowedAdrMode(DREG_ONLY, ALL_EXCEPT_AREG_AND_DREG, OP_SIZE_B, modInfo = RWM_READ_OP1_B or RWM_READ_OP2_B, affectedCc = cc("--*--")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, OP_SIZE_L, modInfo = RWM_READ_OP2_L, affectedCc = cc("--*--")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), INDIRECT_MODES, OP_SIZE_B, modInfo = RWM_READ_OP2_B, affectedCc = cc("--*--")),
AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), ALL_EXCEPT_AREG_AND_DREG, OP_SIZE_B, modInfo = RWM_READ_OP2_B, affectedCc = cc("--*--")),
)
private val conditionCodes =
@@ -293,6 +361,9 @@ object M68kIsa {
private val isaData = listOf(
// Data Movement Instructions
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"move", "Move",
modes = listOf(
@@ -302,12 +373,16 @@ object M68kIsa {
)
)
),
IsaData(
"movea", "Move Address", altMnemonics = listOf("move"),
modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_SET_OP2_L))
)
),
IsaData(
"movem", "Move Multiple Registers",
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.REGISTER_LIST, AddressMode.ADDRESS_REGISTER_DIRECT, AddressMode.DATA_REGISTER_DIRECT),
@@ -354,7 +429,9 @@ object M68kIsa {
AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC,
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT,
AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX,
AddressMode.ABSOLUTE_ADDRESS
AddressMode.ABSOLUTE_ADDRESS,
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT,
AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
),
setOf(AddressMode.IMMEDIATE_DATA),
OP_SIZE_WL,
@@ -362,8 +439,10 @@ object M68kIsa {
),
)
),
IsaData(
"movep", "Move Peripheral",
machine = EnumSet.range(Machine.MC68000, Machine.MC68040),
modes = listOf(
AllowedAdrMode(
DREG_ONLY,
@@ -382,11 +461,13 @@ object M68kIsa {
IsaData(
"moveq", "Move Quick",
machine = ALL_MACHINES,
modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), DREG_ONLY, OP_SIZE_L, modInfo = RWM_SET_OP2_L, affectedCc = cc("-**00")))
),
IsaData(
"exg", "Exchange Registers",
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.DATA_REGISTER_DIRECT, AddressMode.ADDRESS_REGISTER_DIRECT),
@@ -396,6 +477,10 @@ object M68kIsa {
)
)
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"lea", "Load Effective Address",
modes = listOf(
@@ -414,6 +499,7 @@ object M68kIsa {
)
)
),
IsaData(
"pea", "Push Effective Address",
modes = listOf(
@@ -431,22 +517,32 @@ object M68kIsa {
modInfo = RWM_MODIFY_STACK
)
)
)
),
IsaData(
"link", "Link and Allocate",
machine = ALL_MACHINES,
modes = listOf(AllowedAdrMode(AREG_ONLY, setOf(AddressMode.IMMEDIATE_DATA), OP_SIZE_W, modInfo = RWM_SET_OP1_L or RWM_MODIFY_STACK))
),
IsaData(
"unlk", "Unlink",
machine = ALL_MACHINES,
modes = listOf(AllowedAdrMode(AREG_ONLY, null, OP_UNSIZED, modInfo = RWM_SET_OP1_L or RWM_MODIFY_STACK))
),
// Integer Arithmetic Instructions
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData("add", "Add", modes = ADD_SUB_MODES),
IsaData(
"adda", "Add Address", altMnemonics = listOf("add"),
modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_L))
),
IsaData(
"addi", "Add Immediate", altMnemonics = listOf("add"),
modes = listOf(
@@ -455,14 +551,22 @@ object M68kIsa {
)
)
),
IsaData("addq", "Add Quick", modes = ADDQ_SUBQ_MODES),
IsaData("addx", "Add with Extend", modes = ADDX_SUBX_MODES),
IsaData("addq", "Add Quick", modes = ADDQ_SUBQ_MODES)
),
IsaData("addx", "Add with Extend", machine = ALL_MACHINES, modes = ADDX_SUBX_MODES),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData("sub", "Subtract", modes = ADD_SUB_MODES),
IsaData(
"suba", "Subtract Address", altMnemonics = listOf("sub"),
modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_L))
),
IsaData(
"subi", "Subtract Immediate", altMnemonics = listOf("sub"),
modes = listOf(
@@ -471,8 +575,14 @@ object M68kIsa {
)
)
),
IsaData("subq", "Subtract Quick", modes = ADDQ_SUBQ_MODES),
IsaData("subx", "Subtract with Extend", modes = ADDX_SUBX_MODES),
IsaData("subq", "Subtract Quick", modes = ADDQ_SUBQ_MODES)
),
IsaData("subx", "Subtract with Extend", machine = ALL_MACHINES, modes = ADDX_SUBX_MODES),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"neg", "Negate", modes = listOf(
@@ -482,6 +592,7 @@ object M68kIsa {
)
)
),
IsaData(
"negx", "Negate with Extend", modes = listOf(
AllowedAdrMode(
@@ -514,10 +625,20 @@ object M68kIsa {
),
)
),
IsaData(
"cmpa", "Compare Address", altMnemonics = listOf("cmp"),
modes = listOf(AllowedAdrMode(ALL_68000_MODES, AREG_ONLY, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE or RWM_READ_OP2_L, affectedCc = cc("-****")))
modes = listOf(
AllowedAdrMode(
ALL_68000_MODES,
AREG_ONLY,
OP_SIZE_WL,
modInfo = RWM_READ_OP1_OPSIZE or RWM_READ_OP2_L,
affectedCc = cc("-****")
)
)
),
IsaData(
"cmpi", "Compare Immediate", altMnemonics = listOf("cmp"),
modes = listOf(
@@ -526,9 +647,12 @@ object M68kIsa {
affectedCc = cc("-****")
)
)
)
),
IsaData(
"cmpm", "Compare Memory to Memory", altMnemonics = listOf("cmp"),
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.ADDRESS_REGISTER_INDIRECT_POST_INC),
@@ -539,26 +663,41 @@ object M68kIsa {
)
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"muls", "Signed Multiply",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_W or RWM_MODIFY_OP2_L, affectedCc = cc("-**00")))
),
IsaData(
"mulu", "Unsigned Multiply",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_W or RWM_MODIFY_OP2_L, affectedCc = cc("-**00")))
),
IsaData(
"divs", "Signed Divide",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_L or RWM_MODIFY_OP2_L, affectedCc = cc("-***0")))
),
IsaData(
"divu", "Unsigned Divide",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_L or RWM_MODIFY_OP2_L, affectedCc = cc("-***0")))
),
),
IsaData("ext", "Sign Extend", modes = listOf(AllowedAdrMode(DREG_ONLY, null, OP_SIZE_WL, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**00")))),
IsaData(
"ext",
"Sign Extend",
machine = ALL_MACHINES,
modes = listOf(AllowedAdrMode(DREG_ONLY, null, OP_SIZE_WL, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**00")))
),
// Logical Instructions
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"and", "Logical AND",
modes = listOf(
@@ -566,6 +705,7 @@ object M68kIsa {
AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**00"))
)
),
IsaData(
"andi", "Logical AND Immediate",
altMnemonics = listOf("and"),
@@ -578,6 +718,7 @@ object M68kIsa {
)
)
),
IsaData(
"eor", "Logical Exclusive-OR",
modes = listOf(
@@ -589,6 +730,7 @@ object M68kIsa {
)
)
),
IsaData(
"eori", "Logical Exclusive-OR Immediate", altMnemonics = listOf("eor"),
modes = listOf(
@@ -600,6 +742,7 @@ object M68kIsa {
)
)
),
IsaData(
"or", "Logical Inclusive-OR",
modes = listOf(
@@ -607,6 +750,7 @@ object M68kIsa {
AllowedAdrMode(DREG_ONLY, INDIRECT_MODES, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE, affectedCc = cc("-**00"))
)
),
IsaData(
"ori", "Logical Inclusive-OR Immediate", altMnemonics = listOf("or"),
modes = listOf(
@@ -618,20 +762,23 @@ object M68kIsa {
)
)
),
IsaData(
"not", "Logical Complement",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL, null, modInfo = RWM_MODIFY_OP1_OPSIZE, affectedCc = cc("-**00")))
),
// Shift and Rotate Instructions
IsaData("asl", "Arithmetic Shift Left", modes = ASD_LSD_MODES),
IsaData("asr", "Arithmetic Shift Right", modes = ASD_LSD_MODES),
IsaData("lsl", "Logical Shift Left", modes = ASD_LSD_MODES),
IsaData("lsr", "Logical Shift Right", modes = ASD_LSD_MODES),
IsaData("asl", "Arithmetic Shift Left", modes = ASL_MODES),
IsaData("asr", "Arithmetic Shift Right", modes = ASR_LSD_MODES),
IsaData("lsl", "Logical Shift Left", modes = ASR_LSD_MODES),
IsaData("lsr", "Logical Shift Right", modes = ASR_LSD_MODES),
IsaData("rol", "Rotate Left", modes = ROD_MODES),
IsaData("ror", "Rotate Right", modes = ROD_MODES),
IsaData("roxl", "Rotate with Extend Left", modes = ROXD_MODES),
IsaData("roxr", "Rotate with Extend Right", modes = ROXD_MODES),
),
IsaData(
"swap",
"Swap Register Words",
@@ -639,14 +786,19 @@ object M68kIsa {
),
// Bit Manipulation Instructions
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData("bchg", "Test Bit and Change", modes = BCHG_BCLR_BSET_MODES),
IsaData("bclr", "Test Bit and Clear", modes = BCHG_BCLR_BSET_MODES),
IsaData("bset", "Test Bit and Set", modes = BCHG_BCLR_BSET_MODES),
IsaData("btst", "Test Bit", modes = BTST_MODES),
),
// Binary-Coded Decimal Instructions
IsaData(
"abcd", "Add Decimal with Extend",
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
DREG_ONLY, DREG_ONLY, OP_SIZE_B, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE,
@@ -663,6 +815,7 @@ object M68kIsa {
),
IsaData(
"sbcd", "Subtract Decimal with Extend",
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
DREG_ONLY, DREG_ONLY, OP_SIZE_B, modInfo = RWM_READ_OP1_OPSIZE or RWM_MODIFY_OP2_OPSIZE,
@@ -677,6 +830,9 @@ object M68kIsa {
)
)
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"nbcd", "Negate Decimal with Extend",
modes = listOf(
@@ -685,6 +841,7 @@ object M68kIsa {
affectedCc = cc("CUAU*"), testedCc = cc("?-?--")
)
)
)
),
// Program Control Instructions
@@ -713,6 +870,10 @@ object M68kIsa {
modes = listOf(AllowedAdrMode(DREG_ONLY, setOf(AddressMode.ABSOLUTE_ADDRESS), OP_SIZE_W, modInfo = RWM_MODIFY_OP1_W, testedCc = cc("-????"))),
changesControlFlow = true
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"sCC", "Set Conditionally", conditionCodes = conditionCodes,
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL, null, OP_SIZE_B, modInfo = RWM_SET_OP2_B, testedCc = cc("-????")))
@@ -749,24 +910,30 @@ object M68kIsa {
)
),
changesControlFlow = true
)
),
IsaData("nop", "No Operation", hasOps = false, modes = NO_OPS_UNSIZED),
IsaData("nop", "No Operation", machine = ALL_MACHINES, hasOps = false, modes = NO_OPS_UNSIZED),
IsaData(
"rtr",
"Return and Restore",
machine = ALL_MACHINES,
hasOps = false,
modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK, affectedCc = cc("*****"))),
changesControlFlow = true
),
IsaData(
"rts", "Return from Subroutine", hasOps = false,
machine = ALL_MACHINES,
modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK)),
changesControlFlow = true
),
IsaData(
"tst", "Test Operand", modes = listOf(
"tst", "Test Operand",
machine = MC68000_ONLY,
modes = listOf(
AllowedAdrMode(
ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL, null, modInfo = RWM_READ_OP1_OPSIZE,
affectedCc = cc("-**00")
@@ -774,9 +941,25 @@ object M68kIsa {
)
),
IsaData(
"tst", "Test Operand",
machine = MC68020_PLUS,
modes = listOf(
AllowedAdrMode(
ALL_68020_MODES.minus(AddressMode.ADDRESS_REGISTER_DIRECT), null, modInfo = RWM_READ_OP1_OPSIZE,
affectedCc = cc("-**00")
),
AllowedAdrMode(
setOf(AddressMode.ADDRESS_REGISTER_DIRECT), null, OP_SIZE_WL, modInfo = RWM_READ_OP1_OPSIZE,
affectedCc = cc("-**00")
),
)
),
// System Control Instructions
IsaData(
"andi", "AND Immediate to Status Register", id = "andi to SR", altMnemonics = listOf("and"), isPrivileged = true,
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.IMMEDIATE_DATA), setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "sr",
@@ -786,6 +969,7 @@ object M68kIsa {
),
IsaData(
"eori", "Exclusive-OR Immediate to Status Register", id = "eori to SR", altMnemonics = listOf("eor"), isPrivileged = true,
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.IMMEDIATE_DATA), setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "sr",
@@ -795,6 +979,7 @@ object M68kIsa {
),
IsaData(
"ori", "Inclusive-OR Immediate to Status Register", id = "ori to SR", altMnemonics = listOf("or"), isPrivileged = true,
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.IMMEDIATE_DATA), setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "sr",
@@ -802,8 +987,10 @@ object M68kIsa {
)
)
),
IsaData(
"move", "Move from Status Register", id = "move from SR",
machine = MC68000_ONLY,
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
@@ -815,6 +1002,25 @@ object M68kIsa {
)
)
),
IsaData(
"move", "Move from Status Register", id = "move from SR", isPrivileged = true,
machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL,
OP_SIZE_W,
"sr",
modInfo = RWM_SET_OP2_W,
testedCc = cc("?????")
)
)
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"move", "Move to Status Register", id = "move to SR", isPrivileged = true,
modes = listOf(
@@ -823,34 +1029,85 @@ object M68kIsa {
affectedCc = cc("*****")
)
)
)
),
IsaData(
"move", "Move User Stack Pointer", id = "move USP", isPrivileged = true,
machine = ALL_MACHINES,
modes = listOf(
AllowedAdrMode(setOf(AddressMode.SPECIAL_REGISTER_DIRECT), AREG_ONLY, OP_SIZE_L, "usp", modInfo = RWM_SET_OP2_L),
AllowedAdrMode(AREG_ONLY, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_L, "usp", modInfo = RWM_READ_OP1_L),
)
),
IsaData("reset", "Reset External Devices", isPrivileged = true, hasOps = false, modes = NO_OPS_UNSIZED),
IsaData(
"rte", "Return from Exception", isPrivileged = true, hasOps = false,
modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK)),
changesControlFlow = true
),
IsaData(
"stop", "Stop", isPrivileged = true,
modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED))
"movec", "Move Control Register", isPrivileged = true,
machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
modes = listOf(
AllowedAdrMode(setOf(AddressMode.SPECIAL_REGISTER_DIRECT), DREG_AREG, OP_SIZE_L, "sfc|dfc|usp|vbr", modInfo = RWM_SET_OP2_L),
AllowedAdrMode(DREG_AREG, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_L, "sfc|dfc|usp|vbr", modInfo = RWM_READ_OP1_L),
)
),
IsaData(
"moves", "Move Address Space", isPrivileged = true,
machine = EnumSet.range(Machine.MC68010, Machine.MC68060),
modes = listOf(
AllowedAdrMode(
ALL_68020_MODES_EXCEPT_IMMEDIATE_AND_PC_REL.minus(
listOf(
AddressMode.DATA_REGISTER_DIRECT,
AddressMode.ADDRESS_REGISTER_DIRECT
)
), DREG_AREG, modInfo = RWM_SET_OP2_OPSIZE
),
AllowedAdrMode(
DREG_AREG, ALL_68020_MODES_EXCEPT_IMMEDIATE_AND_PC_REL.minus(
listOf(
AddressMode.DATA_REGISTER_DIRECT,
AddressMode.ADDRESS_REGISTER_DIRECT
)
), modInfo = RWM_READ_OP1_OPSIZE
)
)
),
IsaData("reset", "Reset External Devices", machine = ALL_MACHINES, isPrivileged = true, hasOps = false, modes = NO_OPS_UNSIZED),
IsaData(
"rte", "Return from Exception",
machine = ALL_MACHINES, isPrivileged = true, hasOps = false,
modes = listOf(AllowedAdrMode(size = OP_UNSIZED, modInfo = RWM_MODIFY_STACK)),
changesControlFlow = true
),
IsaData(
"stop", "Stop",
machine = ALL_MACHINES, isPrivileged = true,
modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED))
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"chk", "Check Register Against Bound",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_AREG, DREG_ONLY, OP_SIZE_W, modInfo = RWM_READ_OP1_W or RWM_READ_OP2_W, affectedCc = cc("-*UUU")))
)
),
IsaData("illegal", "Take Illegal Instruction Trap", hasOps = false, modes = NO_OPS_UNSIZED, changesControlFlow = true),
IsaData("trap", "Trap", modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED)), changesControlFlow = true),
IsaData("illegal", "Take Illegal Instruction Trap", machine = ALL_MACHINES, hasOps = false, modes = NO_OPS_UNSIZED, changesControlFlow = true),
IsaData(
"trapv", "Trap on Overflow", hasOps = false,
"trap",
"Trap",
machine = ALL_MACHINES,
modes = listOf(AllowedAdrMode(setOf(AddressMode.IMMEDIATE_DATA), null, OP_UNSIZED)),
changesControlFlow = true
),
IsaData(
"trapv", "Trap on Overflow",
machine = ALL_MACHINES, hasOps = false,
modes = listOf(AllowedAdrMode(size = OP_UNSIZED, testedCc = cc("---?-"))),
changesControlFlow = true
),
@@ -882,19 +1139,72 @@ object M68kIsa {
)
)
),
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"move", "Move from Condition Code Register", id = "move from CCR",
machine = EnumSet.of(Machine.MC68010),
modes = listOf(
AllowedAdrMode(
setOf(AddressMode.SPECIAL_REGISTER_DIRECT),
ALL_EXCEPT_AREG_IMMEDIATE_AND_PC_REL,
OP_SIZE_W,
"ccr",
modInfo = RWM_SET_OP2_W,
testedCc = cc("?????")
)
)
),
IsaData(
"move", "Move to Condition Code Register", id = "move to CCR",
modes = listOf(
AllowedAdrMode(ALL_EXCEPT_AREG, setOf(AddressMode.SPECIAL_REGISTER_DIRECT), OP_SIZE_W, "ccr", affectedCc = cc("*****")),
)
)
),
// Multiprocessor Instructions
*autoExpandForOtherCpus(
MC68020_PLUS,
IsaData(
"tas", "Test Operand and Set",
modes = listOf(AllowedAdrMode(ALL_EXCEPT_IMMEDIATE_AND_PC_REL, null, OP_SIZE_B, modInfo = RWM_MODIFY_OP1_B, affectedCc = cc("-**00")))
)
)
)
private fun autoExpandForOtherCpus(machines: Set<Machine>, vararg isaDatas: IsaData): Array<out IsaData> {
val allIsaData = ArrayList<IsaData>()
for (isaData in isaDatas) {
val newModes = isaData.modes.map { it.copy(op1 = add68020Modes(it.op1), op2 = add68020Modes(it.op2)) }
allIsaData.add(isaData.copy(machine = machines, modes = newModes))
}
return allIsaData.toTypedArray()
}
private fun add68020Modes(oldModes: Set<AddressMode>?) = if (oldModes != null) {
val newModes = oldModes.toMutableSet()
if (oldModes.contains(AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX)) {
newModes.add(AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX)
newModes.add(AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT)
newModes.add(AddressMode.MEMORY_INDIRECT)
newModes.add(AddressMode.MEMORY_INDIRECT_POSTINDEXED)
newModes.add(AddressMode.MEMORY_INDIRECT_PREINDEXED)
}
if (oldModes.contains(AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX)) {
newModes.add(AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX)
newModes.add(AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT)
newModes.add(AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT)
newModes.add(AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED)
newModes.add(AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED)
}
newModes
} else {
null
}
private val mnemonicLookupMap = isaData.asSequence()
.flatMap {
@@ -944,5 +1254,5 @@ object M68kIsa {
private fun isAddressModeMatching(am: AllowedAdrMode, op1: AddressMode?, op2: AddressMode?, specialReg: String?) =
((((op1 == null) && (am.op1 == null)) || am.op1?.contains(op1) ?: false)
&& (((op2 == null) && (am.op2 == null)) || am.op2?.contains(op2) ?: false)
&& ((specialReg == null) || (specialReg == am.specialReg)))
&& ((specialReg == null) || (am.specialReg?.split('|')?.any { it.equals(specialReg, true) } ?: false)))
}
src/main/java/de/platon42/intellij/plugins/m68k/documentation/AbstractM68kDocumentationProvider.kt
+39
View File
@@ -0,0 +1,39 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.lang.documentation.AbstractDocumentationProvider
import com.intellij.lang.documentation.DocumentationMarkup
import com.intellij.openapi.util.text.HtmlBuilder
import com.intellij.openapi.util.text.HtmlChunk
import com.intellij.psi.PsiElement
import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
import de.platon42.intellij.plugins.m68k.psi.M68kNamedElement
import de.platon42.intellij.plugins.m68k.psi.utils.M68kPsiWalkUtil
import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
abstract class AbstractM68kDocumentationProvider : AbstractDocumentationProvider() {
fun getSettings(element: PsiElement): M68kLexerPrefs = element.project.getService(M68kProjectSettings::class.java).settings
fun getComments(element: PsiElement): HtmlChunk {
val builder = HtmlBuilder()
val comments = M68kPsiWalkUtil.collectRelatedComments(element).map { HtmlChunk.text(it.text) }
builder.appendWithSeparators(HtmlChunk.br(), comments)
return if (comments.isNotEmpty()) builder.wrapWith(HtmlChunk.span().attr("class", "grayed")) else HtmlChunk.empty()
}
fun getDefinition(element: M68kNamedElement) = getDefinition(HtmlChunk.text(element.name!!).code())
fun getDefinition(value: String) = getDefinition(HtmlChunk.text(value))
fun getDefinition(chunk: HtmlChunk) =
HtmlBuilder().append(chunk).wrapWith(DocumentationMarkup.DEFINITION_ELEMENT)
fun getContent(element: PsiElement) =
HtmlBuilder().append(HtmlChunk.text(element.text).code()).wrapWith(DocumentationMarkup.CONTENT_ELEMENT)
fun getContent(chunk: HtmlChunk) =
HtmlBuilder().append(chunk).wrapWith(DocumentationMarkup.CONTENT_ELEMENT)
fun getContent(value: String) =
HtmlBuilder().append(value).wrapWith(DocumentationMarkup.CONTENT_ELEMENT)
}
src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kInstructionDocumentationProvider.kt
+5 -4
View File
@@ -92,8 +92,8 @@ class M68kInstructionDocumentationProvider : AbstractDocumentationProvider() {
val cellsPerRow = ArrayList<HtmlChunk>(3)
cellsPerRow.add(contentBuilder.toFragment())
if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op1))
if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op2))
if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op1, allowedAdrMode.specialReg))
if (allowedAdrMode.op1 != null) cellsPerRow.add(collectAddressModes(allowedAdrMode.op2, allowedAdrMode.specialReg))
addressModeInfoRows.append(HtmlChunk.tag("tr").children(cellsPerRow.map { it.wrapWith(DocumentationMarkup.SECTION_CONTENT_CELL) }))
addressModeInfoRows.toFragment()
@@ -126,11 +126,12 @@ class M68kInstructionDocumentationProvider : AbstractDocumentationProvider() {
return defBuilder
}
private fun collectAddressModes(addressModes: Set<AddressMode>?): HtmlChunk {
private fun collectAddressModes(addressModes: Set<AddressMode>?, specialReg: String?): HtmlChunk {
if (addressModes == null) return HtmlChunk.text("")
val modes = HtmlBuilder()
addressModes.sortedBy(AddressMode::ordinal)
.forEach { modes.append(HtmlChunk.text(it.syntax).wrapWith(HtmlChunk.div())) }
.map { if (it == AddressMode.SPECIAL_REGISTER_DIRECT) specialReg!! else it.syntax }
.forEach { modes.append(HtmlChunk.text(it).wrapWith(HtmlChunk.div())) }
return modes.toFragment()
}
src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kLabelDefinitionDocumentationProvider.kt
+34
View File
@@ -0,0 +1,34 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.openapi.util.text.HtmlBuilder
import com.intellij.psi.PsiElement
import com.intellij.psi.util.PsiTreeUtil
import de.platon42.intellij.plugins.m68k.psi.M68kGlobalLabel
import de.platon42.intellij.plugins.m68k.psi.M68kLocalLabel
import de.platon42.intellij.plugins.m68k.psi.M68kNamedElement
import de.platon42.intellij.plugins.m68k.psi.M68kStatement
class M68kLabelDefinitionDocumentationProvider : AbstractM68kDocumentationProvider() {
override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
return generateDoc(element, originalElement)
}
override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
return if (element is M68kGlobalLabel || element is M68kLocalLabel) {
// TODO find out how we can generate inner links for more symbol references inside the expression (DocumentationManagerUtil)
val statement = element.parent as M68kStatement
var preprocessorDirective = statement.preprocessorDirective
if ((preprocessorDirective == null) && (statement.asmInstruction == null) && (statement.macroCall == null)) {
val nextLineStatement = PsiTreeUtil.skipWhitespacesAndCommentsForward(PsiTreeUtil.skipWhitespacesAndCommentsForward(statement))
as? M68kStatement
preprocessorDirective = nextLineStatement?.preprocessorDirective
}
val builder = HtmlBuilder()
builder.append(getComments(statement))
builder.append(getDefinition(element as M68kNamedElement))
if (preprocessorDirective != null) builder.append(getContent(preprocessorDirective))
builder.toString()
} else null
}
}
src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kMacroDefinitionDocumentationProvider.kt
+42
View File
@@ -0,0 +1,42 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.openapi.util.text.HtmlBuilder
import com.intellij.openapi.util.text.HtmlChunk
import com.intellij.psi.PsiElement
import com.intellij.psi.util.PsiTreeUtil
import de.platon42.intellij.plugins.m68k.psi.M68kMacroCall
import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
import de.platon42.intellij.plugins.m68k.psi.utils.M68kMacroExpansionUtil
class M68kMacroDefinitionDocumentationProvider : AbstractM68kDocumentationProvider() {
override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
return generateDoc(element, originalElement)
}
override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
return if (element is M68kMacroDefinition) createDoc(element, originalElement, getSettings(element).maxLongDocumentationLines) else null
}
override fun generateHoverDoc(element: PsiElement, originalElement: PsiElement?): String? {
return if (element is M68kMacroDefinition) createDoc(element, originalElement, getSettings(element).maxShortDocumentationLines) else null
}
private fun createDoc(macrodef: M68kMacroDefinition, originalElement: PsiElement?, linesLimit: Int): String {
val macroCall = PsiTreeUtil.getParentOfType(originalElement, M68kMacroCall::class.java)
val expandedMacro = M68kMacroExpansionUtil.expandMacro(macrodef, macroCall)
val builder = HtmlBuilder()
return builder
.append(getComments(macrodef))
.append(getDefinition(HtmlChunk.text(macrodef.name!!).code()))
.append(
getContent(
HtmlBuilder().appendWithSeparators(
HtmlChunk.br(),
expandedMacro.take(linesLimit).map { HtmlChunk.text(it).code() }.toList()
).toFragment()
)
)
.toString()
}
}
src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kRegisterFlowDocumentationProvider.kt
+6 -6
View File
@@ -1,6 +1,5 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.lang.documentation.AbstractDocumentationProvider
import com.intellij.lang.documentation.DocumentationMarkup
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.util.text.HtmlBuilder
@@ -19,18 +18,18 @@ import de.platon42.intellij.plugins.m68k.utils.M68kIsaUtil.findExactIsaDataAndAl
import de.platon42.intellij.plugins.m68k.utils.M68kIsaUtil.getOpSizeOrDefault
import de.platon42.intellij.plugins.m68k.utils.M68kIsaUtil.modifyRwmWithOpsize
class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
class M68kRegisterFlowDocumentationProvider : AbstractM68kDocumentationProvider() {
override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
if (element is M68kDataRegister || element is M68kAddressRegister) {
return createDoc(element as M68kRegister, 100) // TODO make this configurable
return createDoc(element as M68kRegister, getSettings(element).maxLongDocumentationLines)
}
return null
}
override fun generateHoverDoc(element: PsiElement, originalElement: PsiElement?): String? {
if (element is M68kDataRegister || element is M68kAddressRegister) {
return createDoc(element as M68kRegister, 4) // TODO make this configurable
return createDoc(element as M68kRegister, getSettings(element).maxShortDocumentationLines)
}
return null
}
@@ -82,15 +81,16 @@ class M68kRegisterFlowDocumentationProvider : AbstractDocumentationProvider() {
PsiTreeUtil.getPrevSiblingOfType(it, M68kStatement::class.java)
})
backtrace.reverse()
val remLines = linesLimit - backtrace.size.coerceAtLeast(1)
val traceBits = (cursorRwm or (cursorRwm ushr RWM_MODIFY_SHIFT) or (cursorRwm ushr RWM_READ_SHIFT)) and RWM_SIZE_MASK
backtrace.addAll(analyseFlow(register, traceBits, false, initialStatement, linesLimit) {
backtrace.addAll(analyseFlow(register, traceBits, false, initialStatement, remLines) {
PsiTreeUtil.getNextSiblingOfType(it, M68kStatement::class.java)
})
val statementRows = HtmlBuilder()
backtrace.forEach(statementRows::append)
val builder = HtmlBuilder()
builder.append(HtmlChunk.text(thisInfo).wrapWith(DocumentationMarkup.DEFINITION_ELEMENT))
builder.append(getDefinition(thisInfo))
builder.append(statementRows.wrapWith(DocumentationMarkup.SECTIONS_TABLE.style("padding-left: 8pt; padding-right: 8pt")))
return builder.toString()
}
src/main/java/de/platon42/intellij/plugins/m68k/documentation/M68kSymbolDefinitionDocumentationProvider.kt
+8 -7
View File
@@ -1,13 +1,11 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.lang.documentation.AbstractDocumentationProvider
import com.intellij.lang.documentation.DocumentationMarkup
import com.intellij.openapi.util.text.StringUtil
import com.intellij.openapi.util.text.HtmlBuilder
import com.intellij.psi.PsiElement
import de.platon42.intellij.plugins.m68k.psi.M68kAssignment
import de.platon42.intellij.plugins.m68k.psi.M68kSymbolDefinition
class M68kSymbolDefinitionDocumentationProvider : AbstractDocumentationProvider() {
class M68kSymbolDefinitionDocumentationProvider : AbstractM68kDocumentationProvider() {
override fun getQuickNavigateInfo(element: PsiElement, originalElement: PsiElement?): String? {
return generateDoc(element, originalElement)
@@ -16,9 +14,12 @@ class M68kSymbolDefinitionDocumentationProvider : AbstractDocumentationProvider(
override fun generateDoc(element: PsiElement, originalElement: PsiElement?): String? {
return if (element is M68kSymbolDefinition) {
// TODO find out how we can generate inner links for more symbol references inside the expression (DocumentationManagerUtil)
val value = (element.getParent() as M68kAssignment).expr.text
DocumentationMarkup.DEFINITION_START + StringUtil.escapeXmlEntities(element.name!!) + DocumentationMarkup.DEFINITION_END +
DocumentationMarkup.CONTENT_START + StringUtil.escapeXmlEntities(value) + DocumentationMarkup.CONTENT_END
val assignment = element.parent as M68kAssignment
HtmlBuilder()
.append(getComments(assignment.parent))
.append(getDefinition(element))
.append(getContent(assignment.expr))
.toString()
} else null
}
}
src/main/java/de/platon42/intellij/plugins/m68k/inspections/M68kUnresolvedReferenceInspection.kt
+1 -1
View File
@@ -29,7 +29,7 @@ class M68kUnresolvedReferenceInspection : AbstractBaseM68kLocalInspectionTool()
}
override fun visitSymbolReference(symbolReference: M68kSymbolReference) {
val references = symbolReference.references ?: return
val references = symbolReference.references
if (references.isEmpty()) return
val resolve = references.mapNotNull { it as? PsiPolyVariantReference }
.firstNotNullOfOrNull { it.multiResolve(false).ifEmpty { null } }
src/main/java/de/platon42/intellij/plugins/m68k/lexer/M68kLexerPrefs.kt
+4 -1
View File
@@ -4,5 +4,8 @@ data class M68kLexerPrefs(
var spaceIntroducesComment: Boolean = false,
var maxLinesPerMacro: Int = 250,
var macroSectionUnparsed: Boolean = false,
var macroParametersUnparsed: Boolean = true
var macroParametersUnparsed: Boolean = true,
var maxShortDocumentationLines: Int = 5,
var maxLongDocumentationLines: Int = 100,
)
src/main/java/de/platon42/intellij/plugins/m68k/lexer/_M68kLexer.flex
+10 -5
View File
@@ -117,10 +117,10 @@ PLAIN_MACRO_LINE=[^;\r\n]+
{DIRECTIVE_KEYWORD} {
if(isAsmMnemonicWithSize(yytext())) { yybegin(ASMINSTR); yypushback(2); return MNEMONIC; }
if(isAsmMnemonic(yytext())) { yybegin(ASMINSTR); return MNEMONIC; }
if(isEndDirective(yytext())) { yybegin(YYINITIAL); zzAtEOF = true; return null; }
if(isDataDirective(yytext())) { startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
if(isPlainDirective(yytext())) { yybegin(PLAINPARAMS); return OTHER_DIRECTIVE; }
if(isOtherDirective(yytext())) { startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
//if(isEndDirective(yytext())) { yybegin(YYINITIAL); zzAtEOF = true; return null; }
if(isDataDirective(yytext())) { eatOneWhitespace = true; startExpr(EXPR, EXPR_OP); return DATA_DIRECTIVE; }
if(isPlainDirective(yytext())) { eatOneWhitespace = true; yybegin(PLAINPARAMS); return OTHER_DIRECTIVE; }
if(isOtherDirective(yytext())) { eatOneWhitespace = true; startExpr(EXPR, EXPR_OP); return OTHER_DIRECTIVE; }
return handleMacroMode(this);
}
{MACRONAME} { return handleMacroMode(this); }
@@ -168,7 +168,6 @@ PLAIN_MACRO_LINE=[^;\r\n]+
"+" { return OP_PLUS; }
"-" { return OP_MINUS; }
"*" { yybegin(exprOpState); return CURRENT_PC_SYMBOL; }
}
<EXPR> {
@@ -216,8 +215,12 @@ PLAIN_MACRO_LINE=[^;\r\n]+
"sr" { yybegin(exprOpState); return REG_SR; }
"usp" { yybegin(exprOpState); return REG_USP; }
"vbr" { yybegin(exprOpState); return REG_VBR; }
"dfc" { yybegin(exprOpState); return REG_DFC; }
"sfc" { yybegin(exprOpState); return REG_SFC; }
"#" { return HASH; }
"\[" { return SQUARE_L; }
// "\]" { return SQUARE_R; }
{SYMBOL} { yybegin(exprOpState); return SYMBOL; }
}
@@ -226,6 +229,8 @@ PLAIN_MACRO_LINE=[^;\r\n]+
{OPSIZE_BS} { return OPSIZE_BS; }
{OPSIZE_W} { return OPSIZE_W; }
{OPSIZE_L} { return OPSIZE_L; }
"\[" { return SQUARE_L; }
"\]" { return SQUARE_R; }
}
<WAITEOL>
src/main/java/de/platon42/intellij/plugins/m68k/m68k.bnf
+137 -6
View File
@@ -121,7 +121,6 @@ M68kFile ::= line*
private line ::= !<<eof>> (MacroDefinition | statement) (<<eof>>|EOL)
statement ::= (Assignment
| PreprocessorDirective
| LabelInsts)
{pin = 1 recoverWhile = statement_recover}
@@ -140,8 +139,8 @@ Assignment ::= SymbolDefinition COLON? (OP_ASSIGN|EQU) expr
private LabelInsts ::= LabelWithInstruction | LabelOnly | InstructionOnly
private LabelOnly ::= Label
private LabelWithInstruction ::= Label Instruction
private InstructionOnly ::= Instruction
private LabelWithInstruction ::= Label (Instruction|PreprocessorDirective)
private InstructionOnly ::= (Instruction|PreprocessorDirective)
LocalLabel ::= LOCAL_LABEL_DEF COLON? {
name = "local label"
@@ -165,6 +164,7 @@ OperandSize ::= (OPSIZE_BS|OPSIZE_W|OPSIZE_L) {
name = ".s|.b|.w|.l"
methods = [getSize]
}
AddressSize ::= (OPSIZE_W|OPSIZE_L) { name = ".w|.l" }
DataWidth ::= (OPSIZE_W|OPSIZE_L) { name = ".w|.l" }
@@ -175,7 +175,7 @@ AsmOp ::= MNEMONIC OperandSize? {
PreprocessorKeyword ::= (DATA_DIRECTIVE | OTHER_DIRECTIVE)
PreprocessorDirective ::= Label? PreprocessorKeyword PreprocessorOperands? {
PreprocessorDirective ::= PreprocessorKeyword PreprocessorOperands? {
mixin = "de.platon42.intellij.plugins.m68k.psi.M68kPreprocessorDirectiveMixin"
}
@@ -228,7 +228,7 @@ AddressRegister ::= AREG | REG_SP {
extends = Register
}
SpecialRegister ::= REG_CCR | REG_SR | REG_USP | REG_VBR {
SpecialRegister ::= REG_CCR | REG_SR | REG_USP | REG_VBR | REG_SFC | REG_DFC {
name = "special register"
extends = Register
}
@@ -237,14 +237,26 @@ Register ::= DataRegister | AddressRegister | SpecialRegister
private DataOrAddressRegister ::= DataRegister | AddressRegister { name = "data or address register"}
IndexRegister ::= DataOrAddressRegister DataWidth?
BaseDisplacement ::= expr DataWidth?
OuterDisplacement ::= expr DataWidth?
IndexRegister ::= DataOrAddressRegister DataWidth? (OP_AR_MUL IndexScale)?
{
name = "index register"
methods = [
indexRegister = "DataOrAddressRegister"
isLongWidth
]
}
IndexScale ::= expr
{
name = "scale value"
methods = [
indexScale = "expr"
]
}
AddressingMode ::= ImmediateData
| AddressRegisterIndirectPreDecAddressingMode
| AddressRegisterIndirectPostIncAddressingMode
@@ -257,6 +269,14 @@ AddressingMode ::= ImmediateData
| ProgramCounterIndirectWithDisplacementOldAddressingMode
| AddressRegisterIndirectWithIndexOldAddressingMode
| ProgramCounterIndirectWithIndexOldAddressingMode
| AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode
| ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode
| MemoryIndirectAddressingMode
| ProgramCounterMemoryIndirectAddressingMode
| MemoryIndirectPostIndexedAddressingMode
| ProgramCounterMemoryIndirectPostIndexedAddressingMode
| MemoryIndirectPreIndexedAddressingMode
| ProgramCounterMemoryIndirectPreIndexedAddressingMode
| SpecialRegisterDirectAddressingMode
| DataRegisterDirectAddressingMode
| AddressRegisterDirectAddressingMode
@@ -269,6 +289,7 @@ AddressRegisterDirectAddressingMode ::= AddressRegister !(OP_MINUS|OP_AR_DIV)
AddressRegisterIndirectAddressingMode ::= ROUND_L AddressRegister ROUND_R !OP_PLUS { implements = "de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect" }
AddressRegisterIndirectPostIncAddressingMode ::= ROUND_L AddressRegister ROUND_R OP_PLUS { implements = "de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect" }
AddressRegisterIndirectPreDecAddressingMode ::= OP_MINUS ROUND_L AddressRegister ROUND_R { implements = "de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect" }
AddressRegisterIndirectWithDisplacementOldAddressingMode ::= expr ROUND_L AddressRegister ROUND_R
{
implements = [
@@ -279,6 +300,7 @@ AddressRegisterIndirectWithDisplacementOldAddressingMode ::= expr ROUND_L Addres
displacement = "expr"
]
}
AddressRegisterIndirectWithDisplacementNewAddressingMode ::= ROUND_L expr SEPARATOR AddressRegister ROUND_R
{
implements = [
@@ -314,6 +336,77 @@ AddressRegisterIndirectWithIndexNewAddressingMode ::= ROUND_L (expr SEPARATOR)?
]
}
private internalBaseDisplacementOption1 ::= (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister
private internalBaseDisplacementOption2 ::= (BaseDisplacement SEPARATOR)? AddressRegister (SEPARATOR IndexRegister)?
private internalBaseDisplacementOption3 ::= BaseDisplacement (SEPARATOR AddressRegister)? (SEPARATOR IndexRegister)?
AddressRegisterIndirectWithIndexBaseDisplacementAddressingMode ::= ROUND_L (internalBaseDisplacementOption1|internalBaseDisplacementOption2|internalBaseDisplacementOption3)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalIndexRegister"
]
methods = [
baseDisplacement = "BaseDisplacement"
]
}
ProgramCounterIndirectWithIndexBaseDisplacementAddressingMode ::= ROUND_L (BaseDisplacement SEPARATOR)? PC (SEPARATOR IndexRegister)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalIndexRegister"
]
methods = [
baseDisplacement = "BaseDisplacement"
]
}
MemoryIndirectAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? AddressRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "BaseDisplacement"
outerDisplacement = "OuterDisplacement"
]
}
private internalMemoryIndirectPostIndexedOption1 ::= (BaseDisplacement SEPARATOR)? AddressRegister
private internalMemoryIndirectPostIndexedOption2 ::= BaseDisplacement (SEPARATOR AddressRegister)?
MemoryIndirectPostIndexedAddressingMode ::= ROUND_L (SQUARE_L (internalMemoryIndirectPostIndexedOption1|internalMemoryIndirectPostIndexedOption2) SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "BaseDisplacement"
outerDisplacement = "OuterDisplacement"
]
}
MemoryIndirectPreIndexedAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? (AddressRegister SEPARATOR)? IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithOptionalAddressRegisterIndirect"
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "BaseDisplacement"
outerDisplacement = "OuterDisplacement"
]
}
ProgramCounterIndirectWithDisplacementOldAddressingMode ::= (ROUND_L PC ROUND_R) | (expr ROUND_L PC ROUND_R)
{
implements = ["de.platon42.intellij.plugins.m68k.psi.M68kWithDisplacement"]
@@ -352,6 +445,44 @@ ProgramCounterIndirectWithIndexNewAddressingMode ::= ROUND_L (expr SEPARATOR)? P
]
}
ProgramCounterMemoryIndirectAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "BaseDisplacement"
outerDisplacement = "OuterDisplacement"
]
}
ProgramCounterMemoryIndirectPostIndexedAddressingMode ::= ROUND_L (SQUARE_L (BaseDisplacement SEPARATOR)? PC SQUARE_R SEPARATOR)? IndexRegister (SEPARATOR OuterDisplacement)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "BaseDisplacement"
outerDisplacement = "OuterDisplacement"
]
}
ProgramCounterMemoryIndirectPreIndexedAddressingMode ::= ROUND_L SQUARE_L (BaseDisplacement SEPARATOR)? PC SEPARATOR IndexRegister SQUARE_R (SEPARATOR OuterDisplacement)? ROUND_R
{
implements = [
"de.platon42.intellij.plugins.m68k.psi.M68kWithBaseDisplacement"
"de.platon42.intellij.plugins.m68k.psi.M68kWithIndexRegister"
"de.platon42.intellij.plugins.m68k.psi.M68kWithOuterDisplacement"
]
methods = [
baseDisplacement = "BaseDisplacement"
outerDisplacement = "OuterDisplacement"
]
}
AbsoluteAddressAddressingMode ::= expr AddressSize? !ROUND_L
RegisterRange ::= (DataRegister OP_MINUS DataRegister) | (AddressRegister OP_MINUS AddressRegister) | (DataRegister OP_MINUS AddressRegister) {
src/main/java/de/platon42/intellij/plugins/m68k/parser/M68kParserDefinition.kt
+3 -4
View File
@@ -10,15 +10,14 @@ import de.platon42.intellij.plugins.m68k.lexer.M68kLexer
import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
import de.platon42.intellij.plugins.m68k.psi.M68kFile
import de.platon42.intellij.plugins.m68k.psi.M68kTypes
import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
import de.platon42.intellij.plugins.m68k.stubs.M68kElementTypes
class M68kParserDefinition : ParserDefinition {
val lexerPrefs = M68kLexerPrefs() // TODO make this configurable
override fun createLexer(project: Project): Lexer {
// TODO take prefs from project somehow
return M68kLexer(lexerPrefs)
val settings = project.getService(M68kProjectSettings::class.java)
return M68kLexer(settings?.settings ?: M68kLexerPrefs())
}
override fun createParser(project: Project) = M68kParser()
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kAddressModeUtil.kt
+24 -22
View File
@@ -12,12 +12,20 @@ object M68kAddressModeUtil {
is M68kAddressRegisterIndirectPreDecAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_PRE_DEC
is M68kAddressRegisterIndirectWithDisplacementNewAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT
is M68kAddressRegisterIndirectWithDisplacementOldAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_DISPLACEMENT
is M68kAddressRegisterIndirectWithIndexNewAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
is M68kAddressRegisterIndirectWithIndexOldAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
is M68kAddressRegisterIndirectWithIndexNewAddressingMode -> if (hasScale(addressingMode)) AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
is M68kAddressRegisterIndirectWithIndexOldAddressingMode -> if (hasScale(addressingMode)) AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_INDEX
is M68kAddressRegisterIndirectWithIndexBaseDisplacementAddressingMode -> AddressMode.ADDRESS_REGISTER_INDIRECT_WITH_BASE_DISPLACEMENT
is M68kProgramCounterIndirectWithDisplacementNewAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT
is M68kProgramCounterIndirectWithDisplacementOldAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_DISPLACEMENT
is M68kProgramCounterIndirectWithIndexNewAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
is M68kProgramCounterIndirectWithIndexOldAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
is M68kProgramCounterIndirectWithIndexNewAddressingMode -> if (hasScale(addressingMode)) AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
is M68kProgramCounterIndirectWithIndexOldAddressingMode -> if (hasScale(addressingMode)) AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_SCALED_INDEX else AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_INDEX
is M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingMode -> AddressMode.PROGRAM_COUNTER_INDIRECT_WITH_BASE_DISPLACEMENT
is M68kMemoryIndirectAddressingMode -> AddressMode.MEMORY_INDIRECT
is M68kMemoryIndirectPreIndexedAddressingMode -> AddressMode.MEMORY_INDIRECT_PREINDEXED
is M68kMemoryIndirectPostIndexedAddressingMode -> AddressMode.MEMORY_INDIRECT_POSTINDEXED
is M68kProgramCounterMemoryIndirectAddressingMode -> AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT
is M68kProgramCounterMemoryIndirectPreIndexedAddressingMode -> AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_PREINDEXED
is M68kProgramCounterMemoryIndirectPostIndexedAddressingMode -> AddressMode.PROGRAM_COUNTER_MEMORY_INDIRECT_POSTINDEXED
is M68kSpecialRegisterDirectAddressingMode -> AddressMode.SPECIAL_REGISTER_DIRECT
is M68kDataRegisterDirectAddressingMode -> AddressMode.DATA_REGISTER_DIRECT
is M68kAddressRegisterDirectAddressingMode -> AddressMode.ADDRESS_REGISTER_DIRECT
@@ -27,6 +35,9 @@ object M68kAddressModeUtil {
}
}
// TODO add evaluation of constant expressions and allow scale == 1 as false
private fun hasScale(addressingMode: M68kWithIndexRegister) = addressingMode.indexRegister.indexScale != null
fun getOtherReadWriteModifyRegisters(rwm: Int): List<Pair<Register, Int>> {
if (rwm and RWM_MODIFY_STACK > 0) {
return listOf(Register.A7 to RWM_MODIFY_L)
@@ -37,29 +48,20 @@ object M68kAddressModeUtil {
fun getReadWriteModifyRegisters(addressingMode: M68kAddressingMode?, rwm: Int): List<Pair<Register, Int>> {
if (addressingMode == null) return emptyList()
return when (addressingMode) {
is M68kImmediateData,
is M68kSpecialRegisterDirectAddressingMode,
is M68kProgramCounterIndirectWithDisplacementNewAddressingMode,
is M68kProgramCounterIndirectWithDisplacementOldAddressingMode,
is M68kAbsoluteAddressAddressingMode -> emptyList()
is M68kAddressRegisterIndirectPostIncAddressingMode -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to (RWM_READ_L or RWM_MODIFY_L))
is M68kAddressRegisterIndirectPreDecAddressingMode -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to (RWM_READ_L or RWM_MODIFY_L))
is M68kWithAddressRegisterIndirect -> {
if (addressingMode is M68kWithIndexRegister) {
listOf(
Register.getRegFromName(addressingMode.addressRegister.text) to RWM_READ_L,
Register.getRegFromName(addressingMode.indexRegister.register.text) to if (addressingMode.indexRegister.isLongWidth) RWM_READ_L else RWM_READ_W
)
} else {
listOf(Register.getRegFromName(addressingMode.addressRegister.text) to RWM_READ_L)
}
}
is M68kWithIndexRegister -> listOf(Register.getRegFromName(addressingMode.indexRegister.register.text) to if (addressingMode.indexRegister.isLongWidth) RWM_READ_L else RWM_READ_W)
is M68kWithAddressRegisterIndirect -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to RWM_READ_L)
is M68kWithOptionalAddressRegisterIndirect -> if (addressingMode.addressRegister != null) listOf(Register.getRegFromName(addressingMode.addressRegister!!.text) to RWM_READ_L) else emptyList()
is M68kDataRegisterDirectAddressingMode -> listOf(Register.getRegFromName(addressingMode.dataRegister.text) to rwm)
is M68kAddressRegisterDirectAddressingMode -> listOf(Register.getRegFromName(addressingMode.addressRegister.text) to rwm)
is M68kRegisterListAddressingMode -> addressingMode.registers.map { it to rwm }
else -> throw IllegalArgumentException("Unknown addressing mode $addressingMode")
else -> emptyList()
}.plus(
when (addressingMode) {
is M68kWithIndexRegister -> listOf(Register.getRegFromName(addressingMode.indexRegister.register.text) to if (addressingMode.indexRegister.isLongWidth) RWM_READ_L else RWM_READ_W)
is M68kWithOptionalIndexRegister -> if (addressingMode.indexRegister != null) listOf(Register.getRegFromName(addressingMode.indexRegister!!.register.text) to if (addressingMode.indexRegister!!.isLongWidth) RWM_READ_L else RWM_READ_W) else emptyList()
else -> emptyList()
}
)
}
}
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kPsiImplUtil.kt
+2 -2
View File
@@ -29,7 +29,7 @@ object M68kPsiImplUtil {
// Local Label
@JvmStatic
fun getName(element: M68kLocalLabel): String = element.firstChild?.text ?: ""
fun getName(element: M68kLocalLabel): String? = element.firstChild?.text
@JvmStatic
fun setName(element: M68kLocalLabel, name: String): PsiElement {
@@ -105,7 +105,7 @@ object M68kPsiImplUtil {
// OperandSize
@JvmStatic
fun getSize(element: M68kOperandSize): Int =
when (element.text) {
when (element.text?.lowercase()) {
null -> OP_UNSIZED
".w" -> OP_SIZE_W
".l" -> OP_SIZE_L
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithBaseDisplacement.kt
+6
View File
@@ -0,0 +1,6 @@
package de.platon42.intellij.plugins.m68k.psi
interface M68kWithBaseDisplacement : M68kAddressingMode {
val baseDisplacement: M68kBaseDisplacement?
}
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOptionalAddressRegisterIndirect.kt
+6
View File
@@ -0,0 +1,6 @@
package de.platon42.intellij.plugins.m68k.psi
interface M68kWithOptionalAddressRegisterIndirect : M68kAddressingMode {
val addressRegister: M68kAddressRegister?
}
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOptionalIndexRegister.kt
+6
View File
@@ -0,0 +1,6 @@
package de.platon42.intellij.plugins.m68k.psi
interface M68kWithOptionalIndexRegister : M68kAddressingMode {
val indexRegister: M68kIndexRegister?
}
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kWithOuterDisplacement.kt
+6
View File
@@ -0,0 +1,6 @@
package de.platon42.intellij.plugins.m68k.psi
interface M68kWithOuterDisplacement : M68kAddressingMode {
val outerDisplacement: M68kOuterDisplacement?
}
src/main/java/de/platon42/intellij/plugins/m68k/psi/M68kLookupUtil.kt → src/main/java/de/platon42/intellij/plugins/m68k/psi/utils/M68kLookupUtil.kt
+2 -1
View File
@@ -1,9 +1,10 @@
package de.platon42.intellij.plugins.m68k.psi
package de.platon42.intellij.plugins.m68k.psi.utils
import com.intellij.openapi.project.Project
import com.intellij.psi.search.GlobalSearchScope
import com.intellij.psi.stubs.StubIndex
import com.intellij.psi.util.PsiTreeUtil
import de.platon42.intellij.plugins.m68k.psi.*
import de.platon42.intellij.plugins.m68k.stubs.M68kGlobalLabelStubIndex
import de.platon42.intellij.plugins.m68k.stubs.M68kMacroDefinitionStubIndex
import de.platon42.intellij.plugins.m68k.stubs.M68kSymbolDefinitionStubIndex
src/main/java/de/platon42/intellij/plugins/m68k/psi/utils/M68kMacroExpansionUtil.kt
+25
View File
@@ -0,0 +1,25 @@
package de.platon42.intellij.plugins.m68k.psi.utils
import de.platon42.intellij.plugins.m68k.psi.M68kMacroCall
import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
object M68kMacroExpansionUtil {
fun expandMacro(macroDefinition: M68kMacroDefinition, macroCall: M68kMacroCall?): List<String> {
val params = macroCall?.exprList?.map { it.text }?.toTypedArray() ?: emptyArray()
if (params.isEmpty()) return macroDefinition.macroPlainLineList.map { it.text }
val originalContent = macroDefinition.macroPlainLineList.joinToString("\n", transform = { it.text })
var modifiedContent = originalContent
for (param in params.withIndex()) {
val paramRef = when (param.index) {
in 0..8 -> "\\" + (param.index + 1)
in 9..34 -> "\\" + ('a' + (param.index - 9))
else -> "seriously?"
}
modifiedContent = modifiedContent.replace(paramRef, param.value)
}
return modifiedContent.split("\n")
}
}
src/main/java/de/platon42/intellij/plugins/m68k/psi/utils/M68kPsiWalkUtil.kt
+31
View File
@@ -0,0 +1,31 @@
package de.platon42.intellij.plugins.m68k.psi.utils
import com.intellij.psi.PsiComment
import com.intellij.psi.PsiElement
import com.intellij.psi.util.PsiTreeUtil
import com.intellij.util.SmartList
import com.intellij.util.containers.addIfNotNull
import de.platon42.intellij.plugins.m68k.psi.M68kMacroDefinition
object M68kPsiWalkUtil {
fun collectRelatedComments(element: PsiElement): List<PsiComment> {
val comments = SmartList<PsiComment>()
val eolComment = if (element is M68kMacroDefinition) {
// macro definition needs special handling of EOL comments
PsiTreeUtil.findChildOfType(element, PsiComment::class.java)
} else {
PsiTreeUtil.skipWhitespacesForward(element) as? PsiComment
}
comments.addIfNotNull(eolComment)
var prevToken: PsiElement? = element
do {
prevToken = PsiTreeUtil.skipWhitespacesBackward(prevToken)
if (prevToken !is PsiComment) break
comments.add(prevToken)
} while (true)
return comments.reversed()
}
}
src/main/java/de/platon42/intellij/plugins/m68k/refs/M68kGlobalLabelSymbolCompletionContributor.kt
+1 -1
View File
@@ -6,8 +6,8 @@ import com.intellij.codeInsight.lookup.LookupElementBuilder
import com.intellij.patterns.PlatformPatterns
import com.intellij.util.ProcessingContext
import de.platon42.intellij.plugins.m68k.M68kIcons
import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil
import de.platon42.intellij.plugins.m68k.psi.M68kTypes
import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil
class M68kGlobalLabelSymbolCompletionContributor : CompletionContributor() {
src/main/java/de/platon42/intellij/plugins/m68k/refs/M68kMacroCallCompletionContributor.kt
+1 -1
View File
@@ -4,8 +4,8 @@ import com.intellij.codeInsight.completion.*
import com.intellij.codeInsight.lookup.LookupElementBuilder
import com.intellij.patterns.PlatformPatterns
import com.intellij.util.ProcessingContext
import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil
import de.platon42.intellij.plugins.m68k.psi.M68kTypes
import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil
class M68kMacroCallCompletionContributor : CompletionContributor() {
src/main/java/de/platon42/intellij/plugins/m68k/settings/M68kProjectSettings.kt
+19
View File
@@ -0,0 +1,19 @@
package de.platon42.intellij.plugins.m68k.settings
import com.intellij.openapi.components.PersistentStateComponent
import com.intellij.openapi.components.State
import com.intellij.openapi.components.Storage
import com.intellij.openapi.components.StoragePathMacros
import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
@State(name = "M68k.Settings", storages = [Storage(StoragePathMacros.WORKSPACE_FILE)])
class M68kProjectSettings : PersistentStateComponent<M68kLexerPrefs> {
var settings: M68kLexerPrefs = M68kLexerPrefs()
override fun getState() = settings
override fun loadState(state: M68kLexerPrefs) {
settings = state
}
}
src/main/java/de/platon42/intellij/plugins/m68k/settings/M68kProjectSettingsConfigurable.kt
+91
View File
@@ -0,0 +1,91 @@
package de.platon42.intellij.plugins.m68k.settings
import com.intellij.openapi.options.Configurable
import com.intellij.openapi.options.ConfigurationException
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.NlsContexts.ConfigurableName
import com.intellij.ui.components.JBCheckBox
import com.intellij.uiDesigner.core.Spacer
import com.intellij.util.ui.FormBuilder
import com.intellij.util.ui.UIUtil
import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
import java.text.NumberFormat
import java.text.ParseException
import javax.swing.JComponent
import javax.swing.JFormattedTextField
import javax.swing.JLabel
import javax.swing.text.DefaultFormatterFactory
import javax.swing.text.NumberFormatter
class M68kProjectSettingsConfigurable(project: Project?) : Configurable {
private val settings = project?.getService(M68kProjectSettings::class.java)
private val spacesOptionField = JBCheckBox("Space introduces comment (-spaces)", settings?.settings?.spaceIntroducesComment ?: false)
private val maxLinesPerMacroField = createNumberField(settings?.settings?.maxLinesPerMacro)
private val maxShortDocumentationLinesField = createNumberField(settings?.settings?.maxShortDocumentationLines)
private val maxLongDocumentationLinesField = createNumberField(settings?.settings?.maxLongDocumentationLines)
override fun getDisplayName(): @ConfigurableName String = "M68k"
override fun createComponent(): JComponent? {
return FormBuilder.createFormBuilder()
.setAlignLabelOnRight(false)
.setHorizontalGap(UIUtil.DEFAULT_HGAP)
.setVerticalGap(UIUtil.DEFAULT_VGAP)
.addComponent(spacesOptionField)
.addLabeledComponent(JLabel("Maximum lines parsed inside macro"), maxLinesPerMacroField)
.addSeparator()
.addLabeledComponent(JLabel("Lines of code in hovered documentation"), maxShortDocumentationLinesField)
.addLabeledComponent(JLabel("Lines of code in full documentation"), maxLongDocumentationLinesField)
.addComponentFillVertically(Spacer(), 0)
.panel
}
private fun createNumberField(value: Any?): JFormattedTextField {
val valueField = JFormattedTextField()
valueField.columns = 4
val formatter = NumberFormat.getIntegerInstance()
formatter.isParseIntegerOnly = true
valueField.formatterFactory = DefaultFormatterFactory(NumberFormatter(formatter))
valueField.value = value
return valueField
}
override fun isModified(): Boolean {
val prefs = settings?.settings ?: return false
return prefs.spaceIntroducesComment != spacesOptionField.isSelected
|| fieldDiffers(maxLinesPerMacroField, prefs.maxLinesPerMacro)
|| fieldDiffers(maxShortDocumentationLinesField, prefs.maxShortDocumentationLines)
|| fieldDiffers(maxLongDocumentationLinesField, prefs.maxLongDocumentationLines)
}
@Throws(ConfigurationException::class)
override fun apply() {
val prefs = settings?.settings ?: return
prefs.spaceIntroducesComment = spacesOptionField.isSelected
getFieldValue(maxLinesPerMacroField).let { if (it != null) prefs.maxLinesPerMacro = it }
getFieldValue(maxShortDocumentationLinesField).let { if (it != null) prefs.maxShortDocumentationLines = it }
getFieldValue(maxLongDocumentationLinesField).let { if (it != null) prefs.maxLongDocumentationLines = it }
}
private fun fieldDiffers(field: JFormattedTextField, value: Int?): Boolean {
val fieldValue = getFieldValue(field)
return (fieldValue != null) && (value != null) && (fieldValue != value)
}
private fun getFieldValue(field: JFormattedTextField): Int? {
return try {
val value = field.value
(value as Number).toInt()
} catch (ex: ParseException) {
null
}
}
override fun reset() {
settings?.settings = M68kLexerPrefs()
}
}
src/main/java/de/platon42/intellij/plugins/m68k/structureview/M68kStructureViewElement.kt
+2 -2
View File
@@ -6,8 +6,8 @@ import com.intellij.navigation.ItemPresentation
import com.intellij.psi.NavigatablePsiElement
import de.platon42.intellij.plugins.m68k.psi.M68kFile
import de.platon42.intellij.plugins.m68k.psi.M68kGlobalLabel
import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil
import de.platon42.intellij.plugins.m68k.psi.M68kLookupUtil.findAllLocalLabels
import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil
import de.platon42.intellij.plugins.m68k.psi.utils.M68kLookupUtil.findAllLocalLabels
class M68kStructureViewElement(private val myElement: NavigatablePsiElement) : StructureViewTreeElement {
override fun getValue(): Any = myElement
src/main/java/de/platon42/intellij/plugins/m68k/syntax/M68kSyntaxHighlighter.kt
+5 -7
View File
@@ -11,15 +11,13 @@ import com.intellij.psi.tree.IElementType
import de.platon42.intellij.plugins.m68k.lexer.M68kLexer
import de.platon42.intellij.plugins.m68k.lexer.M68kLexerPrefs
import de.platon42.intellij.plugins.m68k.psi.M68kTypes
import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
class M68kSyntaxHighlighter(val project: Project?) : SyntaxHighlighterBase() {
private val settings = project?.getService(M68kProjectSettings::class.java)
override fun getHighlightingLexer(): Lexer {
if (project == null) {
return M68kLexer(M68kLexerPrefs()) // Use some defaults
} else {
// FIXME Where do we get the prefs from?
return M68kLexer(M68kLexerPrefs())
}
return M68kLexer(settings?.settings ?: M68kLexerPrefs()) // Use some defaults
}
override fun getTokenHighlights(tokenType: IElementType): Array<TextAttributesKey> {
@@ -44,7 +42,7 @@ class M68kSyntaxHighlighter(val project: Project?) : SyntaxHighlighterBase() {
M68kTypes.AREG -> arrayOf(AREG)
M68kTypes.REG_SP -> arrayOf(STACK_POINTER)
M68kTypes.DREG -> arrayOf(DREG)
M68kTypes.REG_USP, M68kTypes.REG_SR, M68kTypes.REG_CCR, M68kTypes.REG_VBR -> arrayOf(SPECIAL_REG)
M68kTypes.REG_USP, M68kTypes.REG_SR, M68kTypes.REG_CCR, M68kTypes.REG_VBR, M68kTypes.REG_SFC, M68kTypes.REG_DFC -> arrayOf(SPECIAL_REG)
M68kTypes.COMMENT -> arrayOf(COMMENT)
M68kTypes.DECIMAL, M68kTypes.HEXADECIMAL, M68kTypes.OCTAL -> arrayOf(NUMBER)
M68kTypes.STRINGLIT -> arrayOf(STRING)
src/main/resources/META-INF/plugin.xml
+12 -2
View File
@@ -16,7 +16,7 @@
<extensions defaultExtensionNs="com.intellij">
<fileType name="MC68000 Assembler" implementationClass="de.platon42.intellij.plugins.m68k.M68kFileType"
fieldName="INSTANCE" language="MC68000" extensions="asm;ASM;s;S;i"/>
fieldName="INSTANCE" language="MC68000" extensions="asm;s;i"/>
<lang.parserDefinition language="MC68000"
implementationClass="de.platon42.intellij.plugins.m68k.parser.M68kParserDefinition"/>
<lang.syntaxHighlighterFactory language="MC68000"
@@ -39,6 +39,10 @@
implementationClass="de.platon42.intellij.plugins.m68k.refs.M68kPreprocessorDirectiveElementManipulator"/>
<lang.documentationProvider language="MC68000"
implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kSymbolDefinitionDocumentationProvider"/>
<lang.documentationProvider language="MC68000"
implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kLabelDefinitionDocumentationProvider"/>
<lang.documentationProvider language="MC68000"
implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kMacroDefinitionDocumentationProvider"/>
<lang.documentationProvider language="MC68000"
implementationClass="de.platon42.intellij.plugins.m68k.documentation.M68kRegisterFlowDocumentationProvider"/>
<lang.documentationProvider language="MC68000"
@@ -47,7 +51,7 @@
<stubIndex implementation="de.platon42.intellij.plugins.m68k.stubs.M68kGlobalLabelStubIndex"/>
<stubIndex implementation="de.platon42.intellij.plugins.m68k.stubs.M68kSymbolDefinitionStubIndex"/>
<stubIndex implementation="de.platon42.intellij.plugins.m68k.stubs.M68kMacroDefinitionStubIndex"/>
<psi.referenceContributor implementation="de.platon42.intellij.plugins.m68k.refs.M68kReferenceContributor"/>
<psi.referenceContributor language="MC68000" implementation="de.platon42.intellij.plugins.m68k.refs.M68kReferenceContributor"/>
<gotoSymbolContributor implementation="de.platon42.intellij.plugins.m68k.refs.M68kChooseByNameContributor"/>
<renameInputValidator implementation="de.platon42.intellij.plugins.m68k.psi.M68kRenameInputValidator"/>
<include.provider implementation="de.platon42.intellij.plugins.m68k.scanner.M68kIncludeFileProvider"/>
@@ -64,6 +68,12 @@
<localInspection implementationClass="de.platon42.intellij.plugins.m68k.inspections.M68kUnresolvedReferenceInspection"
displayName="Unresolved label/symbol/macro reference" groupName="M68k"
enabledByDefault="true" level="WARNING"/>
<projectService serviceImplementation="de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings"/>
<projectConfigurable parentId="language" instance="de.platon42.intellij.plugins.m68k.settings.M68kProjectSettingsConfigurable"
id="de.platon42.intellij.plugins.m68k.settings.M68kProjectSettingsConfigurable" displayName="M68k"
nonDefaultProject="true"/>
</extensions>
<actions>
src/test/java/de/platon42/intellij/jupiter/LightCodeInsightExtension.java
+9 -4
View File
@@ -12,6 +12,7 @@ import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.extension.*;
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
import org.junit.jupiter.api.extension.ExtensionContext.Store;
import org.junit.runner.Description;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
@@ -34,8 +35,11 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
LightCodeInsightFixtureTestCaseWrapper testCase = getWrapper(extensionContext);
Parameter parameter = parameterContext.getParameter();
if (parameter.isAnnotationPresent(MyFixture.class)) return testCase.getMyFixture();
else if (parameter.isAnnotationPresent(MyTestCase.class)) return testCase;
if (parameter.isAnnotationPresent(MyFixture.class)) {
return testCase.getMyFixture();
} else if (parameter.isAnnotationPresent(MyTestCase.class)) {
return testCase;
}
return null;
}
@@ -68,14 +72,15 @@ public class LightCodeInsightExtension implements ParameterResolver, AfterTestEx
@Override
public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
Throwable[] throwables = new Throwable[1];
Description testDescription = Description.createTestDescription(extensionContext.getRequiredTestClass(), getWrapper(extensionContext).getName());
Runnable runnable = () -> {
try {
TestLoggerFactory.onTestStarted();
invocation.proceed();
TestLoggerFactory.onTestFinished(true);
TestLoggerFactory.onTestFinished(true, testDescription);
} catch (Throwable e) {
TestLoggerFactory.onTestFinished(false);
TestLoggerFactory.onTestFinished(false, testDescription);
throwables[0] = e;
}
};
src/test/java/de/platon42/intellij/jupiter/ParsingTestExtension.java
+7 -20
View File
@@ -2,17 +2,17 @@ package de.platon42.intellij.jupiter;
import com.intellij.lang.ParserDefinition;
import com.intellij.mock.MockProjectEx;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.util.Disposer;
import com.intellij.psi.PsiFile;
import com.intellij.testFramework.EdtTestUtilKt;
import com.intellij.testFramework.ParsingTestCase;
import com.intellij.testFramework.TestLoggerFactory;
import com.intellij.testFramework.fixtures.IdeaTestExecutionPolicy;
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.extension.*;
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
import org.junit.jupiter.api.extension.ExtensionContext.Store;
import org.junit.runner.Description;
import java.io.IOException;
import java.lang.annotation.Annotation;
@@ -80,39 +80,26 @@ public class ParsingTestExtension implements ParameterResolver, AfterTestExecuti
@Override
public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
Throwable[] throwables = new Throwable[1];
Description testDescription = Description.createTestDescription(extensionContext.getRequiredTestClass(), getWrapper(extensionContext).getName());
Runnable runnable = () -> {
try {
TestLoggerFactory.onTestStarted();
invocation.proceed();
TestLoggerFactory.onTestFinished(true);
TestLoggerFactory.onTestFinished(true, testDescription);
} catch (Throwable e) {
TestLoggerFactory.onTestFinished(false);
TestLoggerFactory.onTestFinished(false, testDescription);
throwables[0] = e;
}
};
invokeTestRunnable(runnable);
if (throwables[0] != null) {
throw throwables[0];
}
}
private static void invokeTestRunnable(@NotNull Runnable runnable) {
IdeaTestExecutionPolicy policy = IdeaTestExecutionPolicy.current();
if (policy != null && !policy.runInDispatchThread()) {
runnable.run();
} else {
EdtTestUtilKt.runInEdtAndWait(() -> {
runnable.run();
return null;
});
}
}
public interface IParsingTestCase {
MockProjectEx getProject();
ParserDefinition getParserDefinition();
void ensureNoErrorElements();
src/test/java/de/platon42/intellij/plugins/m68k/asm/M68kMnemonicCompletionContributorTest.kt
+13 -7
View File
@@ -13,27 +13,33 @@ internal class M68kMnemonicCompletionContributorTest : AbstractM68kTest() {
@Test
internal fun completion_shows_all_move_mnemonics_after_first_letters(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText("completeme.asm", """
myFixture.configureByText(
"completeme.asm", """
mo<caret>
""")
"""
)
myFixture.completeBasic()
assertThat(myFixture.lookupElementStrings).containsExactlyInAnyOrder("move", "moveq", "movea", "movem", "movep")
assertThat(myFixture.lookupElementStrings).containsExactlyInAnyOrder("move", "moveq", "movea", "movem", "movep", "movec", "moves")
}
@Test
internal fun completion_shows_all_mnemonics_after_label(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText("completeme.asm", """
myFixture.configureByText(
"completeme.asm", """
label: <caret>
""")
"""
)
myFixture.completeBasic()
assertThat(myFixture.lookupElementStrings).hasSameElementsAs(M68kIsa.mnemonics)
}
@Test
internal fun completion_shows_all_mnemonics_after_space(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText("completeme.asm", """
myFixture.configureByText(
"completeme.asm", """
<caret>
""")
"""
)
myFixture.completeBasic()
assertThat(myFixture.lookupElementStrings).hasSameElementsAs(M68kIsa.mnemonics)
}
src/test/java/de/platon42/intellij/plugins/m68k/documentation/AbstractDocumentationProviderTest.kt
+1
View File
@@ -12,6 +12,7 @@ import org.junit.jupiter.api.extension.ExtendWith
abstract class AbstractDocumentationProviderTest : AbstractM68kTest() {
fun generateDocumentation(myFixture: CodeInsightTestFixture): String? {
// FIXME migrate to DocumentationTarget
val docElement = DocumentationManager.getInstance(myFixture.project).findTargetElement(myFixture.editor, myFixture.file)
val provider = DocumentationManager.getProviderFromElement(docElement)
src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kInstructionDocumentationProviderTest.kt
+10
View File
@@ -108,6 +108,16 @@ internal class M68kInstructionDocumentationProviderTest : AbstractDocumentationP
assertThat(generateDocumentation(myFixture)).contains("Reset External Devices", "(privileged)")
}
@Test
internal fun check_documentation_for_instruction_with_special_register(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
<caret>move.l usp,a0
"""
)
assertThat(generateDocumentation(myFixture)).contains("<div>usp</div>")
}
@Test
internal fun check_documentation_if_there_is_no_concrete_match(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kLabelDocumentationProviderTest.kt
+43
View File
@@ -0,0 +1,43 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.testFramework.fixtures.CodeInsightTestFixture
import de.platon42.intellij.jupiter.LightCodeInsightExtension
import de.platon42.intellij.jupiter.MyFixture
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
@ExtendWith(LightCodeInsightExtension::class)
internal class M68kLabelDocumentationProviderTest : AbstractDocumentationProviderTest() {
@Test
internal fun check_documentation_for_a_label_definition(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
rts
; inputs: d0 = number
; output: d0 = square
squareme: include "fancysquarecode.asm" ; code -> cool!
rts
bsr square<caret>me
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualTo("<span class=\"grayed\">; inputs: d0 = number<br/>; output: d0 = square<br/>; code -&gt; cool!</span><div class=\"definition\"><code>squareme</code></div><div class=\"content\"><code>include &quot;fancysquarecode.asm&quot;</code></div>")
}
@Test
internal fun check_documentation_for_a_label_definition_next_line(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
; output: d0 = square
.square<caret>me:
; oh man
include "fancysquarecode.asm"
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualTo("<span class=\"grayed\">; output: d0 = square</span><div class=\"definition\"><code>.squareme</code></div><div class=\"content\"><code>include &quot;fancysquarecode.asm&quot;</code></div>")
}
}
src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kMacroDefinitionDocumentationProviderTest.kt
+58
View File
@@ -0,0 +1,58 @@
package de.platon42.intellij.plugins.m68k.documentation
import com.intellij.testFramework.fixtures.CodeInsightTestFixture
import de.platon42.intellij.jupiter.LightCodeInsightExtension
import de.platon42.intellij.jupiter.MyFixture
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
@ExtendWith(LightCodeInsightExtension::class)
internal class M68kMacroDefinitionDocumentationProviderTest : AbstractDocumentationProviderTest() {
@Test
internal fun check_expanded_documentation_for_a_macro_definition(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
MOLV<caret>ANIA MACRO ; the bestest macro
move.l \1,d0
mulu d0,d0
ENDM
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualTo("<span class=\"grayed\">; the bestest macro</span><div class=\"definition\"><code>MOLVANIA</code></div><div class=\"content\"><code> move.l \\1,d0</code><br/><code> mulu d0,d0</code></div>")
}
@Test
internal fun check_expanded_documentation_for_a_macro_invocation(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
MOLVANIA MACRO ; the bestest macro
move.l \1,d0
mulu d0,d0
ENDM
MOLV<caret>ANIA d1
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualTo("<span class=\"grayed\">; the bestest macro</span><div class=\"definition\"><code>MOLVANIA</code></div><div class=\"content\"><code> move.l d1,d0</code><br/><code> mulu d0,d0</code></div>")
}
@Test
internal fun check_expanded_documentation_for_a_macro_invocation_with_lots_of_params(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
; compress nibbles
DTW MACRO
dc.b ((\1)<<4)|(\2),((\3)<<4)|(\4),((\5)<<4)|(\6),((\7)<<4)|(\8),((\9)<<4)|(\a),((\b)<<4)|(\c),((\d)<<4)|(\e),((\f)<<4)|(\g)
ENDM
DTW<caret> 15,14,14,10,1,2,3,4,10,11,10,12,5,3,9,10
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualTo("<span class=\"grayed\">; compress nibbles</span><div class=\"definition\"><code>DTW</code></div><div class=\"content\"><code> dc.b ((15)&lt;&lt;4)|(14),((14)&lt;&lt;4)|(10),((1)&lt;&lt;4)|(2),((3)&lt;&lt;4)|(4),((10)&lt;&lt;4)|(11),((10)&lt;&lt;4)|(12),((5)&lt;&lt;4)|(3),((9)&lt;&lt;4)|(10)</code></div>")
}
}
src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kRegisterFlowDocumentationProviderTest.kt
+36 -1
View File
@@ -100,7 +100,6 @@ nextlabel
)
}
@Test
internal fun check_documentation_for_a_written_register_in_code_flow(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
@@ -177,6 +176,42 @@ nextlabel
<td valign="top"> ; <font color="#00ff00">sets d1.l</font></td>
</tr>
</table>
"""
)
}
@Test
internal fun check_documentation_for_68020_address_modes(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
moveq.l #0,d0
lea foobar(pc),a0
move.l ([100.w,a0,a0.w*4],124.w),($42.w,a0,d0.l*4)
move.l a<caret>0,a1
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualToIgnoringWhitespace(
"""
<div class="definition">movea instruction uses a0.l</div>
<table class="sections" style="padding-left: 8pt; padding-right: 8pt">
<tr>
<td valign="top">        </td>
<td valign="top"><code>lea foobar(pc),<font color="#ffc800">a0</font></code></td>
<td valign="top"> ; <font color="#00ff00">sets a0.l</font></td>
</tr>
<tr>
<td valign="top">        </td>
<td valign="top"><code>move.l ([100.w,<font color="#ffc800">a0</font>,<font color="#ffc800">a0</font>.w*4],124.w),(${'$'}42.w,<font color="#ffc800">a0</font>,d0.l*4)</code>
</td>
<td valign="top"> ; uses a0.l, uses a0.w</td>
</tr>
<tr>
<td valign="top">--&gt;</td>
<td valign="top"><b><code>move.l <font color="#ffc800">a0</font>,a1</code></b></td>
<td valign="top"> ; &lt;--</td>
</tr>
</table>
"""
)
}
src/test/java/de/platon42/intellij/plugins/m68k/documentation/M68kSymbolDefinitionDocumentationProviderTest.kt
+2 -2
View File
@@ -14,11 +14,11 @@ internal class M68kSymbolDefinitionDocumentationProviderTest : AbstractDocumenta
internal fun check_documentation_for_a_symbol_definition(@MyFixture myFixture: CodeInsightTestFixture) {
myFixture.configureByText(
"documentme.asm", """
PIC_WIDTH = 320
PIC_WIDTH = 320 ; width of picture
move.w #PIC_WIDT<caret>H,d0
"""
)
assertThat(generateDocumentation(myFixture))
.isEqualTo("<div class='definition'><pre>PIC_WIDTH</pre></div><div class='content'>320</div>")
.isEqualTo("<span class=\"grayed\">; width of picture</span><div class=\"definition\"><code>PIC_WIDTH</code></div><div class=\"content\"><code>320</code></div>")
}
}
src/test/java/de/platon42/intellij/plugins/m68k/inspections/M68kInspectionSuppressorTest.kt
+1 -1
View File
@@ -63,7 +63,7 @@ internal class M68kInspectionSuppressorTest : AbstractInspectionTest() {
val quickFixPair = highlightInfos[0].quickFixActionRanges[0]
val intentionActionDescriptor = quickFixPair.first
val element = myFixture.file.findElementAt(quickFixPair.second.startOffset)!!
val suppressQuickFix = intentionActionDescriptor.getOptions(element, myFixture.editor)!!
val suppressQuickFix = intentionActionDescriptor.getOptions(element, myFixture.editor)
.first { it.text == suppressAction }
myFixture.launchAction(suppressQuickFix)
}
src/test/java/de/platon42/intellij/plugins/m68k/parser/AddressingModesTest.kt
+192 -2
View File
@@ -14,7 +14,7 @@ internal class AddressingModesTest : AbstractParsingTest() {
@Test
internal fun register_direct(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l d0,a7\n")
testGoodSyntax(testCase, " MOVE.L d0,a7\n")
}
@Test
@@ -52,6 +52,16 @@ internal class AddressingModesTest : AbstractParsingTest() {
testGoodSyntax(testCase, " move.l (sp,d0.w),(a1,a3)\n")
}
@Test
internal fun register_indirect_with_scaled_index_and_offset_old_syntax(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l -4+foo(sp,d0.w*8),(10*20+4)(a1,a3*4)\n")
}
@Test
internal fun register_indirect_with_scaled_index_and_offset_new_syntax(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (-4+foo,sp,a0*1),((10*20+4),a1,d5.l*2)\n")
}
@Test
internal fun pc_indirect_with_offset_old_syntax(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l -4*4(pc),+4(pc)\n")
@@ -82,11 +92,191 @@ internal class AddressingModesTest : AbstractParsingTest() {
testGoodSyntax(testCase, " move.l (pc,d0.w),(pc,a3)\n")
}
@Test
internal fun memory_indirect_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.w,a1],124),([-12.w,a0],-120)\n")
}
@Test
internal fun memory_indirect_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1],124.l),([a0],-120.w)\n")
}
@Test
internal fun memory_indirect_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1]),([-12,a0])\n")
}
@Test
internal fun memory_indirect_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1]),([a0])\n")
}
@Test
internal fun memory_indirect_post_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.w,a1],a0.w*4,124),([-12,a0],d0.l*8,-120.w)\n")
}
@Test
internal fun memory_indirect_post_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1],a0,124.l),([a0],d0.l*8,-120)\n")
}
@Test
internal fun memory_indirect_post_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.l,a1],a0),([-12,a0],d0.l*8)\n")
}
@Test
internal fun memory_indirect_post_indexed_without_address_register(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.l],a0),([-12],d0.l*8)\n")
}
@Test
internal fun memory_indirect_post_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1],a0),([a0],d0)\n")
}
@Test
internal fun memory_indirect_pre_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,a1,a0.w*4],124),([-12,a0,d0.l*8],-120)\n")
}
@Test
internal fun memory_indirect_pre_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1,a0],124),([a0,d0.l*8],-120.w)\n")
}
@Test
internal fun memory_indirect_pre_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.l,a1,a0]),([-12,a0,d0.l*8])\n")
}
@Test
internal fun memory_indirect_pre_indexed_without_address_register(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.l,a0*4]),([-12,d0.l*8])\n")
}
@Test
internal fun memory_indirect_pre_indexed_only_with_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a0*4]),([d0.l*8])\n")
}
@Test
internal fun memory_indirect_pre_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([a1,a0]),([a0,d0])\n")
}
@Test
internal fun pc_memory_indirect_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.w,pc],124),d0\n")
}
@Test
internal fun pc_memory_indirect_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc],124.l),d0\n")
}
@Test
internal fun pc_memory_indirect_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc]),d0\n")
}
@Test
internal fun pc_memory_indirect_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc]),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.l,pc],a0.w*4,124.w),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc],a0.l*4,124),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc],a0),d0\n")
}
@Test
internal fun pc_memory_indirect_post_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc],a0*4),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_with_all_params(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234.w,pc,a0.w*4],124),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_without_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc,a0*4],124.l),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_without_outer_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([1234,pc,a0]),d0\n")
}
@Test
internal fun pc_memory_indirect_pre_indexed_minimal(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l ([pc,a0.l*4]),d0\n")
}
@Test
internal fun register_indirect_with_index_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (100.w,a0,a0.l*4),d0\n")
}
@Test
internal fun register_indirect_with_index_base_displacement_without_areg(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (100.w,a0.l*4),d0\n")
}
@Test
internal fun register_indirect_with_index_base_displacement_without_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (100.l,a0),d0\n")
}
@Test
internal fun register_indirect_with_index_base_displacement_with_dreg_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (d0),(d0.w*4)\n")
}
@Test
internal fun register_indirect_with_index_base_displacement_only(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (100.l),d0\n")
}
@Test
internal fun register_indirect_with_index_base_displacement_zero(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (),d0\n")
}
@Test
internal fun pc_indirect_with_index_base_displacement(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (100.w,pc,a0.l*4),d0\n")
}
@Test
internal fun pc_indirect_with_index_base_displacement_without_index(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l (100.l,pc),d0\n")
}
@Test
internal fun absolute_address(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " move.l 4.w,a6\n")
}
@Test
internal fun btst_quirk(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " btst #5,#42\n btst d0,#42")
}
@Test
internal fun movem_register_list(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(testCase, " movem.l d0-d2/d4/a0/a2-a3/a5,-(sp)\n")
@@ -118,7 +308,7 @@ internal class AddressingModesTest : AbstractParsingTest() {
internal fun special_register_move(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(
testCase, " move.l usp,a0\n"
+ " move.l a5,usp\n"
+ " move.l a5,USP\n"
)
}
src/test/java/de/platon42/intellij/plugins/m68k/parser/CommentsTest.kt
+21 -6
View File
@@ -3,6 +3,7 @@ package de.platon42.intellij.plugins.m68k.parser
import de.platon42.intellij.jupiter.MyTestCase
import de.platon42.intellij.jupiter.ParsingTestExtension
import de.platon42.intellij.jupiter.TestDataSubPath
import de.platon42.intellij.plugins.m68k.settings.M68kProjectSettings
import org.junit.jupiter.api.Test
@TestDataSubPath("comments")
@@ -50,37 +51,51 @@ internal class CommentsTest : AbstractParsingTest() {
@Test
internal fun comment_after_instruction_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
(testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = true
setSpacesSetting(testCase, true)
testGoodSyntax(testCase, " add.w d0,d0 hey comment\n")
}
@Test
internal fun comment_after_assignment_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
(testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = true
setSpacesSetting(testCase, true)
testGoodSyntax(testCase, "FOO = 123+23 hey comment\n")
}
@Test
internal fun comment_after_data_directive_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
setSpacesSetting(testCase, true)
testGoodSyntax(testCase, " dc.w $1234,$2345 hey comment\n")
}
@Test
internal fun comment_after_macro_call_with_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
(testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = true
setSpacesSetting(testCase, true)
testGoodSyntax(testCase, " PUSHM d0,d0 hey comment\n")
}
@Test
internal fun space_does_not_start_comment_within_instruction_without_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
(testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = false
setSpacesSetting(testCase, false)
testGoodSyntax(testCase, " add.w # 234, d0 ; hey comment\n")
}
@Test
internal fun space_does_not_start_comment_within_assignment_without_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
(testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = false
setSpacesSetting(testCase, false)
testGoodSyntax(testCase, "FOO = 123 + 23 ; hey comment\n")
}
@Test
internal fun space_does_not_start_comment_within_macro_call_without_space_introduces_comment_option(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
(testCase.parserDefinition as M68kParserDefinition).lexerPrefs.spaceIntroducesComment = false
setSpacesSetting(testCase, false)
testGoodSyntax(testCase, " PUSHM d0, d0 ; hey comment\n")
}
private fun setSpacesSetting(testCase: ParsingTestExtension.IParsingTestCase, spacesOption: Boolean) {
val settings = M68kProjectSettings()
settings.settings.spaceIntroducesComment = spacesOption
testCase.project.registerService(M68kProjectSettings::class.java, settings)
}
}
src/test/java/de/platon42/intellij/plugins/m68k/parser/EndDirectiveTest.kt
+2
View File
@@ -3,12 +3,14 @@ package de.platon42.intellij.plugins.m68k.parser
import de.platon42.intellij.jupiter.MyTestCase
import de.platon42.intellij.jupiter.ParsingTestExtension
import de.platon42.intellij.jupiter.TestDataSubPath
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test
@TestDataSubPath("directives")
internal class EndDirectiveTest : AbstractParsingTest() {
@Test
@Disabled("END directive detection breaks stuff, need to find a different solution")
internal fun end_directive(@MyTestCase testCase: ParsingTestExtension.IParsingTestCase) {
testGoodSyntax(
testCase, """
src/test/java/de/platon42/intellij/plugins/m68k/refs/M68kReferenceContributorTest.kt
+2 -2
View File
@@ -103,7 +103,7 @@ internal class M68kReferenceContributorTest : AbstractM68kTest() {
assertThat(otherfile.text).isEqualTo("; oh no!")
myFixture.renameElementAtCaret("foobar.asm")
val files = FilenameIndex.getFilesByName(myFixture.project, "foobar.asm", GlobalSearchScope.allScope(myFixture.project))
val files = FilenameIndex.getVirtualFilesByName("foobar.asm", GlobalSearchScope.allScope(myFixture.project))
assertThat(files).hasSize(1)
assertThat(file.text).isEqualToIgnoringWhitespace("include \"foobar.asm\"")
@@ -123,7 +123,7 @@ internal class M68kReferenceContributorTest : AbstractM68kTest() {
assertThat(otherfile.text).isEqualTo("; oh no!")
myFixture.renameElementAtCaret("foobar.asm")
val files = FilenameIndex.getFilesByName(myFixture.project, "foobar.asm", GlobalSearchScope.allScope(myFixture.project))
val files = FilenameIndex.getVirtualFilesByName("foobar.asm", GlobalSearchScope.allScope(myFixture.project))
assertThat(files).hasSize(1)
assertThat(file.text).isEqualToIgnoringWhitespace("include \"foobar/foobar.asm\"")
src/test/resources/parser/addressingmodes/btst_quirk.txt
+31
View File
@@ -0,0 +1,31 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('btst')
PsiWhiteSpace(' ')
M68kImmediateDataImpl(IMMEDIATE_DATA)
PsiElement(M68kTokenType.HASH)('#')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('5')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kImmediateDataImpl(IMMEDIATE_DATA)
PsiElement(M68kTokenType.HASH)('#')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('42')
PsiElement(M68kTokenType.EOL)('\n')
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('btst')
PsiWhiteSpace(' ')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kImmediateDataImpl(IMMEDIATE_DATA)
PsiElement(M68kTokenType.HASH)('#')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('42')
src/test/resources/parser/addressingmodes/memory_indirect_minimal.txt
+25
View File
@@ -0,0 +1,25 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_minimal.txt
+33
View File
@@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_with_all_params.txt
+69
View File
@@ -0,0 +1,69 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_address_register.txt
+45
View File
@@ -0,0 +1,45 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_base_displacement.txt
+51
View File
@@ -0,0 +1,51 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_post_indexed_without_outer_displacement.txt
+51
View File
@@ -0,0 +1,51 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPostIndexedAddressingModeImpl(MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_minimal.txt
+33
View File
@@ -0,0 +1,33 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_only_with_index.txt
+37
View File
@@ -0,0 +1,37 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_with_all_params.txt
+65
View File
@@ -0,0 +1,65 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_address_register.txt
+49
View File
@@ -0,0 +1,49 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_base_displacement.txt
+51
View File
@@ -0,0 +1,51 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_pre_indexed_without_outer_displacement.txt
+51
View File
@@ -0,0 +1,51 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectPreIndexedAddressingModeImpl(MEMORY_INDIRECT_PRE_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('8')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_with_all_params.txt
+49
View File
@@ -0,0 +1,49 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_without_base_displacement.txt
+39
View File
@@ -0,0 +1,39 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('120')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/memory_indirect_without_outer_displacement.txt
+35
View File
@@ -0,0 +1,35 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a1')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kMemoryIndirectAddressingModeImpl(MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kUnaryMinusExprImpl(UNARY_MINUS_EXPR)
PsiElement(M68kTokenType.OP_MINUS)('-')
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('12')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/pc_indirect_with_index_base_displacement.txt
+34
View File
@@ -0,0 +1,34 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('100')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/pc_indirect_with_index_base_displacement_without_index.txt
+24
View File
@@ -0,0 +1,24 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterIndirectWithIndexBaseDisplacementAddressingModeImpl(PROGRAM_COUNTER_INDIRECT_WITH_INDEX_BASE_DISPLACEMENT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('100')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/pc_memory_indirect_minimal.txt
+20
View File
@@ -0,0 +1,20 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_minimal.txt
+28
View File
@@ -0,0 +1,28 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')
src/test/resources/parser/addressingmodes/pc_memory_indirect_post_indexed_with_all_params.txt
+42
View File
@@ -0,0 +1,42 @@
Assembly File: a.asm
PsiWhiteSpace(' ')
M68kStatementImpl(STATEMENT)
M68kAsmInstructionImpl(ASM_INSTRUCTION)
M68kAsmOpImpl(ASM_OP)
PsiElement(M68kTokenType.MNEMONIC)('move')
M68kOperandSizeImpl(OPERAND_SIZE)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiWhiteSpace(' ')
M68kProgramCounterMemoryIndirectPostIndexedAddressingModeImpl(PROGRAM_COUNTER_MEMORY_INDIRECT_POST_INDEXED_ADDRESSING_MODE)
PsiElement(M68kTokenType.ROUND_L)('(')
PsiElement(M68kTokenType.SQUARE_L)('[')
M68kBaseDisplacementImpl(BASE_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('1234')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_L)('.l')
PsiElement(M68kTokenType.SEPARATOR)(',')
PsiElement(M68kTokenType.PC)('pc')
PsiElement(M68kTokenType.SQUARE_R)(']')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kIndexRegisterImpl(INDEX_REGISTER)
M68kAddressRegisterImpl(ADDRESS_REGISTER)
PsiElement(M68kTokenType.AREG)('a0')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.OP_AR_MUL)('*')
M68kIndexScaleImpl(INDEX_SCALE)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('4')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kOuterDisplacementImpl(OUTER_DISPLACEMENT)
M68kLiteralExprImpl(LITERAL_EXPR)
PsiElement(M68kTokenType.DECIMAL)('124')
M68kDataWidthImpl(DATA_WIDTH)
PsiElement(M68kTokenType.OPSIZE_W)('.w')
PsiElement(M68kTokenType.ROUND_R)(')')
PsiElement(M68kTokenType.SEPARATOR)(',')
M68kDataRegisterDirectAddressingModeImpl(DATA_REGISTER_DIRECT_ADDRESSING_MODE)
M68kDataRegisterImpl(DATA_REGISTER)
PsiElement(M68kTokenType.DREG)('d0')
PsiElement(M68kTokenType.EOL)('\n')

Some files were not shown because too many files have changed in this diff Show More