have est

.gitattributes

@@ -1 +0,0 @@
-qt_ui/ filter=lfs diff=lfs merge=lfs -text

CMakeLists.txt

@@ -12,7 +12,6 @@ enable_testing()
 # library in subdirectory
 add_subdirectory(3rd)
 add_subdirectory(src)
-# add_subdirectory(test)
 
 
 # excutable

README.md

@@ -1,101 +1,22 @@
-# 所以你★star★了吗！！！
+# 环境
-# millet porridge III --stage3
+- x86 Debian GNU/Linux 12
+- Python 3.11.2
+- gcc version 12.2.2
+- openJDK version "17.0.12"
+- NASM version 2.16.01
+- antlr complete & runtime Version: 4.9.3
 
-```
+# 执行
-package main
-
-var a int=1;
-
-func add1(x,y int) (int, int) {
-	x = x + 1
-	y = y + 1
-	return x,y
-}
-
-func main() {
-	var a int;
-	var b int = 4-(2+4-4)+3;
-	a=0;
-	if a < 20 {
-	a = 2;
-	} else {
-	if a < 10 {
-	a = 1;
-	} else {
-	a = 3;
-	}
-	}
-    for i := 0; i <= 10; i++ {
-                a = i;
-    }
-	a,b=add1(a,b)
-	a,b=add1(1,2)
-	// var
-}
-```
-
-```
-   9 Operater:        ADD src1:    IMM:      2      src2:   IMM:      4      dst:    VAR:     T8
-  10 Operater:        SUB src1:    VAR:     T8      src2:   IMM:      4      dst:    VAR:    T10
-  11 Operater:        SUB src1:    IMM:      4      src2:   VAR:    T10      dst:    VAR:    T11
-  12 Operater:        ADD src1:    VAR:    T11      src2:   IMM:      3      dst:    VAR:    T13
-  13 Operater:     ASSIGN src1:    VAR:    T13      src2: NULL_:             dst:    VAR:      b
-  14 Operater:     ASSIGN src1:    IMM:      0      src2: NULL_:             dst:    VAR:      a
-  15 Operater:       IFGE src1:    VAR:      a      src2:   IMM:     20      dst:    VAR:  ELSE0
-  16 Operater:     ASSIGN src1:    IMM:      2      src2: NULL_:             dst:    VAR:      a
-  17 Operater:       GOTO src1:  NULL_: ENDIF0      src2: NULL_:             dst:  NULL_:       
-  18 Operater:      LABEL src1:  NULL_:  ELSE0      src2: NULL_:             dst:  NULL_:       
-  19 Operater:       IFGE src1:    VAR:      a      src2:   IMM:     10      dst:    VAR:  ELSE1
-  20 Operater:     ASSIGN src1:    IMM:      1      src2: NULL_:             dst:    VAR:      a
-  21 Operater:       GOTO src1:  NULL_: ENDIF1      src2: NULL_:             dst:  NULL_:       
-  22 Operater:      LABEL src1:  NULL_:  ELSE1      src2: NULL_:             dst:  NULL_:       
-  23 Operater:     ASSIGN src1:    IMM:      3      src2: NULL_:             dst:    VAR:      a
-  24 Operater:      LABEL src1:  NULL_: ENDIF1      src2: NULL_:             dst:  NULL_:       
-  25 Operater:      LABEL src1:  NULL_: ENDIF0      src2: NULL_:             dst:  NULL_:       
-  26 Operater:     ASSIGN src1:    IMM:      0      src2: NULL_:             dst:    VAR:      i
-  27 Operater:       IFGT src1:    VAR:      i      src2:   IMM:     10      dst:    VAR:ENDFOR0
-  28 Operater:      LABEL src1:  NULL_:FORLOOP0      src2: NULL_:             dst:  NULL_:       
-  29 Operater:     ASSIGN src1:    VAR:      i      src2: NULL_:             dst:    VAR:      a
-  30 Operater:        ADD src1:    VAR:      i      src2:   IMM:      1      dst:    VAR:      i
-  31 Operater:       IFLE src1:    VAR:      i      src2:   IMM:     10      dst:    VAR:FORLOOP0
-  32 Operater:      LABEL src1:  NULL_:ENDFOR0      src2: NULL_:             dst:  NULL_:       
-  33 Operater:        RET src1:    VAR:    T22      src2: NULL_:             dst:  NULL_:       
-  34 Operater:        RET src1:    VAR:    T23      src2: NULL_:             dst:  NULL_:       
-  35 Operater:       PARA src1:    VAR:      a      src2: NULL_:             dst:  NULL_:       
-  36 Operater:       PARA src1:    VAR:      b      src2: NULL_:             dst:  NULL_:       
-  37 Operater:       CALL src1:    VAR:   add1      src2: NULL_:             dst:  NULL_:       
-  38 Operater:     ASSIGN src1:    VAR:    T22      src2: NULL_:             dst:    VAR:      a
-  39 Operater:     ASSIGN src1:    VAR:    T23      src2: NULL_:             dst:    VAR:      b
-  40 Operater:        RET src1:    VAR:    T26      src2: NULL_:             dst:  NULL_:       
-  41 Operater:        RET src1:    VAR:    T27      src2: NULL_:             dst:  NULL_:       
-  42 Operater:       PARA src1:    IMM:      1      src2: NULL_:             dst:  NULL_:       
-  43 Operater:       PARA src1:    IMM:      2      src2: NULL_:             dst:  NULL_:       
-  44 Operater:       CALL src1:    VAR:   add1      src2: NULL_:             dst:  NULL_:       
-  45 Operater:     ASSIGN src1:    VAR:    T26      src2: NULL_:             dst:    VAR:      a
-  46 Operater:     ASSIGN src1:    VAR:    T27      src2: NULL_:             dst:    VAR:      b
-----------------------
-   1 Operater:   FUN_PARA src1:    VAR:      x      src2: NULL_:             dst:  NULL_:       
-   2 Operater:   FUN_PARA src1:    VAR:      y      src2: NULL_:             dst:  NULL_:       
-   3 Operater:        ADD src1:    VAR:      x      src2:   IMM:      1      dst:    VAR:     T2
-   4 Operater:     ASSIGN src1:    VAR:     T2      src2: NULL_:             dst:    VAR:      x
-   5 Operater:        ADD src1:    VAR:      y      src2:   IMM:      1      dst:    VAR:     T4
-   6 Operater:     ASSIGN src1:    VAR:     T4      src2: NULL_:             dst:    VAR:      y
-   7 Operater:    FUN_RET src1:    VAR:      x      src2: NULL_:             dst:  NULL_:       
-   8 Operater:    FUN_RET src1:    VAR:      y      src2: NULL_:             dst:  NULL_:       
-----------------------
-   0 Operater:     ASSIGN src1:    IMM:      1      src2: NULL_:             dst:    VAR:      a
-----------------------
-```
-
-生成汇编：
 
 ```shell
-./tjugo ../example/<A>.go
+bash runme.sh
 ```
 
-运行汇编：
+参数说明：
+1. -d (--dir):       [default: ./ ]            输出文件路径
+2. -3 (--3code):     [default: 3code.txt]    输出 3code 文件名
+3. -a (--asm):       [default: out]          输出 asm 文件名
+4. -b (--bin):       [default: bin]          输出 bin 文件名
 
-```shell
-. ../scripts/run_asm.sh <A>
-```
 
+# 文件结构

grammar/calculate.go

@@ -1,34 +0,0 @@
-package main
-
-var a int=1;
-
-func add1(x,y int) (int, int) {
-	x = x + 1
-	y = y + 1
-	return x,y
-}
-
-func main() {
-	var a int;
-	var b int = 4-(2+4-4)+3;
-	a=0;
-	a++;
-	if a < 20 {
-		a = 2;
-	} else {
-		a = 3;
-	}
-
-    for i := 0; i <= 10; i++ {
-        a = i;
-    }
-	a,b=add1(a,b)
-	a,b=add1(1,2)
-
-	var array [5]int
-
-	for i := 0; i <= 4; i++ {
-        array[i] = i;
-        a= i;
-    }
-}

grammar/cpp/GoLexer.h

@@ -0,0 +1,77 @@
+
+// Generated from /workspace/millet-porridge-III/grammar/GoLexer.g4 by ANTLR 4.9.3
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+
+
+
+
+class  GoLexer : public antlr4::Lexer {
+public:
+  enum {
+    BREAK = 1, DEFAULT = 2, FUNC = 3, INTERFACE = 4, SELECT = 5, CASE = 6, 
+    DEFER = 7, GO = 8, MAP = 9, STRUCT = 10, CHAN = 11, ELSE = 12, GOTO = 13, 
+    PACKAGE = 14, SWITCH = 15, CONST = 16, FALLTHROUGH = 17, IF = 18, RANGE = 19, 
+    TYPE = 20, CONTINUE = 21, FOR = 22, IMPORT = 23, RETURN = 24, VAR = 25, 
+    NIL_LIT = 26, IDENTIFIER = 27, L_PAREN = 28, R_PAREN = 29, L_CURLY = 30, 
+    R_CURLY = 31, L_BRACKET = 32, R_BRACKET = 33, ASSIGN = 34, COMMA = 35, 
+    SEMI = 36, HUANHANG = 37, HUANHANGG = 38, COLON = 39, DOT = 40, PLUS_PLUS = 41, 
+    MINUS_MINUS = 42, DECLARE_ASSIGN = 43, ELLIPSIS = 44, EOSSS = 45, LOGICAL_OR = 46, 
+    LOGICAL_AND = 47, EQUALS = 48, NOT_EQUALS = 49, LESS = 50, LESS_OR_EQUALS = 51, 
+    GREATER = 52, GREATER_OR_EQUALS = 53, OR = 54, DIV = 55, MOD = 56, LSHIFT = 57, 
+    RSHIFT = 58, BIT_CLEAR = 59, EXCLAMATION = 60, PLUS = 61, MINUS = 62, 
+    CARET = 63, STAR = 64, AMPERSAND = 65, RECEIVE = 66, DECIMAL_LIT = 67, 
+    BINARY_LIT = 68, OCTAL_LIT = 69, HEX_LIT = 70, FLOAT_LIT = 71, DECIMAL_FLOAT_LIT = 72, 
+    HEX_FLOAT_LIT = 73, IMAGINARY_LIT = 74, RUNE_LIT = 75, BYTE_VALUE = 76, 
+    OCTAL_BYTE_VALUE = 77, HEX_BYTE_VALUE = 78, LITTLE_U_VALUE = 79, BIG_U_VALUE = 80, 
+    RAW_STRING_LIT = 81, INTERPRETED_STRING_LIT = 82, WS = 83, COMMENT = 84, 
+    TERMINATOR = 85, LINE_COMMENT = 86, WS_NLSEMI = 87, COMMENT_NLSEMI = 88, 
+    LINE_COMMENT_NLSEMI = 89
+  };
+
+  enum {
+    NLSEMI = 1
+  };
+
+  explicit GoLexer(antlr4::CharStream *input);
+  ~GoLexer();
+
+  virtual std::string getGrammarFileName() const override;
+  virtual const std::vector<std::string>& getRuleNames() const override;
+
+  virtual const std::vector<std::string>& getChannelNames() const override;
+  virtual const std::vector<std::string>& getModeNames() const override;
+  virtual const std::vector<std::string>& getTokenNames() const override; // deprecated, use vocabulary instead
+  virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
+
+  virtual const std::vector<uint16_t> getSerializedATN() const override;
+  virtual const antlr4::atn::ATN& getATN() const override;
+
+private:
+  static std::vector<antlr4::dfa::DFA> _decisionToDFA;
+  static antlr4::atn::PredictionContextCache _sharedContextCache;
+  static std::vector<std::string> _ruleNames;
+  static std::vector<std::string> _tokenNames;
+  static std::vector<std::string> _channelNames;
+  static std::vector<std::string> _modeNames;
+
+  static std::vector<std::string> _literalNames;
+  static std::vector<std::string> _symbolicNames;
+  static antlr4::dfa::Vocabulary _vocabulary;
+  static antlr4::atn::ATN _atn;
+  static std::vector<uint16_t> _serializedATN;
+
+
+  // Individual action functions triggered by action() above.
+
+  // Individual semantic predicate functions triggered by sempred() above.
+
+  struct Initializer {
+    Initializer();
+  };
+  static Initializer _init;
+};
+

grammar/cpp/GoLexer.tokens

@@ -0,0 +1,153 @@
+BREAK=1
+DEFAULT=2
+FUNC=3
+INTERFACE=4
+SELECT=5
+CASE=6
+DEFER=7
+GO=8
+MAP=9
+STRUCT=10
+CHAN=11
+ELSE=12
+GOTO=13
+PACKAGE=14
+SWITCH=15
+CONST=16
+FALLTHROUGH=17
+IF=18
+RANGE=19
+TYPE=20
+CONTINUE=21
+FOR=22
+IMPORT=23
+RETURN=24
+VAR=25
+NIL_LIT=26
+IDENTIFIER=27
+L_PAREN=28
+R_PAREN=29
+L_CURLY=30
+R_CURLY=31
+L_BRACKET=32
+R_BRACKET=33
+ASSIGN=34
+COMMA=35
+SEMI=36
+HUANHANG=37
+HUANHANGG=38
+COLON=39
+DOT=40
+PLUS_PLUS=41
+MINUS_MINUS=42
+DECLARE_ASSIGN=43
+ELLIPSIS=44
+EOSSS=45
+LOGICAL_OR=46
+LOGICAL_AND=47
+EQUALS=48
+NOT_EQUALS=49
+LESS=50
+LESS_OR_EQUALS=51
+GREATER=52
+GREATER_OR_EQUALS=53
+OR=54
+DIV=55
+MOD=56
+LSHIFT=57
+RSHIFT=58
+BIT_CLEAR=59
+EXCLAMATION=60
+PLUS=61
+MINUS=62
+CARET=63
+STAR=64
+AMPERSAND=65
+RECEIVE=66
+DECIMAL_LIT=67
+BINARY_LIT=68
+OCTAL_LIT=69
+HEX_LIT=70
+FLOAT_LIT=71
+DECIMAL_FLOAT_LIT=72
+HEX_FLOAT_LIT=73
+IMAGINARY_LIT=74
+RUNE_LIT=75
+BYTE_VALUE=76
+OCTAL_BYTE_VALUE=77
+HEX_BYTE_VALUE=78
+LITTLE_U_VALUE=79
+BIG_U_VALUE=80
+RAW_STRING_LIT=81
+INTERPRETED_STRING_LIT=82
+WS=83
+COMMENT=84
+TERMINATOR=85
+LINE_COMMENT=86
+WS_NLSEMI=87
+COMMENT_NLSEMI=88
+LINE_COMMENT_NLSEMI=89
+'break'=1
+'default'=2
+'func'=3
+'interface'=4
+'select'=5
+'case'=6
+'defer'=7
+'go'=8
+'map'=9
+'struct'=10
+'chan'=11
+'else'=12
+'goto'=13
+'package'=14
+'switch'=15
+'const'=16
+'fallthrough'=17
+'if'=18
+'range'=19
+'type'=20
+'continue'=21
+'for'=22
+'import'=23
+'return'=24
+'var'=25
+'nil'=26
+'('=28
+')'=29
+'{'=30
+'}'=31
+'['=32
+']'=33
+'='=34
+','=35
+';'=36
+'\n'=37
+'\r\n'=38
+':'=39
+'.'=40
+'++'=41
+'--'=42
+':='=43
+'...'=44
+'||'=46
+'&&'=47
+'=='=48
+'!='=49
+'<'=50
+'<='=51
+'>'=52
+'>='=53
+'|'=54
+'/'=55
+'%'=56
+'<<'=57
+'>>'=58
+'&^'=59
+'!'=60
+'+'=61
+'-'=62
+'^'=63
+'*'=64
+'&'=65
+'<-'=66

grammar/cpp/GoParser.tokens

@@ -0,0 +1,153 @@
+BREAK=1
+DEFAULT=2
+FUNC=3
+INTERFACE=4
+SELECT=5
+CASE=6
+DEFER=7
+GO=8
+MAP=9
+STRUCT=10
+CHAN=11
+ELSE=12
+GOTO=13
+PACKAGE=14
+SWITCH=15
+CONST=16
+FALLTHROUGH=17
+IF=18
+RANGE=19
+TYPE=20
+CONTINUE=21
+FOR=22
+IMPORT=23
+RETURN=24
+VAR=25
+NIL_LIT=26
+IDENTIFIER=27
+L_PAREN=28
+R_PAREN=29
+L_CURLY=30
+R_CURLY=31
+L_BRACKET=32
+R_BRACKET=33
+ASSIGN=34
+COMMA=35
+SEMI=36
+HUANHANG=37
+HUANHANGG=38
+COLON=39
+DOT=40
+PLUS_PLUS=41
+MINUS_MINUS=42
+DECLARE_ASSIGN=43
+ELLIPSIS=44
+EOSSS=45
+LOGICAL_OR=46
+LOGICAL_AND=47
+EQUALS=48
+NOT_EQUALS=49
+LESS=50
+LESS_OR_EQUALS=51
+GREATER=52
+GREATER_OR_EQUALS=53
+OR=54
+DIV=55
+MOD=56
+LSHIFT=57
+RSHIFT=58
+BIT_CLEAR=59
+EXCLAMATION=60
+PLUS=61
+MINUS=62
+CARET=63
+STAR=64
+AMPERSAND=65
+RECEIVE=66
+DECIMAL_LIT=67
+BINARY_LIT=68
+OCTAL_LIT=69
+HEX_LIT=70
+FLOAT_LIT=71
+DECIMAL_FLOAT_LIT=72
+HEX_FLOAT_LIT=73
+IMAGINARY_LIT=74
+RUNE_LIT=75
+BYTE_VALUE=76
+OCTAL_BYTE_VALUE=77
+HEX_BYTE_VALUE=78
+LITTLE_U_VALUE=79
+BIG_U_VALUE=80
+RAW_STRING_LIT=81
+INTERPRETED_STRING_LIT=82
+WS=83
+COMMENT=84
+TERMINATOR=85
+LINE_COMMENT=86
+WS_NLSEMI=87
+COMMENT_NLSEMI=88
+LINE_COMMENT_NLSEMI=89
+'break'=1
+'default'=2
+'func'=3
+'interface'=4
+'select'=5
+'case'=6
+'defer'=7
+'go'=8
+'map'=9
+'struct'=10
+'chan'=11
+'else'=12
+'goto'=13
+'package'=14
+'switch'=15
+'const'=16
+'fallthrough'=17
+'if'=18
+'range'=19
+'type'=20
+'continue'=21
+'for'=22
+'import'=23
+'return'=24
+'var'=25
+'nil'=26
+'('=28
+')'=29
+'{'=30
+'}'=31
+'['=32
+']'=33
+'='=34
+','=35
+';'=36
+'\n'=37
+'\r\n'=38
+':'=39
+'.'=40
+'++'=41
+'--'=42
+':='=43
+'...'=44
+'||'=46
+'&&'=47
+'=='=48
+'!='=49
+'<'=50
+'<='=51
+'>'=52
+'>='=53
+'|'=54
+'/'=55
+'%'=56
+'<<'=57
+'>>'=58
+'&^'=59
+'!'=60
+'+'=61
+'-'=62
+'^'=63
+'*'=64
+'&'=65
+'<-'=66

grammar/cpp/GoParserBaseListener.cpp

@@ -0,0 +1,7 @@
+
+// Generated from /workspace/millet-porridge-III/grammar/GoParser.g4 by ANTLR 4.9.3
+
+
+#include "GoParserBaseListener.h"
+
+

grammar/cpp/GoParserBaseListener.h

@@ -0,0 +1,341 @@
+
+// Generated from /workspace/millet-porridge-III/grammar/GoParser.g4 by ANTLR 4.9.3
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "GoParserListener.h"
+
+
+/**
+ * This class provides an empty implementation of GoParserListener,
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+class  GoParserBaseListener : public GoParserListener {
+public:
+
+  virtual void enterSourceFile(GoParser::SourceFileContext * /*ctx*/) override { }
+  virtual void exitSourceFile(GoParser::SourceFileContext * /*ctx*/) override { }
+
+  virtual void enterPackageClause(GoParser::PackageClauseContext * /*ctx*/) override { }
+  virtual void exitPackageClause(GoParser::PackageClauseContext * /*ctx*/) override { }
+
+  virtual void enterImportDecl(GoParser::ImportDeclContext * /*ctx*/) override { }
+  virtual void exitImportDecl(GoParser::ImportDeclContext * /*ctx*/) override { }
+
+  virtual void enterImportSpec(GoParser::ImportSpecContext * /*ctx*/) override { }
+  virtual void exitImportSpec(GoParser::ImportSpecContext * /*ctx*/) override { }
+
+  virtual void enterImportPath(GoParser::ImportPathContext * /*ctx*/) override { }
+  virtual void exitImportPath(GoParser::ImportPathContext * /*ctx*/) override { }
+
+  virtual void enterDeclaration(GoParser::DeclarationContext * /*ctx*/) override { }
+  virtual void exitDeclaration(GoParser::DeclarationContext * /*ctx*/) override { }
+
+  virtual void enterConstDecl(GoParser::ConstDeclContext * /*ctx*/) override { }
+  virtual void exitConstDecl(GoParser::ConstDeclContext * /*ctx*/) override { }
+
+  virtual void enterConstSpec(GoParser::ConstSpecContext * /*ctx*/) override { }
+  virtual void exitConstSpec(GoParser::ConstSpecContext * /*ctx*/) override { }
+
+  virtual void enterIdentifierList(GoParser::IdentifierListContext * /*ctx*/) override { }
+  virtual void exitIdentifierList(GoParser::IdentifierListContext * /*ctx*/) override { }
+
+  virtual void enterExpressionList(GoParser::ExpressionListContext * /*ctx*/) override { }
+  virtual void exitExpressionList(GoParser::ExpressionListContext * /*ctx*/) override { }
+
+  virtual void enterTypeDecl(GoParser::TypeDeclContext * /*ctx*/) override { }
+  virtual void exitTypeDecl(GoParser::TypeDeclContext * /*ctx*/) override { }
+
+  virtual void enterTypeSpec(GoParser::TypeSpecContext * /*ctx*/) override { }
+  virtual void exitTypeSpec(GoParser::TypeSpecContext * /*ctx*/) override { }
+
+  virtual void enterFunctionDecl(GoParser::FunctionDeclContext * /*ctx*/) override { }
+  virtual void exitFunctionDecl(GoParser::FunctionDeclContext * /*ctx*/) override { }
+
+  virtual void enterMethodDecl(GoParser::MethodDeclContext * /*ctx*/) override { }
+  virtual void exitMethodDecl(GoParser::MethodDeclContext * /*ctx*/) override { }
+
+  virtual void enterReceiver(GoParser::ReceiverContext * /*ctx*/) override { }
+  virtual void exitReceiver(GoParser::ReceiverContext * /*ctx*/) override { }
+
+  virtual void enterVarDecl(GoParser::VarDeclContext * /*ctx*/) override { }
+  virtual void exitVarDecl(GoParser::VarDeclContext * /*ctx*/) override { }
+
+  virtual void enterVarSpec(GoParser::VarSpecContext * /*ctx*/) override { }
+  virtual void exitVarSpec(GoParser::VarSpecContext * /*ctx*/) override { }
+
+  virtual void enterBlock(GoParser::BlockContext * /*ctx*/) override { }
+  virtual void exitBlock(GoParser::BlockContext * /*ctx*/) override { }
+
+  virtual void enterStatementList(GoParser::StatementListContext * /*ctx*/) override { }
+  virtual void exitStatementList(GoParser::StatementListContext * /*ctx*/) override { }
+
+  virtual void enterStatement(GoParser::StatementContext * /*ctx*/) override { }
+  virtual void exitStatement(GoParser::StatementContext * /*ctx*/) override { }
+
+  virtual void enterSimpleStmt(GoParser::SimpleStmtContext * /*ctx*/) override { }
+  virtual void exitSimpleStmt(GoParser::SimpleStmtContext * /*ctx*/) override { }
+
+  virtual void enterExpressionStmt(GoParser::ExpressionStmtContext * /*ctx*/) override { }
+  virtual void exitExpressionStmt(GoParser::ExpressionStmtContext * /*ctx*/) override { }
+
+  virtual void enterSendStmt(GoParser::SendStmtContext * /*ctx*/) override { }
+  virtual void exitSendStmt(GoParser::SendStmtContext * /*ctx*/) override { }
+
+  virtual void enterIncDecStmt(GoParser::IncDecStmtContext * /*ctx*/) override { }
+  virtual void exitIncDecStmt(GoParser::IncDecStmtContext * /*ctx*/) override { }
+
+  virtual void enterAssignment(GoParser::AssignmentContext * /*ctx*/) override { }
+  virtual void exitAssignment(GoParser::AssignmentContext * /*ctx*/) override { }
+
+  virtual void enterAssign_op(GoParser::Assign_opContext * /*ctx*/) override { }
+  virtual void exitAssign_op(GoParser::Assign_opContext * /*ctx*/) override { }
+
+  virtual void enterShortVarDecl(GoParser::ShortVarDeclContext * /*ctx*/) override { }
+  virtual void exitShortVarDecl(GoParser::ShortVarDeclContext * /*ctx*/) override { }
+
+  virtual void enterEmptyStmt(GoParser::EmptyStmtContext * /*ctx*/) override { }
+  virtual void exitEmptyStmt(GoParser::EmptyStmtContext * /*ctx*/) override { }
+
+  virtual void enterLabeledStmt(GoParser::LabeledStmtContext * /*ctx*/) override { }
+  virtual void exitLabeledStmt(GoParser::LabeledStmtContext * /*ctx*/) override { }
+
+  virtual void enterReturnStmt(GoParser::ReturnStmtContext * /*ctx*/) override { }
+  virtual void exitReturnStmt(GoParser::ReturnStmtContext * /*ctx*/) override { }
+
+  virtual void enterBreakStmt(GoParser::BreakStmtContext * /*ctx*/) override { }
+  virtual void exitBreakStmt(GoParser::BreakStmtContext * /*ctx*/) override { }
+
+  virtual void enterContinueStmt(GoParser::ContinueStmtContext * /*ctx*/) override { }
+  virtual void exitContinueStmt(GoParser::ContinueStmtContext * /*ctx*/) override { }
+
+  virtual void enterGotoStmt(GoParser::GotoStmtContext * /*ctx*/) override { }
+  virtual void exitGotoStmt(GoParser::GotoStmtContext * /*ctx*/) override { }
+
+  virtual void enterFallthroughStmt(GoParser::FallthroughStmtContext * /*ctx*/) override { }
+  virtual void exitFallthroughStmt(GoParser::FallthroughStmtContext * /*ctx*/) override { }
+
+  virtual void enterDeferStmt(GoParser::DeferStmtContext * /*ctx*/) override { }
+  virtual void exitDeferStmt(GoParser::DeferStmtContext * /*ctx*/) override { }
+
+  virtual void enterIfStmt(GoParser::IfStmtContext * /*ctx*/) override { }
+  virtual void exitIfStmt(GoParser::IfStmtContext * /*ctx*/) override { }
+
+  virtual void enterSwitchStmt(GoParser::SwitchStmtContext * /*ctx*/) override { }
+  virtual void exitSwitchStmt(GoParser::SwitchStmtContext * /*ctx*/) override { }
+
+  virtual void enterExprSwitchStmt(GoParser::ExprSwitchStmtContext * /*ctx*/) override { }
+  virtual void exitExprSwitchStmt(GoParser::ExprSwitchStmtContext * /*ctx*/) override { }
+
+  virtual void enterExprCaseClause(GoParser::ExprCaseClauseContext * /*ctx*/) override { }
+  virtual void exitExprCaseClause(GoParser::ExprCaseClauseContext * /*ctx*/) override { }
+
+  virtual void enterExprSwitchCase(GoParser::ExprSwitchCaseContext * /*ctx*/) override { }
+  virtual void exitExprSwitchCase(GoParser::ExprSwitchCaseContext * /*ctx*/) override { }
+
+  virtual void enterTypeSwitchStmt(GoParser::TypeSwitchStmtContext * /*ctx*/) override { }
+  virtual void exitTypeSwitchStmt(GoParser::TypeSwitchStmtContext * /*ctx*/) override { }
+
+  virtual void enterTypeSwitchGuard(GoParser::TypeSwitchGuardContext * /*ctx*/) override { }
+  virtual void exitTypeSwitchGuard(GoParser::TypeSwitchGuardContext * /*ctx*/) override { }
+
+  virtual void enterTypeCaseClause(GoParser::TypeCaseClauseContext * /*ctx*/) override { }
+  virtual void exitTypeCaseClause(GoParser::TypeCaseClauseContext * /*ctx*/) override { }
+
+  virtual void enterTypeSwitchCase(GoParser::TypeSwitchCaseContext * /*ctx*/) override { }
+  virtual void exitTypeSwitchCase(GoParser::TypeSwitchCaseContext * /*ctx*/) override { }
+
+  virtual void enterTypeList(GoParser::TypeListContext * /*ctx*/) override { }
+  virtual void exitTypeList(GoParser::TypeListContext * /*ctx*/) override { }
+
+  virtual void enterSelectStmt(GoParser::SelectStmtContext * /*ctx*/) override { }
+  virtual void exitSelectStmt(GoParser::SelectStmtContext * /*ctx*/) override { }
+
+  virtual void enterCommClause(GoParser::CommClauseContext * /*ctx*/) override { }
+  virtual void exitCommClause(GoParser::CommClauseContext * /*ctx*/) override { }
+
+  virtual void enterCommCase(GoParser::CommCaseContext * /*ctx*/) override { }
+  virtual void exitCommCase(GoParser::CommCaseContext * /*ctx*/) override { }
+
+  virtual void enterRecvStmt(GoParser::RecvStmtContext * /*ctx*/) override { }
+  virtual void exitRecvStmt(GoParser::RecvStmtContext * /*ctx*/) override { }
+
+  virtual void enterForStmt(GoParser::ForStmtContext * /*ctx*/) override { }
+  virtual void exitForStmt(GoParser::ForStmtContext * /*ctx*/) override { }
+
+  virtual void enterForClause(GoParser::ForClauseContext * /*ctx*/) override { }
+  virtual void exitForClause(GoParser::ForClauseContext * /*ctx*/) override { }
+
+  virtual void enterRangeClause(GoParser::RangeClauseContext * /*ctx*/) override { }
+  virtual void exitRangeClause(GoParser::RangeClauseContext * /*ctx*/) override { }
+
+  virtual void enterGoStmt(GoParser::GoStmtContext * /*ctx*/) override { }
+  virtual void exitGoStmt(GoParser::GoStmtContext * /*ctx*/) override { }
+
+  virtual void enterType_(GoParser::Type_Context * /*ctx*/) override { }
+  virtual void exitType_(GoParser::Type_Context * /*ctx*/) override { }
+
+  virtual void enterTypeName(GoParser::TypeNameContext * /*ctx*/) override { }
+  virtual void exitTypeName(GoParser::TypeNameContext * /*ctx*/) override { }
+
+  virtual void enterTypeLit(GoParser::TypeLitContext * /*ctx*/) override { }
+  virtual void exitTypeLit(GoParser::TypeLitContext * /*ctx*/) override { }
+
+  virtual void enterArrayType(GoParser::ArrayTypeContext * /*ctx*/) override { }
+  virtual void exitArrayType(GoParser::ArrayTypeContext * /*ctx*/) override { }
+
+  virtual void enterArrayLength(GoParser::ArrayLengthContext * /*ctx*/) override { }
+  virtual void exitArrayLength(GoParser::ArrayLengthContext * /*ctx*/) override { }
+
+  virtual void enterElementType(GoParser::ElementTypeContext * /*ctx*/) override { }
+  virtual void exitElementType(GoParser::ElementTypeContext * /*ctx*/) override { }
+
+  virtual void enterPointerType(GoParser::PointerTypeContext * /*ctx*/) override { }
+  virtual void exitPointerType(GoParser::PointerTypeContext * /*ctx*/) override { }
+
+  virtual void enterInterfaceType(GoParser::InterfaceTypeContext * /*ctx*/) override { }
+  virtual void exitInterfaceType(GoParser::InterfaceTypeContext * /*ctx*/) override { }
+
+  virtual void enterSliceType(GoParser::SliceTypeContext * /*ctx*/) override { }
+  virtual void exitSliceType(GoParser::SliceTypeContext * /*ctx*/) override { }
+
+  virtual void enterMapType(GoParser::MapTypeContext * /*ctx*/) override { }
+  virtual void exitMapType(GoParser::MapTypeContext * /*ctx*/) override { }
+
+  virtual void enterChannelType(GoParser::ChannelTypeContext * /*ctx*/) override { }
+  virtual void exitChannelType(GoParser::ChannelTypeContext * /*ctx*/) override { }
+
+  virtual void enterMethodSpec(GoParser::MethodSpecContext * /*ctx*/) override { }
+  virtual void exitMethodSpec(GoParser::MethodSpecContext * /*ctx*/) override { }
+
+  virtual void enterFunctionType(GoParser::FunctionTypeContext * /*ctx*/) override { }
+  virtual void exitFunctionType(GoParser::FunctionTypeContext * /*ctx*/) override { }
+
+  virtual void enterSignature(GoParser::SignatureContext * /*ctx*/) override { }
+  virtual void exitSignature(GoParser::SignatureContext * /*ctx*/) override { }
+
+  virtual void enterResult(GoParser::ResultContext * /*ctx*/) override { }
+  virtual void exitResult(GoParser::ResultContext * /*ctx*/) override { }
+
+  virtual void enterParameters(GoParser::ParametersContext * /*ctx*/) override { }
+  virtual void exitParameters(GoParser::ParametersContext * /*ctx*/) override { }
+
+  virtual void enterParameterDecl(GoParser::ParameterDeclContext * /*ctx*/) override { }
+  virtual void exitParameterDecl(GoParser::ParameterDeclContext * /*ctx*/) override { }
+
+  virtual void enterLogicalAndOperation(GoParser::LogicalAndOperationContext * /*ctx*/) override { }
+  virtual void exitLogicalAndOperation(GoParser::LogicalAndOperationContext * /*ctx*/) override { }
+
+  virtual void enterUnaryOperation(GoParser::UnaryOperationContext * /*ctx*/) override { }
+  virtual void exitUnaryOperation(GoParser::UnaryOperationContext * /*ctx*/) override { }
+
+  virtual void enterPrimaryExpression(GoParser::PrimaryExpressionContext * /*ctx*/) override { }
+  virtual void exitPrimaryExpression(GoParser::PrimaryExpressionContext * /*ctx*/) override { }
+
+  virtual void enterPlusMinusOperation(GoParser::PlusMinusOperationContext * /*ctx*/) override { }
+  virtual void exitPlusMinusOperation(GoParser::PlusMinusOperationContext * /*ctx*/) override { }
+
+  virtual void enterRelationOperation(GoParser::RelationOperationContext * /*ctx*/) override { }
+  virtual void exitRelationOperation(GoParser::RelationOperationContext * /*ctx*/) override { }
+
+  virtual void enterMulDivOperation(GoParser::MulDivOperationContext * /*ctx*/) override { }
+  virtual void exitMulDivOperation(GoParser::MulDivOperationContext * /*ctx*/) override { }
+
+  virtual void enterLogicalOrOperation(GoParser::LogicalOrOperationContext * /*ctx*/) override { }
+  virtual void exitLogicalOrOperation(GoParser::LogicalOrOperationContext * /*ctx*/) override { }
+
+  virtual void enterPrimaryExpr(GoParser::PrimaryExprContext * /*ctx*/) override { }
+  virtual void exitPrimaryExpr(GoParser::PrimaryExprContext * /*ctx*/) override { }
+
+  virtual void enterConversion(GoParser::ConversionContext * /*ctx*/) override { }
+  virtual void exitConversion(GoParser::ConversionContext * /*ctx*/) override { }
+
+  virtual void enterNonNamedType(GoParser::NonNamedTypeContext * /*ctx*/) override { }
+  virtual void exitNonNamedType(GoParser::NonNamedTypeContext * /*ctx*/) override { }
+
+  virtual void enterOperand(GoParser::OperandContext * /*ctx*/) override { }
+  virtual void exitOperand(GoParser::OperandContext * /*ctx*/) override { }
+
+  virtual void enterLiteral(GoParser::LiteralContext * /*ctx*/) override { }
+  virtual void exitLiteral(GoParser::LiteralContext * /*ctx*/) override { }
+
+  virtual void enterBasicLit(GoParser::BasicLitContext * /*ctx*/) override { }
+  virtual void exitBasicLit(GoParser::BasicLitContext * /*ctx*/) override { }
+
+  virtual void enterInteger(GoParser::IntegerContext * /*ctx*/) override { }
+  virtual void exitInteger(GoParser::IntegerContext * /*ctx*/) override { }
+
+  virtual void enterOperandName(GoParser::OperandNameContext * /*ctx*/) override { }
+  virtual void exitOperandName(GoParser::OperandNameContext * /*ctx*/) override { }
+
+  virtual void enterQualifiedIdent(GoParser::QualifiedIdentContext * /*ctx*/) override { }
+  virtual void exitQualifiedIdent(GoParser::QualifiedIdentContext * /*ctx*/) override { }
+
+  virtual void enterCompositeLit(GoParser::CompositeLitContext * /*ctx*/) override { }
+  virtual void exitCompositeLit(GoParser::CompositeLitContext * /*ctx*/) override { }
+
+  virtual void enterLiteralType(GoParser::LiteralTypeContext * /*ctx*/) override { }
+  virtual void exitLiteralType(GoParser::LiteralTypeContext * /*ctx*/) override { }
+
+  virtual void enterLiteralValue(GoParser::LiteralValueContext * /*ctx*/) override { }
+  virtual void exitLiteralValue(GoParser::LiteralValueContext * /*ctx*/) override { }
+
+  virtual void enterElementList(GoParser::ElementListContext * /*ctx*/) override { }
+  virtual void exitElementList(GoParser::ElementListContext * /*ctx*/) override { }
+
+  virtual void enterKeyedElement(GoParser::KeyedElementContext * /*ctx*/) override { }
+  virtual void exitKeyedElement(GoParser::KeyedElementContext * /*ctx*/) override { }
+
+  virtual void enterKey(GoParser::KeyContext * /*ctx*/) override { }
+  virtual void exitKey(GoParser::KeyContext * /*ctx*/) override { }
+
+  virtual void enterElement(GoParser::ElementContext * /*ctx*/) override { }
+  virtual void exitElement(GoParser::ElementContext * /*ctx*/) override { }
+
+  virtual void enterStructType(GoParser::StructTypeContext * /*ctx*/) override { }
+  virtual void exitStructType(GoParser::StructTypeContext * /*ctx*/) override { }
+
+  virtual void enterFieldDecl(GoParser::FieldDeclContext * /*ctx*/) override { }
+  virtual void exitFieldDecl(GoParser::FieldDeclContext * /*ctx*/) override { }
+
+  virtual void enterString_(GoParser::String_Context * /*ctx*/) override { }
+  virtual void exitString_(GoParser::String_Context * /*ctx*/) override { }
+
+  virtual void enterEmbeddedField(GoParser::EmbeddedFieldContext * /*ctx*/) override { }
+  virtual void exitEmbeddedField(GoParser::EmbeddedFieldContext * /*ctx*/) override { }
+
+  virtual void enterFunctionLit(GoParser::FunctionLitContext * /*ctx*/) override { }
+  virtual void exitFunctionLit(GoParser::FunctionLitContext * /*ctx*/) override { }
+
+  virtual void enterIndex(GoParser::IndexContext * /*ctx*/) override { }
+  virtual void exitIndex(GoParser::IndexContext * /*ctx*/) override { }
+
+  virtual void enterSlice_(GoParser::Slice_Context * /*ctx*/) override { }
+  virtual void exitSlice_(GoParser::Slice_Context * /*ctx*/) override { }
+
+  virtual void enterTypeAssertion(GoParser::TypeAssertionContext * /*ctx*/) override { }
+  virtual void exitTypeAssertion(GoParser::TypeAssertionContext * /*ctx*/) override { }
+
+  virtual void enterArguments(GoParser::ArgumentsContext * /*ctx*/) override { }
+  virtual void exitArguments(GoParser::ArgumentsContext * /*ctx*/) override { }
+
+  virtual void enterMethodExpr(GoParser::MethodExprContext * /*ctx*/) override { }
+  virtual void exitMethodExpr(GoParser::MethodExprContext * /*ctx*/) override { }
+
+  virtual void enterReceiverType(GoParser::ReceiverTypeContext * /*ctx*/) override { }
+  virtual void exitReceiverType(GoParser::ReceiverTypeContext * /*ctx*/) override { }
+
+  virtual void enterEoss(GoParser::EossContext * /*ctx*/) override { }
+  virtual void exitEoss(GoParser::EossContext * /*ctx*/) override { }
+
+
+  virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
+  virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
+  virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { }
+  virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { }
+
+};
+

grammar/cpp/GoParserListener.cpp

@@ -0,0 +1,7 @@
+
+// Generated from /workspace/millet-porridge-III/grammar/GoParser.g4 by ANTLR 4.9.3
+
+
+#include "GoParserListener.h"
+
+

grammar/cpp/GoParserListener.h

@@ -0,0 +1,334 @@
+
+// Generated from /workspace/millet-porridge-III/grammar/GoParser.g4 by ANTLR 4.9.3
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "GoParser.h"
+
+
+/**
+ * This interface defines an abstract listener for a parse tree produced by GoParser.
+ */
+class  GoParserListener : public antlr4::tree::ParseTreeListener {
+public:
+
+  virtual void enterSourceFile(GoParser::SourceFileContext *ctx) = 0;
+  virtual void exitSourceFile(GoParser::SourceFileContext *ctx) = 0;
+
+  virtual void enterPackageClause(GoParser::PackageClauseContext *ctx) = 0;
+  virtual void exitPackageClause(GoParser::PackageClauseContext *ctx) = 0;
+
+  virtual void enterImportDecl(GoParser::ImportDeclContext *ctx) = 0;
+  virtual void exitImportDecl(GoParser::ImportDeclContext *ctx) = 0;
+
+  virtual void enterImportSpec(GoParser::ImportSpecContext *ctx) = 0;
+  virtual void exitImportSpec(GoParser::ImportSpecContext *ctx) = 0;
+
+  virtual void enterImportPath(GoParser::ImportPathContext *ctx) = 0;
+  virtual void exitImportPath(GoParser::ImportPathContext *ctx) = 0;
+
+  virtual void enterDeclaration(GoParser::DeclarationContext *ctx) = 0;
+  virtual void exitDeclaration(GoParser::DeclarationContext *ctx) = 0;
+
+  virtual void enterConstDecl(GoParser::ConstDeclContext *ctx) = 0;
+  virtual void exitConstDecl(GoParser::ConstDeclContext *ctx) = 0;
+
+  virtual void enterConstSpec(GoParser::ConstSpecContext *ctx) = 0;
+  virtual void exitConstSpec(GoParser::ConstSpecContext *ctx) = 0;
+
+  virtual void enterIdentifierList(GoParser::IdentifierListContext *ctx) = 0;
+  virtual void exitIdentifierList(GoParser::IdentifierListContext *ctx) = 0;
+
+  virtual void enterExpressionList(GoParser::ExpressionListContext *ctx) = 0;
+  virtual void exitExpressionList(GoParser::ExpressionListContext *ctx) = 0;
+
+  virtual void enterTypeDecl(GoParser::TypeDeclContext *ctx) = 0;
+  virtual void exitTypeDecl(GoParser::TypeDeclContext *ctx) = 0;
+
+  virtual void enterTypeSpec(GoParser::TypeSpecContext *ctx) = 0;
+  virtual void exitTypeSpec(GoParser::TypeSpecContext *ctx) = 0;
+
+  virtual void enterFunctionDecl(GoParser::FunctionDeclContext *ctx) = 0;
+  virtual void exitFunctionDecl(GoParser::FunctionDeclContext *ctx) = 0;
+
+  virtual void enterMethodDecl(GoParser::MethodDeclContext *ctx) = 0;
+  virtual void exitMethodDecl(GoParser::MethodDeclContext *ctx) = 0;
+
+  virtual void enterReceiver(GoParser::ReceiverContext *ctx) = 0;
+  virtual void exitReceiver(GoParser::ReceiverContext *ctx) = 0;
+
+  virtual void enterVarDecl(GoParser::VarDeclContext *ctx) = 0;
+  virtual void exitVarDecl(GoParser::VarDeclContext *ctx) = 0;
+
+  virtual void enterVarSpec(GoParser::VarSpecContext *ctx) = 0;
+  virtual void exitVarSpec(GoParser::VarSpecContext *ctx) = 0;
+
+  virtual void enterBlock(GoParser::BlockContext *ctx) = 0;
+  virtual void exitBlock(GoParser::BlockContext *ctx) = 0;
+
+  virtual void enterStatementList(GoParser::StatementListContext *ctx) = 0;
+  virtual void exitStatementList(GoParser::StatementListContext *ctx) = 0;
+
+  virtual void enterStatement(GoParser::StatementContext *ctx) = 0;
+  virtual void exitStatement(GoParser::StatementContext *ctx) = 0;
+
+  virtual void enterSimpleStmt(GoParser::SimpleStmtContext *ctx) = 0;
+  virtual void exitSimpleStmt(GoParser::SimpleStmtContext *ctx) = 0;
+
+  virtual void enterExpressionStmt(GoParser::ExpressionStmtContext *ctx) = 0;
+  virtual void exitExpressionStmt(GoParser::ExpressionStmtContext *ctx) = 0;
+
+  virtual void enterSendStmt(GoParser::SendStmtContext *ctx) = 0;
+  virtual void exitSendStmt(GoParser::SendStmtContext *ctx) = 0;
+
+  virtual void enterIncDecStmt(GoParser::IncDecStmtContext *ctx) = 0;
+  virtual void exitIncDecStmt(GoParser::IncDecStmtContext *ctx) = 0;
+
+  virtual void enterAssignment(GoParser::AssignmentContext *ctx) = 0;
+  virtual void exitAssignment(GoParser::AssignmentContext *ctx) = 0;
+
+  virtual void enterAssign_op(GoParser::Assign_opContext *ctx) = 0;
+  virtual void exitAssign_op(GoParser::Assign_opContext *ctx) = 0;
+
+  virtual void enterShortVarDecl(GoParser::ShortVarDeclContext *ctx) = 0;
+  virtual void exitShortVarDecl(GoParser::ShortVarDeclContext *ctx) = 0;
+
+  virtual void enterEmptyStmt(GoParser::EmptyStmtContext *ctx) = 0;
+  virtual void exitEmptyStmt(GoParser::EmptyStmtContext *ctx) = 0;
+
+  virtual void enterLabeledStmt(GoParser::LabeledStmtContext *ctx) = 0;
+  virtual void exitLabeledStmt(GoParser::LabeledStmtContext *ctx) = 0;
+
+  virtual void enterReturnStmt(GoParser::ReturnStmtContext *ctx) = 0;
+  virtual void exitReturnStmt(GoParser::ReturnStmtContext *ctx) = 0;
+
+  virtual void enterBreakStmt(GoParser::BreakStmtContext *ctx) = 0;
+  virtual void exitBreakStmt(GoParser::BreakStmtContext *ctx) = 0;
+
+  virtual void enterContinueStmt(GoParser::ContinueStmtContext *ctx) = 0;
+  virtual void exitContinueStmt(GoParser::ContinueStmtContext *ctx) = 0;
+
+  virtual void enterGotoStmt(GoParser::GotoStmtContext *ctx) = 0;
+  virtual void exitGotoStmt(GoParser::GotoStmtContext *ctx) = 0;
+
+  virtual void enterFallthroughStmt(GoParser::FallthroughStmtContext *ctx) = 0;
+  virtual void exitFallthroughStmt(GoParser::FallthroughStmtContext *ctx) = 0;
+
+  virtual void enterDeferStmt(GoParser::DeferStmtContext *ctx) = 0;
+  virtual void exitDeferStmt(GoParser::DeferStmtContext *ctx) = 0;
+
+  virtual void enterIfStmt(GoParser::IfStmtContext *ctx) = 0;
+  virtual void exitIfStmt(GoParser::IfStmtContext *ctx) = 0;
+
+  virtual void enterSwitchStmt(GoParser::SwitchStmtContext *ctx) = 0;
+  virtual void exitSwitchStmt(GoParser::SwitchStmtContext *ctx) = 0;
+
+  virtual void enterExprSwitchStmt(GoParser::ExprSwitchStmtContext *ctx) = 0;
+  virtual void exitExprSwitchStmt(GoParser::ExprSwitchStmtContext *ctx) = 0;
+
+  virtual void enterExprCaseClause(GoParser::ExprCaseClauseContext *ctx) = 0;
+  virtual void exitExprCaseClause(GoParser::ExprCaseClauseContext *ctx) = 0;
+
+  virtual void enterExprSwitchCase(GoParser::ExprSwitchCaseContext *ctx) = 0;
+  virtual void exitExprSwitchCase(GoParser::ExprSwitchCaseContext *ctx) = 0;
+
+  virtual void enterTypeSwitchStmt(GoParser::TypeSwitchStmtContext *ctx) = 0;
+  virtual void exitTypeSwitchStmt(GoParser::TypeSwitchStmtContext *ctx) = 0;
+
+  virtual void enterTypeSwitchGuard(GoParser::TypeSwitchGuardContext *ctx) = 0;
+  virtual void exitTypeSwitchGuard(GoParser::TypeSwitchGuardContext *ctx) = 0;
+
+  virtual void enterTypeCaseClause(GoParser::TypeCaseClauseContext *ctx) = 0;
+  virtual void exitTypeCaseClause(GoParser::TypeCaseClauseContext *ctx) = 0;
+
+  virtual void enterTypeSwitchCase(GoParser::TypeSwitchCaseContext *ctx) = 0;
+  virtual void exitTypeSwitchCase(GoParser::TypeSwitchCaseContext *ctx) = 0;
+
+  virtual void enterTypeList(GoParser::TypeListContext *ctx) = 0;
+  virtual void exitTypeList(GoParser::TypeListContext *ctx) = 0;
+
+  virtual void enterSelectStmt(GoParser::SelectStmtContext *ctx) = 0;
+  virtual void exitSelectStmt(GoParser::SelectStmtContext *ctx) = 0;
+
+  virtual void enterCommClause(GoParser::CommClauseContext *ctx) = 0;
+  virtual void exitCommClause(GoParser::CommClauseContext *ctx) = 0;
+
+  virtual void enterCommCase(GoParser::CommCaseContext *ctx) = 0;
+  virtual void exitCommCase(GoParser::CommCaseContext *ctx) = 0;
+
+  virtual void enterRecvStmt(GoParser::RecvStmtContext *ctx) = 0;
+  virtual void exitRecvStmt(GoParser::RecvStmtContext *ctx) = 0;
+
+  virtual void enterForStmt(GoParser::ForStmtContext *ctx) = 0;
+  virtual void exitForStmt(GoParser::ForStmtContext *ctx) = 0;
+
+  virtual void enterForClause(GoParser::ForClauseContext *ctx) = 0;
+  virtual void exitForClause(GoParser::ForClauseContext *ctx) = 0;
+
+  virtual void enterRangeClause(GoParser::RangeClauseContext *ctx) = 0;
+  virtual void exitRangeClause(GoParser::RangeClauseContext *ctx) = 0;
+
+  virtual void enterGoStmt(GoParser::GoStmtContext *ctx) = 0;
+  virtual void exitGoStmt(GoParser::GoStmtContext *ctx) = 0;
+
+  virtual void enterType_(GoParser::Type_Context *ctx) = 0;
+  virtual void exitType_(GoParser::Type_Context *ctx) = 0;
+
+  virtual void enterTypeName(GoParser::TypeNameContext *ctx) = 0;
+  virtual void exitTypeName(GoParser::TypeNameContext *ctx) = 0;
+
+  virtual void enterTypeLit(GoParser::TypeLitContext *ctx) = 0;
+  virtual void exitTypeLit(GoParser::TypeLitContext *ctx) = 0;
+
+  virtual void enterArrayType(GoParser::ArrayTypeContext *ctx) = 0;
+  virtual void exitArrayType(GoParser::ArrayTypeContext *ctx) = 0;
+
+  virtual void enterArrayLength(GoParser::ArrayLengthContext *ctx) = 0;
+  virtual void exitArrayLength(GoParser::ArrayLengthContext *ctx) = 0;
+
+  virtual void enterElementType(GoParser::ElementTypeContext *ctx) = 0;
+  virtual void exitElementType(GoParser::ElementTypeContext *ctx) = 0;
+
+  virtual void enterPointerType(GoParser::PointerTypeContext *ctx) = 0;
+  virtual void exitPointerType(GoParser::PointerTypeContext *ctx) = 0;
+
+  virtual void enterInterfaceType(GoParser::InterfaceTypeContext *ctx) = 0;
+  virtual void exitInterfaceType(GoParser::InterfaceTypeContext *ctx) = 0;
+
+  virtual void enterSliceType(GoParser::SliceTypeContext *ctx) = 0;
+  virtual void exitSliceType(GoParser::SliceTypeContext *ctx) = 0;
+
+  virtual void enterMapType(GoParser::MapTypeContext *ctx) = 0;
+  virtual void exitMapType(GoParser::MapTypeContext *ctx) = 0;
+
+  virtual void enterChannelType(GoParser::ChannelTypeContext *ctx) = 0;
+  virtual void exitChannelType(GoParser::ChannelTypeContext *ctx) = 0;
+
+  virtual void enterMethodSpec(GoParser::MethodSpecContext *ctx) = 0;
+  virtual void exitMethodSpec(GoParser::MethodSpecContext *ctx) = 0;
+
+  virtual void enterFunctionType(GoParser::FunctionTypeContext *ctx) = 0;
+  virtual void exitFunctionType(GoParser::FunctionTypeContext *ctx) = 0;
+
+  virtual void enterSignature(GoParser::SignatureContext *ctx) = 0;
+  virtual void exitSignature(GoParser::SignatureContext *ctx) = 0;
+
+  virtual void enterResult(GoParser::ResultContext *ctx) = 0;
+  virtual void exitResult(GoParser::ResultContext *ctx) = 0;
+
+  virtual void enterParameters(GoParser::ParametersContext *ctx) = 0;
+  virtual void exitParameters(GoParser::ParametersContext *ctx) = 0;
+
+  virtual void enterParameterDecl(GoParser::ParameterDeclContext *ctx) = 0;
+  virtual void exitParameterDecl(GoParser::ParameterDeclContext *ctx) = 0;
+
+  virtual void enterLogicalAndOperation(GoParser::LogicalAndOperationContext *ctx) = 0;
+  virtual void exitLogicalAndOperation(GoParser::LogicalAndOperationContext *ctx) = 0;
+
+  virtual void enterUnaryOperation(GoParser::UnaryOperationContext *ctx) = 0;
+  virtual void exitUnaryOperation(GoParser::UnaryOperationContext *ctx) = 0;
+
+  virtual void enterPrimaryExpression(GoParser::PrimaryExpressionContext *ctx) = 0;
+  virtual void exitPrimaryExpression(GoParser::PrimaryExpressionContext *ctx) = 0;
+
+  virtual void enterPlusMinusOperation(GoParser::PlusMinusOperationContext *ctx) = 0;
+  virtual void exitPlusMinusOperation(GoParser::PlusMinusOperationContext *ctx) = 0;
+
+  virtual void enterRelationOperation(GoParser::RelationOperationContext *ctx) = 0;
+  virtual void exitRelationOperation(GoParser::RelationOperationContext *ctx) = 0;
+
+  virtual void enterMulDivOperation(GoParser::MulDivOperationContext *ctx) = 0;
+  virtual void exitMulDivOperation(GoParser::MulDivOperationContext *ctx) = 0;
+
+  virtual void enterLogicalOrOperation(GoParser::LogicalOrOperationContext *ctx) = 0;
+  virtual void exitLogicalOrOperation(GoParser::LogicalOrOperationContext *ctx) = 0;
+
+  virtual void enterPrimaryExpr(GoParser::PrimaryExprContext *ctx) = 0;
+  virtual void exitPrimaryExpr(GoParser::PrimaryExprContext *ctx) = 0;
+
+  virtual void enterConversion(GoParser::ConversionContext *ctx) = 0;
+  virtual void exitConversion(GoParser::ConversionContext *ctx) = 0;
+
+  virtual void enterNonNamedType(GoParser::NonNamedTypeContext *ctx) = 0;
+  virtual void exitNonNamedType(GoParser::NonNamedTypeContext *ctx) = 0;
+
+  virtual void enterOperand(GoParser::OperandContext *ctx) = 0;
+  virtual void exitOperand(GoParser::OperandContext *ctx) = 0;
+
+  virtual void enterLiteral(GoParser::LiteralContext *ctx) = 0;
+  virtual void exitLiteral(GoParser::LiteralContext *ctx) = 0;
+
+  virtual void enterBasicLit(GoParser::BasicLitContext *ctx) = 0;
+  virtual void exitBasicLit(GoParser::BasicLitContext *ctx) = 0;
+
+  virtual void enterInteger(GoParser::IntegerContext *ctx) = 0;
+  virtual void exitInteger(GoParser::IntegerContext *ctx) = 0;
+
+  virtual void enterOperandName(GoParser::OperandNameContext *ctx) = 0;
+  virtual void exitOperandName(GoParser::OperandNameContext *ctx) = 0;
+
+  virtual void enterQualifiedIdent(GoParser::QualifiedIdentContext *ctx) = 0;
+  virtual void exitQualifiedIdent(GoParser::QualifiedIdentContext *ctx) = 0;
+
+  virtual void enterCompositeLit(GoParser::CompositeLitContext *ctx) = 0;
+  virtual void exitCompositeLit(GoParser::CompositeLitContext *ctx) = 0;
+
+  virtual void enterLiteralType(GoParser::LiteralTypeContext *ctx) = 0;
+  virtual void exitLiteralType(GoParser::LiteralTypeContext *ctx) = 0;
+
+  virtual void enterLiteralValue(GoParser::LiteralValueContext *ctx) = 0;
+  virtual void exitLiteralValue(GoParser::LiteralValueContext *ctx) = 0;
+
+  virtual void enterElementList(GoParser::ElementListContext *ctx) = 0;
+  virtual void exitElementList(GoParser::ElementListContext *ctx) = 0;
+
+  virtual void enterKeyedElement(GoParser::KeyedElementContext *ctx) = 0;
+  virtual void exitKeyedElement(GoParser::KeyedElementContext *ctx) = 0;
+
+  virtual void enterKey(GoParser::KeyContext *ctx) = 0;
+  virtual void exitKey(GoParser::KeyContext *ctx) = 0;
+
+  virtual void enterElement(GoParser::ElementContext *ctx) = 0;
+  virtual void exitElement(GoParser::ElementContext *ctx) = 0;
+
+  virtual void enterStructType(GoParser::StructTypeContext *ctx) = 0;
+  virtual void exitStructType(GoParser::StructTypeContext *ctx) = 0;
+
+  virtual void enterFieldDecl(GoParser::FieldDeclContext *ctx) = 0;
+  virtual void exitFieldDecl(GoParser::FieldDeclContext *ctx) = 0;
+
+  virtual void enterString_(GoParser::String_Context *ctx) = 0;
+  virtual void exitString_(GoParser::String_Context *ctx) = 0;
+
+  virtual void enterEmbeddedField(GoParser::EmbeddedFieldContext *ctx) = 0;
+  virtual void exitEmbeddedField(GoParser::EmbeddedFieldContext *ctx) = 0;
+
+  virtual void enterFunctionLit(GoParser::FunctionLitContext *ctx) = 0;
+  virtual void exitFunctionLit(GoParser::FunctionLitContext *ctx) = 0;
+
+  virtual void enterIndex(GoParser::IndexContext *ctx) = 0;
+  virtual void exitIndex(GoParser::IndexContext *ctx) = 0;
+
+  virtual void enterSlice_(GoParser::Slice_Context *ctx) = 0;
+  virtual void exitSlice_(GoParser::Slice_Context *ctx) = 0;
+
+  virtual void enterTypeAssertion(GoParser::TypeAssertionContext *ctx) = 0;
+  virtual void exitTypeAssertion(GoParser::TypeAssertionContext *ctx) = 0;
+
+  virtual void enterArguments(GoParser::ArgumentsContext *ctx) = 0;
+  virtual void exitArguments(GoParser::ArgumentsContext *ctx) = 0;
+
+  virtual void enterMethodExpr(GoParser::MethodExprContext *ctx) = 0;
+  virtual void exitMethodExpr(GoParser::MethodExprContext *ctx) = 0;
+
+  virtual void enterReceiverType(GoParser::ReceiverTypeContext *ctx) = 0;
+  virtual void exitReceiverType(GoParser::ReceiverTypeContext *ctx) = 0;
+
+  virtual void enterEoss(GoParser::EossContext *ctx) = 0;
+  virtual void exitEoss(GoParser::EossContext *ctx) = 0;
+
+
+};
+

run_asm.sh

@@ -1,5 +0,0 @@
-cd build
-./tjugo ../demo/05func.go
-ld -m elf_i386 -o run.bin out.o print.o
-./run.bin
-

src/ICG/CMakeLists.txt

@@ -7,28 +7,23 @@ file(GLOB grammar_g4
 
 set(ANTLR4_FLAGS -Dlanguage=Cpp)
 execute_process(
-    COMMAND java -jar "${ANTLR4CPP_JAR_LOCATION}" ${ANTLR4_FLAGS} ${grammar_g4} -o ${CMAKE_SOURCE_DIR}/grammar/gen
+    COMMAND java -jar "${ANTLR4CPP_JAR_LOCATION}" ${ANTLR4_FLAGS} ${grammar_g4} -o ${CMAKE_SOURCE_DIR}/grammar/cpp
-)
-
-set(ANTLR4_FLAGS -Dlanguage=Java)
-execute_process(
-    COMMAND java -jar "${ANTLR4CPP_JAR_LOCATION}" ${ANTLR4_FLAGS} ${grammar_g4} -o ${CMAKE_SOURCE_DIR}/grammar/java
 )
 
 
 
 # cmake
-file(GLOB_RECURSE src_lib_gen ${CMAKE_SOURCE_DIR}/grammar/gen/*.cpp)
+file(GLOB_RECURSE src_lib_cpp ${CMAKE_SOURCE_DIR}/grammar/cpp/*.cpp)
 file(GLOB_RECURSE src_lib_icg *.cpp)
 
 add_library(icg
-    ${src_lib_gen}
+    ${src_lib_cpp}
     ${src_lib_icg}
 )
 
 target_include_directories(icg PUBLIC
     ${CMAKE_SOURCE_DIR}/3rd/antlr4-runtime/src
-    ${CMAKE_SOURCE_DIR}/grammar/gen
+    ${CMAKE_SOURCE_DIR}/grammar/cpp
     ${CMAKE_SOURCE_DIR}/include
 )
 

temp/05func.go

@@ -1,18 +0,0 @@
-package main
-
-
-func myprint(a int)
-
-
-func add_1(a int, b int) (int, int) {
-	return a + 1, b + 1
-}
-
-
-func main() {
-	var a = 100;
-	var b = 105;
-	var c, d = add_1(a, b)
-	myprint(c)				// 预计输出 101
-	myprint(d)				// 预计输出 106
-}

test_all.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+cd build
+
+for test_file in ../demo/*.go; do
+    base_name=$(basename "$test_file" .go)
+
+    echo -e "\n========== 编译 $base_name =========="
+    if ! ./tjugo ../demo/$test_file; then
+        echo "编译错误，按任意键继续..."
+        read -n 1 -s
+    fi
+    
+    if ! ld -m elf_i386 -o run.bin out.o print.o; then
+        echo "链接错误，按任意键继续..."
+        read -n 1 -s
+    fi
+
+    echo -e "\n========== 运行 $base_name =========="
+    if ! ./run.bin; then
+        echo "运行错误，按任意键继续..."
+        read -n 1 -s
+    fi
+done