cariboujs 2.0.7 → 2.0.8

package/asm/asm8080/asm8080Parser.js

@@ -4,49 +4,84 @@ import antlr4 from 'antlr4';
 import asm8080Listener from './asm8080Listener.js';
 import asm8080Visitor from './asm8080Visitor.js';
 
-const serializedATN = [4,1,18,146,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
+const serializedATN = [4,1,41,244,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,
 4,2,5,7,5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,
-2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,1,0,5,0,38,8,0,10,0,12,
-0,41,9,0,1,0,1,0,1,0,5,0,46,8,0,10,0,12,0,49,9,0,1,0,1,0,5,0,53,8,0,10,0,
-12,0,56,9,0,3,0,58,8,0,1,0,1,0,1,1,3,1,63,8,1,1,1,1,1,3,1,67,8,1,1,1,3,1,
-70,8,1,1,1,1,1,3,1,74,8,1,1,1,3,1,77,8,1,1,2,1,2,3,2,81,8,2,1,3,1,3,1,4,
-1,4,1,5,3,5,88,8,5,1,5,1,5,1,5,1,6,1,6,1,7,1,7,3,7,97,8,7,1,8,1,8,1,8,5,
-8,102,8,8,10,8,12,8,105,9,8,1,9,1,9,1,10,1,10,1,10,5,10,112,8,10,10,10,12,
-10,115,9,10,1,11,1,11,1,11,5,11,120,8,11,10,11,12,11,123,9,11,1,12,1,12,
-1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,134,8,12,1,13,1,13,1,14,1,14,1,15,
-1,15,1,16,1,16,1,17,1,17,1,17,0,0,18,0,2,4,6,8,10,12,14,16,18,20,22,24,26,
-28,30,32,34,0,2,1,0,3,4,1,0,5,6,148,0,39,1,0,0,0,2,76,1,0,0,0,4,78,1,0,0,
-0,6,82,1,0,0,0,8,84,1,0,0,0,10,87,1,0,0,0,12,92,1,0,0,0,14,94,1,0,0,0,16,
-98,1,0,0,0,18,106,1,0,0,0,20,108,1,0,0,0,22,116,1,0,0,0,24,133,1,0,0,0,26,
-135,1,0,0,0,28,137,1,0,0,0,30,139,1,0,0,0,32,141,1,0,0,0,34,143,1,0,0,0,
-36,38,5,17,0,0,37,36,1,0,0,0,38,41,1,0,0,0,39,37,1,0,0,0,39,40,1,0,0,0,40,
-57,1,0,0,0,41,39,1,0,0,0,42,43,3,2,1,0,43,44,5,17,0,0,44,46,1,0,0,0,45,42,
-1,0,0,0,46,49,1,0,0,0,47,45,1,0,0,0,47,48,1,0,0,0,48,50,1,0,0,0,49,47,1,
-0,0,0,50,54,3,2,1,0,51,53,5,17,0,0,52,51,1,0,0,0,53,56,1,0,0,0,54,52,1,0,
-0,0,54,55,1,0,0,0,55,58,1,0,0,0,56,54,1,0,0,0,57,47,1,0,0,0,57,58,1,0,0,
-0,58,59,1,0,0,0,59,60,5,0,0,1,60,1,1,0,0,0,61,63,3,14,7,0,62,61,1,0,0,0,
-62,63,1,0,0,0,63,66,1,0,0,0,64,67,3,4,2,0,65,67,3,10,5,0,66,64,1,0,0,0,66,
-65,1,0,0,0,67,69,1,0,0,0,68,70,3,34,17,0,69,68,1,0,0,0,69,70,1,0,0,0,70,
-77,1,0,0,0,71,73,3,14,7,0,72,74,3,34,17,0,73,72,1,0,0,0,73,74,1,0,0,0,74,
-77,1,0,0,0,75,77,3,34,17,0,76,62,1,0,0,0,76,71,1,0,0,0,76,75,1,0,0,0,77,
-3,1,0,0,0,78,80,3,6,3,0,79,81,3,16,8,0,80,79,1,0,0,0,80,81,1,0,0,0,81,5,
-1,0,0,0,82,83,5,12,0,0,83,7,1,0,0,0,84,85,5,11,0,0,85,9,1,0,0,0,86,88,3,
-24,12,0,87,86,1,0,0,0,87,88,1,0,0,0,88,89,1,0,0,0,89,90,3,12,6,0,90,91,3,
-16,8,0,91,11,1,0,0,0,92,93,5,10,0,0,93,13,1,0,0,0,94,96,3,18,9,0,95,97,5,
-1,0,0,96,95,1,0,0,0,96,97,1,0,0,0,97,15,1,0,0,0,98,103,3,20,10,0,99,100,
-5,2,0,0,100,102,3,20,10,0,101,99,1,0,0,0,102,105,1,0,0,0,103,101,1,0,0,0,
-103,104,1,0,0,0,104,17,1,0,0,0,105,103,1,0,0,0,106,107,3,30,15,0,107,19,
-1,0,0,0,108,113,3,22,11,0,109,110,7,0,0,0,110,112,3,22,11,0,111,109,1,0,
-0,0,112,115,1,0,0,0,113,111,1,0,0,0,113,114,1,0,0,0,114,21,1,0,0,0,115,113,
-1,0,0,0,116,121,3,24,12,0,117,118,7,1,0,0,118,120,3,24,12,0,119,117,1,0,
-0,0,120,123,1,0,0,0,121,119,1,0,0,0,121,122,1,0,0,0,122,23,1,0,0,0,123,121,
-1,0,0,0,124,134,3,32,16,0,125,134,3,8,4,0,126,134,3,26,13,0,127,134,3,30,
-15,0,128,134,3,28,14,0,129,130,5,7,0,0,130,131,3,20,10,0,131,132,5,8,0,0,
-132,134,1,0,0,0,133,124,1,0,0,0,133,125,1,0,0,0,133,126,1,0,0,0,133,127,
-1,0,0,0,133,128,1,0,0,0,133,129,1,0,0,0,134,25,1,0,0,0,135,136,5,9,0,0,136,
-27,1,0,0,0,137,138,5,16,0,0,138,29,1,0,0,0,139,140,5,13,0,0,140,31,1,0,0,
-0,141,142,5,14,0,0,142,33,1,0,0,0,143,144,5,15,0,0,144,35,1,0,0,0,16,39,
-47,54,57,62,66,69,73,76,80,87,96,103,113,121,133];
+2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
+20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,1,0,5,0,54,8,0,
+10,0,12,0,57,9,0,1,0,1,0,4,0,61,8,0,11,0,12,0,62,5,0,65,8,0,10,0,12,0,68,
+9,0,1,0,1,0,5,0,72,8,0,10,0,12,0,75,9,0,3,0,77,8,0,1,0,1,0,1,1,3,1,82,8,
+1,1,1,1,1,1,1,3,1,87,8,1,1,1,1,1,1,1,1,1,3,1,93,8,1,5,1,95,8,1,10,1,12,1,
+98,9,1,1,1,3,1,101,8,1,1,1,1,1,3,1,105,8,1,1,1,3,1,108,8,1,1,2,1,2,3,2,112,
+8,2,1,3,1,3,3,3,116,8,3,1,4,1,4,1,5,1,5,1,6,3,6,123,8,6,1,6,1,6,3,6,127,
+8,6,1,7,1,7,1,8,1,8,3,8,133,8,8,1,9,1,9,1,9,5,9,138,8,9,10,9,12,9,141,9,
+9,1,10,1,10,1,10,3,10,146,8,10,1,11,1,11,1,11,3,11,151,8,11,1,12,1,12,1,
+12,5,12,156,8,12,10,12,12,12,159,9,12,1,13,1,13,1,13,5,13,164,8,13,10,13,
+12,13,167,9,13,1,14,1,14,1,14,5,14,172,8,14,10,14,12,14,175,9,14,1,15,1,
+15,1,15,5,15,180,8,15,10,15,12,15,183,9,15,1,16,1,16,1,16,5,16,188,8,16,
+10,16,12,16,191,9,16,1,17,1,17,1,17,5,17,196,8,17,10,17,12,17,199,9,17,1,
+18,1,18,1,18,5,18,204,8,18,10,18,12,18,207,9,18,1,19,1,19,1,19,1,19,1,19,
+1,19,1,19,1,19,1,19,1,19,1,19,3,19,220,8,19,1,20,1,20,1,20,1,20,1,20,1,20,
+1,20,1,20,1,20,1,20,3,20,232,8,20,1,21,1,21,1,22,1,22,1,23,1,23,1,24,1,24,
+1,25,1,25,1,25,0,0,26,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,
+38,40,42,44,46,48,50,0,4,2,0,4,9,27,32,1,0,10,11,1,0,24,25,1,0,12,13,260,
+0,55,1,0,0,0,2,107,1,0,0,0,4,109,1,0,0,0,6,113,1,0,0,0,8,117,1,0,0,0,10,
+119,1,0,0,0,12,122,1,0,0,0,14,128,1,0,0,0,16,130,1,0,0,0,18,134,1,0,0,0,
+20,145,1,0,0,0,22,147,1,0,0,0,24,152,1,0,0,0,26,160,1,0,0,0,28,168,1,0,0,
+0,30,176,1,0,0,0,32,184,1,0,0,0,34,192,1,0,0,0,36,200,1,0,0,0,38,219,1,0,
+0,0,40,231,1,0,0,0,42,233,1,0,0,0,44,235,1,0,0,0,46,237,1,0,0,0,48,239,1,
+0,0,0,50,241,1,0,0,0,52,54,5,39,0,0,53,52,1,0,0,0,54,57,1,0,0,0,55,53,1,
+0,0,0,55,56,1,0,0,0,56,76,1,0,0,0,57,55,1,0,0,0,58,60,3,2,1,0,59,61,5,39,
+0,0,60,59,1,0,0,0,61,62,1,0,0,0,62,60,1,0,0,0,62,63,1,0,0,0,63,65,1,0,0,
+0,64,58,1,0,0,0,65,68,1,0,0,0,66,64,1,0,0,0,66,67,1,0,0,0,67,69,1,0,0,0,
+68,66,1,0,0,0,69,73,3,2,1,0,70,72,5,39,0,0,71,70,1,0,0,0,72,75,1,0,0,0,73,
+71,1,0,0,0,73,74,1,0,0,0,74,77,1,0,0,0,75,73,1,0,0,0,76,66,1,0,0,0,76,77,
+1,0,0,0,77,78,1,0,0,0,78,79,5,0,0,1,79,1,1,0,0,0,80,82,3,16,8,0,81,80,1,
+0,0,0,81,82,1,0,0,0,82,86,1,0,0,0,83,87,3,4,2,0,84,87,3,12,6,0,85,87,3,6,
+3,0,86,83,1,0,0,0,86,84,1,0,0,0,86,85,1,0,0,0,87,96,1,0,0,0,88,92,5,1,0,
+0,89,93,3,4,2,0,90,93,3,12,6,0,91,93,3,6,3,0,92,89,1,0,0,0,92,90,1,0,0,0,
+92,91,1,0,0,0,92,93,1,0,0,0,93,95,1,0,0,0,94,88,1,0,0,0,95,98,1,0,0,0,96,
+94,1,0,0,0,96,97,1,0,0,0,97,100,1,0,0,0,98,96,1,0,0,0,99,101,3,50,25,0,100,
+99,1,0,0,0,100,101,1,0,0,0,101,108,1,0,0,0,102,104,3,16,8,0,103,105,3,50,
+25,0,104,103,1,0,0,0,104,105,1,0,0,0,105,108,1,0,0,0,106,108,3,50,25,0,107,
+81,1,0,0,0,107,102,1,0,0,0,107,106,1,0,0,0,108,3,1,0,0,0,109,111,3,8,4,0,
+110,112,3,18,9,0,111,110,1,0,0,0,111,112,1,0,0,0,112,5,1,0,0,0,113,115,3,
+46,23,0,114,116,3,18,9,0,115,114,1,0,0,0,115,116,1,0,0,0,116,7,1,0,0,0,117,
+118,5,34,0,0,118,9,1,0,0,0,119,120,5,33,0,0,120,11,1,0,0,0,121,123,3,40,
+20,0,122,121,1,0,0,0,122,123,1,0,0,0,123,124,1,0,0,0,124,126,3,14,7,0,125,
+127,3,18,9,0,126,125,1,0,0,0,126,127,1,0,0,0,127,13,1,0,0,0,128,129,5,17,
+0,0,129,15,1,0,0,0,130,132,3,20,10,0,131,133,5,2,0,0,132,131,1,0,0,0,132,
+133,1,0,0,0,133,17,1,0,0,0,134,139,3,22,11,0,135,136,5,3,0,0,136,138,3,22,
+11,0,137,135,1,0,0,0,138,141,1,0,0,0,139,137,1,0,0,0,139,140,1,0,0,0,140,
+19,1,0,0,0,141,139,1,0,0,0,142,146,3,46,23,0,143,146,3,10,5,0,144,146,3,
+14,7,0,145,142,1,0,0,0,145,143,1,0,0,0,145,144,1,0,0,0,146,21,1,0,0,0,147,
+150,3,24,12,0,148,149,7,0,0,0,149,151,3,24,12,0,150,148,1,0,0,0,150,151,
+1,0,0,0,151,23,1,0,0,0,152,157,3,26,13,0,153,154,5,22,0,0,154,156,3,26,13,
+0,155,153,1,0,0,0,156,159,1,0,0,0,157,155,1,0,0,0,157,158,1,0,0,0,158,25,
+1,0,0,0,159,157,1,0,0,0,160,165,3,28,14,0,161,162,5,23,0,0,162,164,3,28,
+14,0,163,161,1,0,0,0,164,167,1,0,0,0,165,163,1,0,0,0,165,166,1,0,0,0,166,
+27,1,0,0,0,167,165,1,0,0,0,168,173,3,30,15,0,169,170,5,21,0,0,170,172,3,
+30,15,0,171,169,1,0,0,0,172,175,1,0,0,0,173,171,1,0,0,0,173,174,1,0,0,0,
+174,29,1,0,0,0,175,173,1,0,0,0,176,181,3,32,16,0,177,178,7,1,0,0,178,180,
+3,32,16,0,179,177,1,0,0,0,180,183,1,0,0,0,181,179,1,0,0,0,181,182,1,0,0,
+0,182,31,1,0,0,0,183,181,1,0,0,0,184,189,3,34,17,0,185,186,7,2,0,0,186,188,
+3,34,17,0,187,185,1,0,0,0,188,191,1,0,0,0,189,187,1,0,0,0,189,190,1,0,0,
+0,190,33,1,0,0,0,191,189,1,0,0,0,192,197,3,36,18,0,193,194,5,26,0,0,194,
+196,3,36,18,0,195,193,1,0,0,0,196,199,1,0,0,0,197,195,1,0,0,0,197,198,1,
+0,0,0,198,35,1,0,0,0,199,197,1,0,0,0,200,205,3,38,19,0,201,202,7,3,0,0,202,
+204,3,38,19,0,203,201,1,0,0,0,204,207,1,0,0,0,205,203,1,0,0,0,205,206,1,
+0,0,0,206,37,1,0,0,0,207,205,1,0,0,0,208,209,5,18,0,0,209,220,3,38,19,0,
+210,211,5,19,0,0,211,220,3,38,19,0,212,213,5,20,0,0,213,220,3,38,19,0,214,
+215,5,11,0,0,215,220,3,38,19,0,216,217,5,10,0,0,217,220,3,38,19,0,218,220,
+3,40,20,0,219,208,1,0,0,0,219,210,1,0,0,0,219,212,1,0,0,0,219,214,1,0,0,
+0,219,216,1,0,0,0,219,218,1,0,0,0,220,39,1,0,0,0,221,232,3,48,24,0,222,232,
+3,8,4,0,223,232,3,10,5,0,224,232,3,42,21,0,225,232,3,46,23,0,226,232,3,44,
+22,0,227,228,5,14,0,0,228,229,3,22,11,0,229,230,5,15,0,0,230,232,1,0,0,0,
+231,221,1,0,0,0,231,222,1,0,0,0,231,223,1,0,0,0,231,224,1,0,0,0,231,225,
+1,0,0,0,231,226,1,0,0,0,231,227,1,0,0,0,232,41,1,0,0,0,233,234,5,16,0,0,
+234,43,1,0,0,0,235,236,5,38,0,0,236,45,1,0,0,0,237,238,5,35,0,0,238,47,1,
+0,0,0,239,240,5,36,0,0,240,49,1,0,0,0,241,242,5,37,0,0,242,51,1,0,0,0,29,
+55,62,66,73,76,81,86,92,96,100,104,107,111,115,122,126,132,139,145,150,157,
+165,173,181,189,197,205,219,231];
 
 
 const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
@@ -58,17 +93,27 @@ const sharedContextCache = new antlr4.atn.PredictionContextCache();
 export default class asm8080Parser extends antlr4.Parser {
 
     static grammarFileName = "asm8080.g4";
-    static literalNames = [ null, "':'", "','", "'+'", "'-'", "'*'", "'/'", 
-                            "'('", "')'", "'$'" ];
+    static literalNames = [ null, "'!'", "':'", "','", "'='", "'<>'", "'<'", 
+                            "'>'", "'<='", "'>='", "'+'", "'-'", "'*'", 
+                            "'/'", "'('", "')'", "'$'", null, "'NOT'", "'HIGH'", 
+                            "'LOW'", "'AND'", "'OR'", "'XOR'", "'SHL'", 
+                            "'SHR'", "'MOD'", "'GT'", "'LT'", "'GE'", "'LE'", 
+                            "'NE'", "'EQ'" ];
     static symbolicNames = [ null, null, null, null, null, null, null, null, 
-                             null, null, "ASSEMBLER_DIRECTIVE", "REGISTER", 
-                             "OPCODE", "NAME", "NUMBER", "COMMENT", "STRING", 
-                             "EOL", "WS" ];
-    static ruleNames = [ "prog", "line", "instruction", "opcode", "register_", 
-                         "directive", "assemblerdirective", "lbl", "expressionlist", 
-                         "label", "expression", "multiplyingExpression", 
-                         "argument", "dollar", "string_", "name", "number", 
-                         "comment" ];
+                             null, null, null, null, null, null, null, null, 
+                             null, "ASSEMBLER_DIRECTIVE", "OP_NOT", "OP_HIGH", 
+                             "OP_LOW", "OP_AND", "OP_OR", "OP_XOR", "OP_SHL", 
+                             "OP_SHR", "OP_MOD", "OP_GT", "OP_LT", "OP_GE", 
+                             "OP_LE", "OP_NE", "OP_EQ", "REGISTER", "OPCODE", 
+                             "NAME", "NUMBER", "COMMENT", "STRING", "EOL", 
+                             "WS", "ARTIFACT" ];
+    static ruleNames = [ "prog", "line", "instruction", "macrocall", "opcode", 
+                         "register_", "directive", "assemblerdirective", 
+                         "lbl", "expressionlist", "label", "expression", 
+                         "orExpression", "xorExpression", "andExpression", 
+                         "addExpression", "shiftExpression", "modExpression", 
+                         "multiplyingExpression", "unaryExpression", "argument", 
+                         "dollar", "string_", "name", "number", "comment" ];
 
     constructor(input) {
         super(input);
@@ -86,50 +131,58 @@ export default class asm8080Parser extends antlr4.Parser {
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 39;
+	        this.state = 55;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        while(_la===17) {
-	            this.state = 36;
+	        while(_la===39) {
+	            this.state = 52;
 	            this.match(asm8080Parser.EOL);
-	            this.state = 41;
+	            this.state = 57;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	        }
-	        this.state = 57;
+	        this.state = 76;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 130688) !== 0)) {
-	            this.state = 47;
+	        if(((((_la - 14)) & ~0x1f) === 0 && ((1 << (_la - 14)) & 33030157) !== 0)) {
+	            this.state = 66;
 	            this._errHandler.sync(this);
-	            var _alt = this._interp.adaptivePredict(this._input,1,this._ctx)
+	            var _alt = this._interp.adaptivePredict(this._input,2,this._ctx)
 	            while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
 	                if(_alt===1) {
-	                    this.state = 42;
+	                    this.state = 58;
 	                    this.line();
-	                    this.state = 43;
-	                    this.match(asm8080Parser.EOL); 
+	                    this.state = 60; 
+	                    this._errHandler.sync(this);
+	                    _la = this._input.LA(1);
+	                    do {
+	                        this.state = 59;
+	                        this.match(asm8080Parser.EOL);
+	                        this.state = 62; 
+	                        this._errHandler.sync(this);
+	                        _la = this._input.LA(1);
+	                    } while(_la===39); 
 	                }
-	                this.state = 49;
+	                this.state = 68;
 	                this._errHandler.sync(this);
-	                _alt = this._interp.adaptivePredict(this._input,1,this._ctx);
+	                _alt = this._interp.adaptivePredict(this._input,2,this._ctx);
 	            }
 
-	            this.state = 50;
+	            this.state = 69;
 	            this.line();
-	            this.state = 54;
+	            this.state = 73;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
-	            while(_la===17) {
-	                this.state = 51;
+	            while(_la===39) {
+	                this.state = 70;
 	                this.match(asm8080Parser.EOL);
-	                this.state = 56;
+	                this.state = 75;
 	                this._errHandler.sync(this);
 	                _la = this._input.LA(1);
 	            }
 	        }
 
-	        this.state = 59;
+	        this.state = 78;
 	        this.match(asm8080Parser.EOF);
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
@@ -152,45 +205,71 @@ export default class asm8080Parser extends antlr4.Parser {
 	    this.enterRule(localctx, 2, asm8080Parser.RULE_line);
 	    var _la = 0;
 	    try {
-	        this.state = 76;
+	        this.state = 107;
 	        this._errHandler.sync(this);
-	        var la_ = this._interp.adaptivePredict(this._input,8,this._ctx);
+	        var la_ = this._interp.adaptivePredict(this._input,11,this._ctx);
 	        switch(la_) {
 	        case 1:
 	            this.enterOuterAlt(localctx, 1);
-	            this.state = 62;
+	            this.state = 81;
 	            this._errHandler.sync(this);
-	            var la_ = this._interp.adaptivePredict(this._input,4,this._ctx);
+	            var la_ = this._interp.adaptivePredict(this._input,5,this._ctx);
 	            if(la_===1) {
-	                this.state = 61;
+	                this.state = 80;
 	                this.lbl();
 
 	            }
-	            this.state = 66;
+	            this.state = 86;
 	            this._errHandler.sync(this);
-	            switch(this._input.LA(1)) {
-	            case 12:
-	                this.state = 64;
+	            var la_ = this._interp.adaptivePredict(this._input,6,this._ctx);
+	            switch(la_) {
+	            case 1:
+	                this.state = 83;
 	                this.instruction();
 	                break;
-	            case 7:
-	            case 9:
-	            case 10:
-	            case 11:
-	            case 13:
-	            case 14:
-	            case 16:
-	                this.state = 65;
+
+	            case 2:
+	                this.state = 84;
 	                this.directive();
 	                break;
-	            default:
-	                throw new antlr4.error.NoViableAltException(this);
+
+	            case 3:
+	                this.state = 85;
+	                this.macrocall();
+	                break;
+
 	            }
-	            this.state = 69;
+	            this.state = 96;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
-	            if(_la===15) {
-	                this.state = 68;
+	            while(_la===1) {
+	                this.state = 88;
+	                this.match(asm8080Parser.T__0);
+	                this.state = 92;
+	                this._errHandler.sync(this);
+	                var la_ = this._interp.adaptivePredict(this._input,7,this._ctx);
+	                if(la_===1) {
+	                    this.state = 89;
+	                    this.instruction();
+
+	                } else if(la_===2) {
+	                    this.state = 90;
+	                    this.directive();
+
+	                } else if(la_===3) {
+	                    this.state = 91;
+	                    this.macrocall();
+
+	                }
+	                this.state = 98;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            this.state = 100;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===37) {
+	                this.state = 99;
 	                this.comment();
 	            }
 
@@ -198,13 +277,13 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	        case 2:
 	            this.enterOuterAlt(localctx, 2);
-	            this.state = 71;
+	            this.state = 102;
 	            this.lbl();
-	            this.state = 73;
+	            this.state = 104;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
-	            if(_la===15) {
-	                this.state = 72;
+	            if(_la===37) {
+	                this.state = 103;
 	                this.comment();
 	            }
 
@@ -212,7 +291,7 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	        case 3:
 	            this.enterOuterAlt(localctx, 3);
-	            this.state = 75;
+	            this.state = 106;
 	            this.comment();
 	            break;
 
@@ -239,13 +318,45 @@ export default class asm8080Parser extends antlr4.Parser {
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 78;
+	        this.state = 109;
 	        this.opcode();
-	        this.state = 80;
+	        this.state = 111;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(((((_la - 10)) & ~0x1f) === 0 && ((1 << (_la - 10)) & 394266451) !== 0)) {
+	            this.state = 110;
+	            this.expressionlist();
+	        }
+
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	macrocall() {
+	    let localctx = new MacrocallContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 6, asm8080Parser.RULE_macrocall);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 113;
+	        this.name();
+	        this.state = 115;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 92800) !== 0)) {
-	            this.state = 79;
+	        if(((((_la - 10)) & ~0x1f) === 0 && ((1 << (_la - 10)) & 394266451) !== 0)) {
+	            this.state = 114;
 	            this.expressionlist();
 	        }
 
@@ -267,10 +378,10 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	opcode() {
 	    let localctx = new OpcodeContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 6, asm8080Parser.RULE_opcode);
+	    this.enterRule(localctx, 8, asm8080Parser.RULE_opcode);
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 82;
+	        this.state = 117;
 	        this.match(asm8080Parser.OPCODE);
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
@@ -290,10 +401,10 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	register_() {
 	    let localctx = new Register_Context(this, this._ctx, this.state);
-	    this.enterRule(localctx, 8, asm8080Parser.RULE_register_);
+	    this.enterRule(localctx, 10, asm8080Parser.RULE_register_);
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 84;
+	        this.state = 119;
 	        this.match(asm8080Parser.REGISTER);
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
@@ -313,22 +424,28 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	directive() {
 	    let localctx = new DirectiveContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 10, asm8080Parser.RULE_directive);
+	    this.enterRule(localctx, 12, asm8080Parser.RULE_directive);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 87;
+	        this.state = 122;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 92800) !== 0)) {
-	            this.state = 86;
+	        if(((((_la - 14)) & ~0x1f) === 0 && ((1 << (_la - 14)) & 24641541) !== 0)) {
+	            this.state = 121;
 	            this.argument();
 	        }
 
-	        this.state = 89;
+	        this.state = 124;
 	        this.assemblerdirective();
-	        this.state = 90;
-	        this.expressionlist();
+	        this.state = 126;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if(((((_la - 10)) & ~0x1f) === 0 && ((1 << (_la - 10)) & 394266451) !== 0)) {
+	            this.state = 125;
+	            this.expressionlist();
+	        }
+
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -347,10 +464,10 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	assemblerdirective() {
 	    let localctx = new AssemblerdirectiveContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 12, asm8080Parser.RULE_assemblerdirective);
+	    this.enterRule(localctx, 14, asm8080Parser.RULE_assemblerdirective);
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 92;
+	        this.state = 128;
 	        this.match(asm8080Parser.ASSEMBLER_DIRECTIVE);
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
@@ -370,18 +487,18 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	lbl() {
 	    let localctx = new LblContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 14, asm8080Parser.RULE_lbl);
+	    this.enterRule(localctx, 16, asm8080Parser.RULE_lbl);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 94;
+	        this.state = 130;
 	        this.label();
-	        this.state = 96;
+	        this.state = 132;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        if(_la===1) {
-	            this.state = 95;
-	            this.match(asm8080Parser.T__0);
+	        if(_la===2) {
+	            this.state = 131;
+	            this.match(asm8080Parser.T__1);
 	        }
 
 	    } catch (re) {
@@ -402,21 +519,21 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	expressionlist() {
 	    let localctx = new ExpressionlistContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 16, asm8080Parser.RULE_expressionlist);
+	    this.enterRule(localctx, 18, asm8080Parser.RULE_expressionlist);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 98;
+	        this.state = 134;
 	        this.expression();
-	        this.state = 103;
+	        this.state = 139;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        while(_la===2) {
-	            this.state = 99;
-	            this.match(asm8080Parser.T__1);
-	            this.state = 100;
+	        while(_la===3) {
+	            this.state = 135;
+	            this.match(asm8080Parser.T__2);
+	            this.state = 136;
 	            this.expression();
-	            this.state = 105;
+	            this.state = 141;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	        }
@@ -438,11 +555,29 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	label() {
 	    let localctx = new LabelContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 18, asm8080Parser.RULE_label);
+	    this.enterRule(localctx, 20, asm8080Parser.RULE_label);
 	    try {
-	        this.enterOuterAlt(localctx, 1);
-	        this.state = 106;
-	        this.name();
+	        this.state = 145;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 35:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 142;
+	            this.name();
+	            break;
+	        case 33:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 143;
+	            this.register_();
+	            break;
+	        case 17:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 144;
+	            this.assemblerdirective();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -461,31 +596,29 @@ export default class asm8080Parser extends antlr4.Parser {
 
 	expression() {
 	    let localctx = new ExpressionContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 20, asm8080Parser.RULE_expression);
+	    this.enterRule(localctx, 22, asm8080Parser.RULE_expression);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 108;
-	        this.multiplyingExpression();
-	        this.state = 113;
+	        this.state = 147;
+	        this.orExpression();
+	        this.state = 150;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        while(_la===3 || _la===4) {
-	            this.state = 109;
+	        if(((((_la - 4)) & ~0x1f) === 0 && ((1 << (_la - 4)) & 528482367) !== 0)) {
+	            this.state = 148;
 	            _la = this._input.LA(1);
-	            if(!(_la===3 || _la===4)) {
+	            if(!(((((_la - 4)) & ~0x1f) === 0 && ((1 << (_la - 4)) & 528482367) !== 0))) {
 	            this._errHandler.recoverInline(this);
 	            }
 	            else {
 	            	this._errHandler.reportMatch(this);
 	                this.consume();
 	            }
-	            this.state = 110;
-	            this.multiplyingExpression();
-	            this.state = 115;
-	            this._errHandler.sync(this);
-	            _la = this._input.LA(1);
+	            this.state = 149;
+	            this.orExpression();
 	        }
+
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -502,30 +635,23 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	multiplyingExpression() {
-	    let localctx = new MultiplyingExpressionContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 22, asm8080Parser.RULE_multiplyingExpression);
+	orExpression() {
+	    let localctx = new OrExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 24, asm8080Parser.RULE_orExpression);
 	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 116;
-	        this.argument();
-	        this.state = 121;
+	        this.state = 152;
+	        this.xorExpression();
+	        this.state = 157;
 	        this._errHandler.sync(this);
 	        _la = this._input.LA(1);
-	        while(_la===5 || _la===6) {
-	            this.state = 117;
-	            _la = this._input.LA(1);
-	            if(!(_la===5 || _la===6)) {
-	            this._errHandler.recoverInline(this);
-	            }
-	            else {
-	            	this._errHandler.reportMatch(this);
-	                this.consume();
-	            }
-	            this.state = 118;
-	            this.argument();
-	            this.state = 123;
+	        while(_la===22) {
+	            this.state = 153;
+	            this.match(asm8080Parser.OP_OR);
+	            this.state = 154;
+	            this.xorExpression();
+	            this.state = 159;
 	            this._errHandler.sync(this);
 	            _la = this._input.LA(1);
 	        }
@@ -545,49 +671,25 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	argument() {
-	    let localctx = new ArgumentContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 24, asm8080Parser.RULE_argument);
+	xorExpression() {
+	    let localctx = new XorExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 26, asm8080Parser.RULE_xorExpression);
+	    var _la = 0;
 	    try {
-	        this.state = 133;
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 160;
+	        this.andExpression();
+	        this.state = 165;
 	        this._errHandler.sync(this);
-	        switch(this._input.LA(1)) {
-	        case 14:
-	            this.enterOuterAlt(localctx, 1);
-	            this.state = 124;
-	            this.number();
-	            break;
-	        case 11:
-	            this.enterOuterAlt(localctx, 2);
-	            this.state = 125;
-	            this.register_();
-	            break;
-	        case 9:
-	            this.enterOuterAlt(localctx, 3);
-	            this.state = 126;
-	            this.dollar();
-	            break;
-	        case 13:
-	            this.enterOuterAlt(localctx, 4);
-	            this.state = 127;
-	            this.name();
-	            break;
-	        case 16:
-	            this.enterOuterAlt(localctx, 5);
-	            this.state = 128;
-	            this.string_();
-	            break;
-	        case 7:
-	            this.enterOuterAlt(localctx, 6);
-	            this.state = 129;
-	            this.match(asm8080Parser.T__6);
-	            this.state = 130;
-	            this.expression();
-	            this.state = 131;
-	            this.match(asm8080Parser.T__7);
-	            break;
-	        default:
-	            throw new antlr4.error.NoViableAltException(this);
+	        _la = this._input.LA(1);
+	        while(_la===23) {
+	            this.state = 161;
+	            this.match(asm8080Parser.OP_XOR);
+	            this.state = 162;
+	            this.andExpression();
+	            this.state = 167;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
 	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
@@ -605,13 +707,26 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	dollar() {
-	    let localctx = new DollarContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 26, asm8080Parser.RULE_dollar);
+	andExpression() {
+	    let localctx = new AndExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 28, asm8080Parser.RULE_andExpression);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 135;
-	        this.match(asm8080Parser.T__8);
+	        this.state = 168;
+	        this.addExpression();
+	        this.state = 173;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===21) {
+	            this.state = 169;
+	            this.match(asm8080Parser.OP_AND);
+	            this.state = 170;
+	            this.addExpression();
+	            this.state = 175;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -628,13 +743,33 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	string_() {
-	    let localctx = new String_Context(this, this._ctx, this.state);
-	    this.enterRule(localctx, 28, asm8080Parser.RULE_string_);
+	addExpression() {
+	    let localctx = new AddExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 30, asm8080Parser.RULE_addExpression);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 137;
-	        this.match(asm8080Parser.STRING);
+	        this.state = 176;
+	        this.shiftExpression();
+	        this.state = 181;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===10 || _la===11) {
+	            this.state = 177;
+	            _la = this._input.LA(1);
+	            if(!(_la===10 || _la===11)) {
+	            this._errHandler.recoverInline(this);
+	            }
+	            else {
+	            	this._errHandler.reportMatch(this);
+	                this.consume();
+	            }
+	            this.state = 178;
+	            this.shiftExpression();
+	            this.state = 183;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -651,13 +786,33 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	name() {
-	    let localctx = new NameContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 30, asm8080Parser.RULE_name);
+	shiftExpression() {
+	    let localctx = new ShiftExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 32, asm8080Parser.RULE_shiftExpression);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 139;
-	        this.match(asm8080Parser.NAME);
+	        this.state = 184;
+	        this.modExpression();
+	        this.state = 189;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===24 || _la===25) {
+	            this.state = 185;
+	            _la = this._input.LA(1);
+	            if(!(_la===24 || _la===25)) {
+	            this._errHandler.recoverInline(this);
+	            }
+	            else {
+	            	this._errHandler.reportMatch(this);
+	                this.consume();
+	            }
+	            this.state = 186;
+	            this.modExpression();
+	            this.state = 191;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -674,13 +829,26 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	number() {
-	    let localctx = new NumberContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 32, asm8080Parser.RULE_number);
+	modExpression() {
+	    let localctx = new ModExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 34, asm8080Parser.RULE_modExpression);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 141;
-	        this.match(asm8080Parser.NUMBER);
+	        this.state = 192;
+	        this.multiplyingExpression();
+	        this.state = 197;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===26) {
+	            this.state = 193;
+	            this.match(asm8080Parser.OP_MOD);
+	            this.state = 194;
+	            this.multiplyingExpression();
+	            this.state = 199;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -697,13 +865,33 @@ export default class asm8080Parser extends antlr4.Parser {
 
 
 
-	comment() {
-	    let localctx = new CommentContext(this, this._ctx, this.state);
-	    this.enterRule(localctx, 34, asm8080Parser.RULE_comment);
+	multiplyingExpression() {
+	    let localctx = new MultiplyingExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 36, asm8080Parser.RULE_multiplyingExpression);
+	    var _la = 0;
 	    try {
 	        this.enterOuterAlt(localctx, 1);
-	        this.state = 143;
-	        this.match(asm8080Parser.COMMENT);
+	        this.state = 200;
+	        this.unaryExpression();
+	        this.state = 205;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===12 || _la===13) {
+	            this.state = 201;
+	            _la = this._input.LA(1);
+	            if(!(_la===12 || _la===13)) {
+	            this._errHandler.recoverInline(this);
+	            }
+	            else {
+	            	this._errHandler.reportMatch(this);
+	                this.consume();
+	            }
+	            this.state = 202;
+	            this.unaryExpression();
+	            this.state = 207;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
 	    } catch (re) {
 	    	if(re instanceof antlr4.error.RecognitionException) {
 		        localctx.exception = re;
@@ -719,53 +907,336 @@ export default class asm8080Parser extends antlr4.Parser {
 	}
 
 
-}
 
-asm8080Parser.EOF = antlr4.Token.EOF;
-asm8080Parser.T__0 = 1;
-asm8080Parser.T__1 = 2;
-asm8080Parser.T__2 = 3;
-asm8080Parser.T__3 = 4;
-asm8080Parser.T__4 = 5;
-asm8080Parser.T__5 = 6;
-asm8080Parser.T__6 = 7;
-asm8080Parser.T__7 = 8;
-asm8080Parser.T__8 = 9;
-asm8080Parser.ASSEMBLER_DIRECTIVE = 10;
-asm8080Parser.REGISTER = 11;
-asm8080Parser.OPCODE = 12;
-asm8080Parser.NAME = 13;
-asm8080Parser.NUMBER = 14;
-asm8080Parser.COMMENT = 15;
-asm8080Parser.STRING = 16;
-asm8080Parser.EOL = 17;
-asm8080Parser.WS = 18;
+	unaryExpression() {
+	    let localctx = new UnaryExpressionContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 38, asm8080Parser.RULE_unaryExpression);
+	    try {
+	        this.state = 219;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 18:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 208;
+	            this.match(asm8080Parser.OP_NOT);
+	            this.state = 209;
+	            this.unaryExpression();
+	            break;
+	        case 19:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 210;
+	            this.match(asm8080Parser.OP_HIGH);
+	            this.state = 211;
+	            this.unaryExpression();
+	            break;
+	        case 20:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 212;
+	            this.match(asm8080Parser.OP_LOW);
+	            this.state = 213;
+	            this.unaryExpression();
+	            break;
+	        case 11:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 214;
+	            this.match(asm8080Parser.T__10);
+	            this.state = 215;
+	            this.unaryExpression();
+	            break;
+	        case 10:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 216;
+	            this.match(asm8080Parser.T__9);
+	            this.state = 217;
+	            this.unaryExpression();
+	            break;
+	        case 14:
+	        case 16:
+	        case 33:
+	        case 34:
+	        case 35:
+	        case 36:
+	        case 38:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 218;
+	            this.argument();
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
 
-asm8080Parser.RULE_prog = 0;
-asm8080Parser.RULE_line = 1;
-asm8080Parser.RULE_instruction = 2;
-asm8080Parser.RULE_opcode = 3;
-asm8080Parser.RULE_register_ = 4;
-asm8080Parser.RULE_directive = 5;
-asm8080Parser.RULE_assemblerdirective = 6;
-asm8080Parser.RULE_lbl = 7;
-asm8080Parser.RULE_expressionlist = 8;
-asm8080Parser.RULE_label = 9;
-asm8080Parser.RULE_expression = 10;
-asm8080Parser.RULE_multiplyingExpression = 11;
-asm8080Parser.RULE_argument = 12;
-asm8080Parser.RULE_dollar = 13;
-asm8080Parser.RULE_string_ = 14;
-asm8080Parser.RULE_name = 15;
-asm8080Parser.RULE_number = 16;
-asm8080Parser.RULE_comment = 17;
 
-class ProgContext extends antlr4.ParserRuleContext {
 
-    constructor(parser, parent, invokingState) {
-        if(parent===undefined) {
-            parent = null;
-        }
+	argument() {
+	    let localctx = new ArgumentContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 40, asm8080Parser.RULE_argument);
+	    try {
+	        this.state = 231;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 36:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 221;
+	            this.number();
+	            break;
+	        case 34:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 222;
+	            this.opcode();
+	            break;
+	        case 33:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 223;
+	            this.register_();
+	            break;
+	        case 16:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 224;
+	            this.dollar();
+	            break;
+	        case 35:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 225;
+	            this.name();
+	            break;
+	        case 38:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 226;
+	            this.string_();
+	            break;
+	        case 14:
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 227;
+	            this.match(asm8080Parser.T__13);
+	            this.state = 228;
+	            this.expression();
+	            this.state = 229;
+	            this.match(asm8080Parser.T__14);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	dollar() {
+	    let localctx = new DollarContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 42, asm8080Parser.RULE_dollar);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 233;
+	        this.match(asm8080Parser.T__15);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	string_() {
+	    let localctx = new String_Context(this, this._ctx, this.state);
+	    this.enterRule(localctx, 44, asm8080Parser.RULE_string_);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 235;
+	        this.match(asm8080Parser.STRING);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	name() {
+	    let localctx = new NameContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 46, asm8080Parser.RULE_name);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 237;
+	        this.match(asm8080Parser.NAME);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	number() {
+	    let localctx = new NumberContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 48, asm8080Parser.RULE_number);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 239;
+	        this.match(asm8080Parser.NUMBER);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	comment() {
+	    let localctx = new CommentContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 50, asm8080Parser.RULE_comment);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 241;
+	        this.match(asm8080Parser.COMMENT);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+}
+
+asm8080Parser.EOF = antlr4.Token.EOF;
+asm8080Parser.T__0 = 1;
+asm8080Parser.T__1 = 2;
+asm8080Parser.T__2 = 3;
+asm8080Parser.T__3 = 4;
+asm8080Parser.T__4 = 5;
+asm8080Parser.T__5 = 6;
+asm8080Parser.T__6 = 7;
+asm8080Parser.T__7 = 8;
+asm8080Parser.T__8 = 9;
+asm8080Parser.T__9 = 10;
+asm8080Parser.T__10 = 11;
+asm8080Parser.T__11 = 12;
+asm8080Parser.T__12 = 13;
+asm8080Parser.T__13 = 14;
+asm8080Parser.T__14 = 15;
+asm8080Parser.T__15 = 16;
+asm8080Parser.ASSEMBLER_DIRECTIVE = 17;
+asm8080Parser.OP_NOT = 18;
+asm8080Parser.OP_HIGH = 19;
+asm8080Parser.OP_LOW = 20;
+asm8080Parser.OP_AND = 21;
+asm8080Parser.OP_OR = 22;
+asm8080Parser.OP_XOR = 23;
+asm8080Parser.OP_SHL = 24;
+asm8080Parser.OP_SHR = 25;
+asm8080Parser.OP_MOD = 26;
+asm8080Parser.OP_GT = 27;
+asm8080Parser.OP_LT = 28;
+asm8080Parser.OP_GE = 29;
+asm8080Parser.OP_LE = 30;
+asm8080Parser.OP_NE = 31;
+asm8080Parser.OP_EQ = 32;
+asm8080Parser.REGISTER = 33;
+asm8080Parser.OPCODE = 34;
+asm8080Parser.NAME = 35;
+asm8080Parser.NUMBER = 36;
+asm8080Parser.COMMENT = 37;
+asm8080Parser.STRING = 38;
+asm8080Parser.EOL = 39;
+asm8080Parser.WS = 40;
+asm8080Parser.ARTIFACT = 41;
+
+asm8080Parser.RULE_prog = 0;
+asm8080Parser.RULE_line = 1;
+asm8080Parser.RULE_instruction = 2;
+asm8080Parser.RULE_macrocall = 3;
+asm8080Parser.RULE_opcode = 4;
+asm8080Parser.RULE_register_ = 5;
+asm8080Parser.RULE_directive = 6;
+asm8080Parser.RULE_assemblerdirective = 7;
+asm8080Parser.RULE_lbl = 8;
+asm8080Parser.RULE_expressionlist = 9;
+asm8080Parser.RULE_label = 10;
+asm8080Parser.RULE_expression = 11;
+asm8080Parser.RULE_orExpression = 12;
+asm8080Parser.RULE_xorExpression = 13;
+asm8080Parser.RULE_andExpression = 14;
+asm8080Parser.RULE_addExpression = 15;
+asm8080Parser.RULE_shiftExpression = 16;
+asm8080Parser.RULE_modExpression = 17;
+asm8080Parser.RULE_multiplyingExpression = 18;
+asm8080Parser.RULE_unaryExpression = 19;
+asm8080Parser.RULE_argument = 20;
+asm8080Parser.RULE_dollar = 21;
+asm8080Parser.RULE_string_ = 22;
+asm8080Parser.RULE_name = 23;
+asm8080Parser.RULE_number = 24;
+asm8080Parser.RULE_comment = 25;
+
+class ProgContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
         if(invokingState===undefined || invokingState===null) {
             invokingState = -1;
         }
@@ -840,12 +1311,37 @@ class LineContext extends antlr4.ParserRuleContext {
         this.ruleIndex = asm8080Parser.RULE_line;
     }
 
-	instruction() {
-	    return this.getTypedRuleContext(InstructionContext,0);
+	instruction = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(InstructionContext);
+	    } else {
+	        return this.getTypedRuleContext(InstructionContext,i);
+	    }
 	};
 
-	directive() {
-	    return this.getTypedRuleContext(DirectiveContext,0);
+	directive = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(DirectiveContext);
+	    } else {
+	        return this.getTypedRuleContext(DirectiveContext,i);
+	    }
+	};
+
+	macrocall = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(MacrocallContext);
+	    } else {
+	        return this.getTypedRuleContext(MacrocallContext,i);
+	    }
 	};
 
 	lbl() {
@@ -928,6 +1424,53 @@ class InstructionContext extends antlr4.ParserRuleContext {
 
 
 
+class MacrocallContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_macrocall;
+    }
+
+	name() {
+	    return this.getTypedRuleContext(NameContext,0);
+	};
+
+	expressionlist() {
+	    return this.getTypedRuleContext(ExpressionlistContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterMacrocall(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitMacrocall(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitMacrocall(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
 class OpcodeContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
@@ -1032,14 +1575,14 @@ class DirectiveContext extends antlr4.ParserRuleContext {
 	    return this.getTypedRuleContext(AssemblerdirectiveContext,0);
 	};
 
-	expressionlist() {
-	    return this.getTypedRuleContext(ExpressionlistContext,0);
-	};
-
 	argument() {
 	    return this.getTypedRuleContext(ArgumentContext,0);
 	};
 
+	expressionlist() {
+	    return this.getTypedRuleContext(ExpressionlistContext,0);
+	};
+
 	enterRule(listener) {
 	    if(listener instanceof asm8080Listener ) {
 	        listener.enterDirective(this);
@@ -1219,6 +1762,14 @@ class LabelContext extends antlr4.ParserRuleContext {
 	    return this.getTypedRuleContext(NameContext,0);
 	};
 
+	register_() {
+	    return this.getTypedRuleContext(Register_Context,0);
+	};
+
+	assemblerdirective() {
+	    return this.getTypedRuleContext(AssemblerdirectiveContext,0);
+	};
+
 	enterRule(listener) {
 	    if(listener instanceof asm8080Listener ) {
 	        listener.enterLabel(this);
@@ -1258,19 +1809,43 @@ class ExpressionContext extends antlr4.ParserRuleContext {
         this.ruleIndex = asm8080Parser.RULE_expression;
     }
 
-	multiplyingExpression = function(i) {
+	orExpression = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(MultiplyingExpressionContext);
+	        return this.getTypedRuleContexts(OrExpressionContext);
 	    } else {
-	        return this.getTypedRuleContext(MultiplyingExpressionContext,i);
+	        return this.getTypedRuleContext(OrExpressionContext,i);
 	    }
 	};
 
-	enterRule(listener) {
-	    if(listener instanceof asm8080Listener ) {
+	OP_GT() {
+	    return this.getToken(asm8080Parser.OP_GT, 0);
+	};
+
+	OP_LT() {
+	    return this.getToken(asm8080Parser.OP_LT, 0);
+	};
+
+	OP_GE() {
+	    return this.getToken(asm8080Parser.OP_GE, 0);
+	};
+
+	OP_LE() {
+	    return this.getToken(asm8080Parser.OP_LE, 0);
+	};
+
+	OP_NE() {
+	    return this.getToken(asm8080Parser.OP_NE, 0);
+	};
+
+	OP_EQ() {
+	    return this.getToken(asm8080Parser.OP_EQ, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
 	        listener.enterExpression(this);
 		}
 	}
@@ -1294,6 +1869,378 @@ class ExpressionContext extends antlr4.ParserRuleContext {
 
 
 
+class OrExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_orExpression;
+    }
+
+	xorExpression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(XorExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(XorExpressionContext,i);
+	    }
+	};
+
+	OP_OR = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(asm8080Parser.OP_OR);
+	    } else {
+	        return this.getToken(asm8080Parser.OP_OR, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterOrExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitOrExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitOrExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class XorExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_xorExpression;
+    }
+
+	andExpression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(AndExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(AndExpressionContext,i);
+	    }
+	};
+
+	OP_XOR = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(asm8080Parser.OP_XOR);
+	    } else {
+	        return this.getToken(asm8080Parser.OP_XOR, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterXorExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitXorExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitXorExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class AndExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_andExpression;
+    }
+
+	addExpression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(AddExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(AddExpressionContext,i);
+	    }
+	};
+
+	OP_AND = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(asm8080Parser.OP_AND);
+	    } else {
+	        return this.getToken(asm8080Parser.OP_AND, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterAndExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitAndExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitAndExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class AddExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_addExpression;
+    }
+
+	shiftExpression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ShiftExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ShiftExpressionContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterAddExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitAddExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitAddExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ShiftExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_shiftExpression;
+    }
+
+	modExpression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ModExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ModExpressionContext,i);
+	    }
+	};
+
+	OP_SHL = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(asm8080Parser.OP_SHL);
+	    } else {
+	        return this.getToken(asm8080Parser.OP_SHL, i);
+	    }
+	};
+
+
+	OP_SHR = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(asm8080Parser.OP_SHR);
+	    } else {
+	        return this.getToken(asm8080Parser.OP_SHR, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterShiftExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitShiftExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitShiftExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ModExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_modExpression;
+    }
+
+	multiplyingExpression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(MultiplyingExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(MultiplyingExpressionContext,i);
+	    }
+	};
+
+	OP_MOD = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(asm8080Parser.OP_MOD);
+	    } else {
+	        return this.getToken(asm8080Parser.OP_MOD, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterModExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitModExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitModExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
 class MultiplyingExpressionContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
@@ -1308,14 +2255,14 @@ class MultiplyingExpressionContext extends antlr4.ParserRuleContext {
         this.ruleIndex = asm8080Parser.RULE_multiplyingExpression;
     }
 
-	argument = function(i) {
+	unaryExpression = function(i) {
 	    if(i===undefined) {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(ArgumentContext);
+	        return this.getTypedRuleContexts(UnaryExpressionContext);
 	    } else {
-	        return this.getTypedRuleContext(ArgumentContext,i);
+	        return this.getTypedRuleContext(UnaryExpressionContext,i);
 	    }
 	};
 
@@ -1344,6 +2291,65 @@ class MultiplyingExpressionContext extends antlr4.ParserRuleContext {
 
 
 
+class UnaryExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = asm8080Parser.RULE_unaryExpression;
+    }
+
+	OP_NOT() {
+	    return this.getToken(asm8080Parser.OP_NOT, 0);
+	};
+
+	unaryExpression() {
+	    return this.getTypedRuleContext(UnaryExpressionContext,0);
+	};
+
+	OP_HIGH() {
+	    return this.getToken(asm8080Parser.OP_HIGH, 0);
+	};
+
+	OP_LOW() {
+	    return this.getToken(asm8080Parser.OP_LOW, 0);
+	};
+
+	argument() {
+	    return this.getTypedRuleContext(ArgumentContext,0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.enterUnaryExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof asm8080Listener ) {
+	        listener.exitUnaryExpression(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof asm8080Visitor ) {
+	        return visitor.visitUnaryExpression(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
 class ArgumentContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
@@ -1362,6 +2368,10 @@ class ArgumentContext extends antlr4.ParserRuleContext {
 	    return this.getTypedRuleContext(NumberContext,0);
 	};
 
+	opcode() {
+	    return this.getTypedRuleContext(OpcodeContext,0);
+	};
+
 	register_() {
 	    return this.getTypedRuleContext(Register_Context,0);
 	};
@@ -1623,6 +2633,7 @@ class CommentContext extends antlr4.ParserRuleContext {
 asm8080Parser.ProgContext = ProgContext; 
 asm8080Parser.LineContext = LineContext; 
 asm8080Parser.InstructionContext = InstructionContext; 
+asm8080Parser.MacrocallContext = MacrocallContext; 
 asm8080Parser.OpcodeContext = OpcodeContext; 
 asm8080Parser.Register_Context = Register_Context; 
 asm8080Parser.DirectiveContext = DirectiveContext; 
@@ -1631,7 +2642,14 @@ asm8080Parser.LblContext = LblContext;
 asm8080Parser.ExpressionlistContext = ExpressionlistContext; 
 asm8080Parser.LabelContext = LabelContext; 
 asm8080Parser.ExpressionContext = ExpressionContext; 
+asm8080Parser.OrExpressionContext = OrExpressionContext; 
+asm8080Parser.XorExpressionContext = XorExpressionContext; 
+asm8080Parser.AndExpressionContext = AndExpressionContext; 
+asm8080Parser.AddExpressionContext = AddExpressionContext; 
+asm8080Parser.ShiftExpressionContext = ShiftExpressionContext; 
+asm8080Parser.ModExpressionContext = ModExpressionContext; 
 asm8080Parser.MultiplyingExpressionContext = MultiplyingExpressionContext; 
+asm8080Parser.UnaryExpressionContext = UnaryExpressionContext; 
 asm8080Parser.ArgumentContext = ArgumentContext; 
 asm8080Parser.DollarContext = DollarContext; 
 asm8080Parser.String_Context = String_Context;