Feature api root path (#1261)

tools/goctl/api/parser/g4/ApiParser.g4

@@ -63,11 +63,11 @@ serviceApi:     {match(p,"service")}serviceToken=ID serviceName lbrace='{' servi
 serviceRoute:   atDoc? (atServer|atHandler) route;
 atDoc:          ATDOC lp='('? ((kvLit+)|STRING) rp=')'?;
 atHandler:      ATHANDLER ID;
-route:          {checkHttpMethod(p)}httpMethod=ID path request=body? returnToken=ID? response=replybody?;
+route:          {checkHTTPMethod(p)}httpMethod=ID path request=body? returnToken=ID? response=replybody?;
 body:           lp='(' (ID)? rp=')';
 replybody:      lp='(' dataType? rp=')';
 // kv
 kvLit:          key=ID {checkKeyValue(p)}value=LINE_VALUE;
 
 serviceName:    (ID '-'?)+;
-path:           (('/' (ID ('-' ID)*))|('/:' (ID ('-' ID)?)))+;
+path:           (('/' (ID ('-' ID)*))|('/:' (ID ('-' ID)?)))+ | '/';

tools/goctl/api/parser/g4/gen/api/apiparser_base_visitor.go

@@ -1,5 +1,3 @@
-// Code generated from tools/goctl/api/parser/g4/ApiParser.g4 by ANTLR 4.9. DO NOT EDIT.
-
 package api // ApiParser
 import "github.com/zeromicro/antlr"
 

tools/goctl/api/parser/g4/gen/api/apiparser_lexer.go

@@ -1,5 +1,3 @@
-// Code generated from tools/goctl/api/parser/g4/ApiParser.g4 by ANTLR 4.9. DO NOT EDIT.
-
 package api
 
 import (
@@ -10,10 +8,8 @@ import (
 )
 
 // Suppress unused import error
-var (
-	_ = fmt.Printf
-	_ = unicode.IsLetter
-)
+var _ = fmt.Printf
+var _ = unicode.IsLetter
 
 var serializedLexerAtn = []uint16{
 	3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 25, 266,

tools/goctl/api/parser/g4/gen/api/apiparser_parser.go

@@ -1,5 +1,3 @@
-// Code generated from tools/goctl/api/parser/g4/ApiParser.g4 by ANTLR 4.9. DO NOT EDIT.
-
 package api // ApiParser
 import (
 	"fmt"
@@ -10,14 +8,12 @@ import (
 )
 
 // Suppress unused import errors
-var (
-	_ = fmt.Printf
-	_ = reflect.Copy
-	_ = strconv.Itoa
-)
+var _ = fmt.Printf
+var _ = reflect.Copy
+var _ = strconv.Itoa
 
 var parserATN = []uint16{
-	3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 25, 348,
+	3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 25, 351,
 	4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7,
 	4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13,
 	9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9,
@@ -54,127 +50,127 @@ var parserATN = []uint16{
 	35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 5, 37, 323, 10, 37,
 	6, 37, 325, 10, 37, 13, 37, 14, 37, 326, 3, 38, 3, 38, 3, 38, 3, 38, 7,
 	38, 333, 10, 38, 12, 38, 14, 38, 336, 11, 38, 3, 38, 3, 38, 3, 38, 3, 38,
-	5, 38, 342, 10, 38, 6, 38, 344, 10, 38, 13, 38, 14, 38, 345, 3, 38, 2,
-	2, 39, 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, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70,
-	72, 74, 2, 2, 2, 357, 2, 79, 3, 2, 2, 2, 4, 87, 3, 2, 2, 2, 6, 89, 3, 2,
-	2, 2, 8, 97, 3, 2, 2, 2, 10, 99, 3, 2, 2, 2, 12, 103, 3, 2, 2, 2, 14, 113,
-	3, 2, 2, 2, 16, 115, 3, 2, 2, 2, 18, 118, 3, 2, 2, 2, 20, 130, 3, 2, 2,
-	2, 22, 132, 3, 2, 2, 2, 24, 136, 3, 2, 2, 2, 26, 149, 3, 2, 2, 2, 28, 153,
-	3, 2, 2, 2, 30, 155, 3, 2, 2, 2, 32, 169, 3, 2, 2, 2, 34, 176, 3, 2, 2,
-	2, 36, 190, 3, 2, 2, 2, 38, 200, 3, 2, 2, 2, 40, 202, 3, 2, 2, 2, 42, 209,
-	3, 2, 2, 2, 44, 221, 3, 2, 2, 2, 46, 223, 3, 2, 2, 2, 48, 227, 3, 2, 2,
-	2, 50, 235, 3, 2, 2, 2, 52, 240, 3, 2, 2, 2, 54, 244, 3, 2, 2, 2, 56, 253,
-	3, 2, 2, 2, 58, 266, 3, 2, 2, 2, 60, 274, 3, 2, 2, 2, 62, 289, 3, 2, 2,
-	2, 64, 292, 3, 2, 2, 2, 66, 304, 3, 2, 2, 2, 68, 310, 3, 2, 2, 2, 70, 316,
-	3, 2, 2, 2, 72, 324, 3, 2, 2, 2, 74, 343, 3, 2, 2, 2, 76, 78, 5, 4, 3,
-	2, 77, 76, 3, 2, 2, 2, 78, 81, 3, 2, 2, 2, 79, 77, 3, 2, 2, 2, 79, 80,
-	3, 2, 2, 2, 80, 3, 3, 2, 2, 2, 81, 79, 3, 2, 2, 2, 82, 88, 5, 6, 4, 2,
-	83, 88, 5, 8, 5, 2, 84, 88, 5, 18, 10, 2, 85, 88, 5, 20, 11, 2, 86, 88,
-	5, 52, 27, 2, 87, 82, 3, 2, 2, 2, 87, 83, 3, 2, 2, 2, 87, 84, 3, 2, 2,
-	2, 87, 85, 3, 2, 2, 2, 87, 86, 3, 2, 2, 2, 88, 5, 3, 2, 2, 2, 89, 90, 8,
-	4, 1, 2, 90, 91, 7, 25, 2, 2, 91, 92, 7, 3, 2, 2, 92, 93, 8, 4, 1, 2, 93,
-	94, 7, 22, 2, 2, 94, 7, 3, 2, 2, 2, 95, 98, 5, 10, 6, 2, 96, 98, 5, 12,
-	7, 2, 97, 95, 3, 2, 2, 2, 97, 96, 3, 2, 2, 2, 98, 9, 3, 2, 2, 2, 99, 100,
-	8, 6, 1, 2, 100, 101, 7, 25, 2, 2, 101, 102, 5, 16, 9, 2, 102, 11, 3, 2,
-	2, 2, 103, 104, 8, 7, 1, 2, 104, 105, 7, 25, 2, 2, 105, 107, 7, 4, 2, 2,
-	106, 108, 5, 14, 8, 2, 107, 106, 3, 2, 2, 2, 108, 109, 3, 2, 2, 2, 109,
-	107, 3, 2, 2, 2, 109, 110, 3, 2, 2, 2, 110, 111, 3, 2, 2, 2, 111, 112,
-	7, 5, 2, 2, 112, 13, 3, 2, 2, 2, 113, 114, 5, 16, 9, 2, 114, 15, 3, 2,
-	2, 2, 115, 116, 8, 9, 1, 2, 116, 117, 7, 22, 2, 2, 117, 17, 3, 2, 2, 2,
-	118, 119, 8, 10, 1, 2, 119, 120, 7, 25, 2, 2, 120, 122, 7, 4, 2, 2, 121,
-	123, 5, 70, 36, 2, 122, 121, 3, 2, 2, 2, 123, 124, 3, 2, 2, 2, 124, 122,
-	3, 2, 2, 2, 124, 125, 3, 2, 2, 2, 125, 126, 3, 2, 2, 2, 126, 127, 7, 5,
-	2, 2, 127, 19, 3, 2, 2, 2, 128, 131, 5, 22, 12, 2, 129, 131, 5, 24, 13,
-	2, 130, 128, 3, 2, 2, 2, 130, 129, 3, 2, 2, 2, 131, 21, 3, 2, 2, 2, 132,
-	133, 8, 12, 1, 2, 133, 134, 7, 25, 2, 2, 134, 135, 5, 26, 14, 2, 135, 23,
-	3, 2, 2, 2, 136, 137, 8, 13, 1, 2, 137, 138, 7, 25, 2, 2, 138, 142, 7,
-	4, 2, 2, 139, 141, 5, 28, 15, 2, 140, 139, 3, 2, 2, 2, 141, 144, 3, 2,
-	2, 2, 142, 140, 3, 2, 2, 2, 142, 143, 3, 2, 2, 2, 143, 145, 3, 2, 2, 2,
-	144, 142, 3, 2, 2, 2, 145, 146, 7, 5, 2, 2, 146, 25, 3, 2, 2, 2, 147, 150,
-	5, 30, 16, 2, 148, 150, 5, 32, 17, 2, 149, 147, 3, 2, 2, 2, 149, 148, 3,
-	2, 2, 2, 150, 27, 3, 2, 2, 2, 151, 154, 5, 34, 18, 2, 152, 154, 5, 36,
-	19, 2, 153, 151, 3, 2, 2, 2, 153, 152, 3, 2, 2, 2, 154, 29, 3, 2, 2, 2,
-	155, 156, 8, 16, 1, 2, 156, 158, 7, 25, 2, 2, 157, 159, 7, 25, 2, 2, 158,
-	157, 3, 2, 2, 2, 158, 159, 3, 2, 2, 2, 159, 160, 3, 2, 2, 2, 160, 164,
-	7, 6, 2, 2, 161, 163, 5, 38, 20, 2, 162, 161, 3, 2, 2, 2, 163, 166, 3,
-	2, 2, 2, 164, 162, 3, 2, 2, 2, 164, 165, 3, 2, 2, 2, 165, 167, 3, 2, 2,
-	2, 166, 164, 3, 2, 2, 2, 167, 168, 7, 7, 2, 2, 168, 31, 3, 2, 2, 2, 169,
-	170, 8, 17, 1, 2, 170, 172, 7, 25, 2, 2, 171, 173, 7, 3, 2, 2, 172, 171,
-	3, 2, 2, 2, 172, 173, 3, 2, 2, 2, 173, 174, 3, 2, 2, 2, 174, 175, 5, 44,
-	23, 2, 175, 33, 3, 2, 2, 2, 176, 177, 8, 18, 1, 2, 177, 179, 7, 25, 2,
-	2, 178, 180, 7, 25, 2, 2, 179, 178, 3, 2, 2, 2, 179, 180, 3, 2, 2, 2, 180,
-	181, 3, 2, 2, 2, 181, 185, 7, 6, 2, 2, 182, 184, 5, 38, 20, 2, 183, 182,
-	3, 2, 2, 2, 184, 187, 3, 2, 2, 2, 185, 183, 3, 2, 2, 2, 185, 186, 3, 2,
-	2, 2, 186, 188, 3, 2, 2, 2, 187, 185, 3, 2, 2, 2, 188, 189, 7, 7, 2, 2,
-	189, 35, 3, 2, 2, 2, 190, 191, 8, 19, 1, 2, 191, 193, 7, 25, 2, 2, 192,
-	194, 7, 3, 2, 2, 193, 192, 3, 2, 2, 2, 193, 194, 3, 2, 2, 2, 194, 195,
-	3, 2, 2, 2, 195, 196, 5, 44, 23, 2, 196, 37, 3, 2, 2, 2, 197, 198, 6, 20,
-	2, 2, 198, 201, 5, 40, 21, 2, 199, 201, 5, 42, 22, 2, 200, 197, 3, 2, 2,
-	2, 200, 199, 3, 2, 2, 2, 201, 39, 3, 2, 2, 2, 202, 203, 8, 21, 1, 2, 203,
-	204, 7, 25, 2, 2, 204, 206, 5, 44, 23, 2, 205, 207, 7, 23, 2, 2, 206, 205,
-	3, 2, 2, 2, 206, 207, 3, 2, 2, 2, 207, 41, 3, 2, 2, 2, 208, 210, 7, 8,
-	2, 2, 209, 208, 3, 2, 2, 2, 209, 210, 3, 2, 2, 2, 210, 211, 3, 2, 2, 2,
-	211, 212, 7, 25, 2, 2, 212, 43, 3, 2, 2, 2, 213, 214, 8, 23, 1, 2, 214,
-	222, 7, 25, 2, 2, 215, 222, 5, 48, 25, 2, 216, 222, 5, 50, 26, 2, 217,
-	222, 7, 17, 2, 2, 218, 222, 7, 9, 2, 2, 219, 222, 5, 46, 24, 2, 220, 222,
-	5, 30, 16, 2, 221, 213, 3, 2, 2, 2, 221, 215, 3, 2, 2, 2, 221, 216, 3,
-	2, 2, 2, 221, 217, 3, 2, 2, 2, 221, 218, 3, 2, 2, 2, 221, 219, 3, 2, 2,
-	2, 221, 220, 3, 2, 2, 2, 222, 45, 3, 2, 2, 2, 223, 224, 7, 8, 2, 2, 224,
-	225, 8, 24, 1, 2, 225, 226, 7, 25, 2, 2, 226, 47, 3, 2, 2, 2, 227, 228,
-	8, 25, 1, 2, 228, 229, 7, 25, 2, 2, 229, 230, 7, 10, 2, 2, 230, 231, 8,
-	25, 1, 2, 231, 232, 7, 25, 2, 2, 232, 233, 7, 11, 2, 2, 233, 234, 5, 44,
-	23, 2, 234, 49, 3, 2, 2, 2, 235, 236, 7, 10, 2, 2, 236, 237, 7, 11, 2,
-	2, 237, 238, 5, 44, 23, 2, 238, 51, 3, 2, 2, 2, 239, 241, 5, 54, 28, 2,
-	240, 239, 3, 2, 2, 2, 240, 241, 3, 2, 2, 2, 241, 242, 3, 2, 2, 2, 242,
-	243, 5, 56, 29, 2, 243, 53, 3, 2, 2, 2, 244, 245, 7, 18, 2, 2, 245, 247,
-	7, 4, 2, 2, 246, 248, 5, 70, 36, 2, 247, 246, 3, 2, 2, 2, 248, 249, 3,
-	2, 2, 2, 249, 247, 3, 2, 2, 2, 249, 250, 3, 2, 2, 2, 250, 251, 3, 2, 2,
-	2, 251, 252, 7, 5, 2, 2, 252, 55, 3, 2, 2, 2, 253, 254, 8, 29, 1, 2, 254,
-	255, 7, 25, 2, 2, 255, 256, 5, 72, 37, 2, 256, 260, 7, 6, 2, 2, 257, 259,
-	5, 58, 30, 2, 258, 257, 3, 2, 2, 2, 259, 262, 3, 2, 2, 2, 260, 258, 3,
-	2, 2, 2, 260, 261, 3, 2, 2, 2, 261, 263, 3, 2, 2, 2, 262, 260, 3, 2, 2,
-	2, 263, 264, 7, 7, 2, 2, 264, 57, 3, 2, 2, 2, 265, 267, 5, 60, 31, 2, 266,
-	265, 3, 2, 2, 2, 266, 267, 3, 2, 2, 2, 267, 270, 3, 2, 2, 2, 268, 271,
-	5, 54, 28, 2, 269, 271, 5, 62, 32, 2, 270, 268, 3, 2, 2, 2, 270, 269, 3,
-	2, 2, 2, 271, 272, 3, 2, 2, 2, 272, 273, 5, 64, 33, 2, 273, 59, 3, 2, 2,
-	2, 274, 276, 7, 15, 2, 2, 275, 277, 7, 4, 2, 2, 276, 275, 3, 2, 2, 2, 276,
-	277, 3, 2, 2, 2, 277, 284, 3, 2, 2, 2, 278, 280, 5, 70, 36, 2, 279, 278,
-	3, 2, 2, 2, 280, 281, 3, 2, 2, 2, 281, 279, 3, 2, 2, 2, 281, 282, 3, 2,
-	2, 2, 282, 285, 3, 2, 2, 2, 283, 285, 7, 22, 2, 2, 284, 279, 3, 2, 2, 2,
-	284, 283, 3, 2, 2, 2, 285, 287, 3, 2, 2, 2, 286, 288, 7, 5, 2, 2, 287,
-	286, 3, 2, 2, 2, 287, 288, 3, 2, 2, 2, 288, 61, 3, 2, 2, 2, 289, 290, 7,
-	16, 2, 2, 290, 291, 7, 25, 2, 2, 291, 63, 3, 2, 2, 2, 292, 293, 8, 33,
-	1, 2, 293, 294, 7, 25, 2, 2, 294, 296, 5, 74, 38, 2, 295, 297, 5, 66, 34,
-	2, 296, 295, 3, 2, 2, 2, 296, 297, 3, 2, 2, 2, 297, 299, 3, 2, 2, 2, 298,
-	300, 7, 25, 2, 2, 299, 298, 3, 2, 2, 2, 299, 300, 3, 2, 2, 2, 300, 302,
-	3, 2, 2, 2, 301, 303, 5, 68, 35, 2, 302, 301, 3, 2, 2, 2, 302, 303, 3,
-	2, 2, 2, 303, 65, 3, 2, 2, 2, 304, 306, 7, 4, 2, 2, 305, 307, 7, 25, 2,
-	2, 306, 305, 3, 2, 2, 2, 306, 307, 3, 2, 2, 2, 307, 308, 3, 2, 2, 2, 308,
-	309, 7, 5, 2, 2, 309, 67, 3, 2, 2, 2, 310, 312, 7, 4, 2, 2, 311, 313, 5,
-	44, 23, 2, 312, 311, 3, 2, 2, 2, 312, 313, 3, 2, 2, 2, 313, 314, 3, 2,
-	2, 2, 314, 315, 7, 5, 2, 2, 315, 69, 3, 2, 2, 2, 316, 317, 7, 25, 2, 2,
-	317, 318, 8, 36, 1, 2, 318, 319, 7, 24, 2, 2, 319, 71, 3, 2, 2, 2, 320,
-	322, 7, 25, 2, 2, 321, 323, 7, 12, 2, 2, 322, 321, 3, 2, 2, 2, 322, 323,
-	3, 2, 2, 2, 323, 325, 3, 2, 2, 2, 324, 320, 3, 2, 2, 2, 325, 326, 3, 2,
-	2, 2, 326, 324, 3, 2, 2, 2, 326, 327, 3, 2, 2, 2, 327, 73, 3, 2, 2, 2,
-	328, 329, 7, 13, 2, 2, 329, 334, 7, 25, 2, 2, 330, 331, 7, 12, 2, 2, 331,
-	333, 7, 25, 2, 2, 332, 330, 3, 2, 2, 2, 333, 336, 3, 2, 2, 2, 334, 332,
-	3, 2, 2, 2, 334, 335, 3, 2, 2, 2, 335, 344, 3, 2, 2, 2, 336, 334, 3, 2,
-	2, 2, 337, 338, 7, 14, 2, 2, 338, 341, 7, 25, 2, 2, 339, 340, 7, 12, 2,
-	2, 340, 342, 7, 25, 2, 2, 341, 339, 3, 2, 2, 2, 341, 342, 3, 2, 2, 2, 342,
-	344, 3, 2, 2, 2, 343, 328, 3, 2, 2, 2, 343, 337, 3, 2, 2, 2, 344, 345,
-	3, 2, 2, 2, 345, 343, 3, 2, 2, 2, 345, 346, 3, 2, 2, 2, 346, 75, 3, 2,
-	2, 2, 41, 79, 87, 97, 109, 124, 130, 142, 149, 153, 158, 164, 172, 179,
-	185, 193, 200, 206, 209, 221, 240, 249, 260, 266, 270, 276, 281, 284, 287,
-	296, 299, 302, 306, 312, 322, 326, 334, 341, 343, 345,
+	5, 38, 342, 10, 38, 6, 38, 344, 10, 38, 13, 38, 14, 38, 345, 3, 38, 5,
+	38, 349, 10, 38, 3, 38, 2, 2, 39, 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, 52, 54, 56, 58,
+	60, 62, 64, 66, 68, 70, 72, 74, 2, 2, 2, 361, 2, 79, 3, 2, 2, 2, 4, 87,
+	3, 2, 2, 2, 6, 89, 3, 2, 2, 2, 8, 97, 3, 2, 2, 2, 10, 99, 3, 2, 2, 2, 12,
+	103, 3, 2, 2, 2, 14, 113, 3, 2, 2, 2, 16, 115, 3, 2, 2, 2, 18, 118, 3,
+	2, 2, 2, 20, 130, 3, 2, 2, 2, 22, 132, 3, 2, 2, 2, 24, 136, 3, 2, 2, 2,
+	26, 149, 3, 2, 2, 2, 28, 153, 3, 2, 2, 2, 30, 155, 3, 2, 2, 2, 32, 169,
+	3, 2, 2, 2, 34, 176, 3, 2, 2, 2, 36, 190, 3, 2, 2, 2, 38, 200, 3, 2, 2,
+	2, 40, 202, 3, 2, 2, 2, 42, 209, 3, 2, 2, 2, 44, 221, 3, 2, 2, 2, 46, 223,
+	3, 2, 2, 2, 48, 227, 3, 2, 2, 2, 50, 235, 3, 2, 2, 2, 52, 240, 3, 2, 2,
+	2, 54, 244, 3, 2, 2, 2, 56, 253, 3, 2, 2, 2, 58, 266, 3, 2, 2, 2, 60, 274,
+	3, 2, 2, 2, 62, 289, 3, 2, 2, 2, 64, 292, 3, 2, 2, 2, 66, 304, 3, 2, 2,
+	2, 68, 310, 3, 2, 2, 2, 70, 316, 3, 2, 2, 2, 72, 324, 3, 2, 2, 2, 74, 348,
+	3, 2, 2, 2, 76, 78, 5, 4, 3, 2, 77, 76, 3, 2, 2, 2, 78, 81, 3, 2, 2, 2,
+	79, 77, 3, 2, 2, 2, 79, 80, 3, 2, 2, 2, 80, 3, 3, 2, 2, 2, 81, 79, 3, 2,
+	2, 2, 82, 88, 5, 6, 4, 2, 83, 88, 5, 8, 5, 2, 84, 88, 5, 18, 10, 2, 85,
+	88, 5, 20, 11, 2, 86, 88, 5, 52, 27, 2, 87, 82, 3, 2, 2, 2, 87, 83, 3,
+	2, 2, 2, 87, 84, 3, 2, 2, 2, 87, 85, 3, 2, 2, 2, 87, 86, 3, 2, 2, 2, 88,
+	5, 3, 2, 2, 2, 89, 90, 8, 4, 1, 2, 90, 91, 7, 25, 2, 2, 91, 92, 7, 3, 2,
+	2, 92, 93, 8, 4, 1, 2, 93, 94, 7, 22, 2, 2, 94, 7, 3, 2, 2, 2, 95, 98,
+	5, 10, 6, 2, 96, 98, 5, 12, 7, 2, 97, 95, 3, 2, 2, 2, 97, 96, 3, 2, 2,
+	2, 98, 9, 3, 2, 2, 2, 99, 100, 8, 6, 1, 2, 100, 101, 7, 25, 2, 2, 101,
+	102, 5, 16, 9, 2, 102, 11, 3, 2, 2, 2, 103, 104, 8, 7, 1, 2, 104, 105,
+	7, 25, 2, 2, 105, 107, 7, 4, 2, 2, 106, 108, 5, 14, 8, 2, 107, 106, 3,
+	2, 2, 2, 108, 109, 3, 2, 2, 2, 109, 107, 3, 2, 2, 2, 109, 110, 3, 2, 2,
+	2, 110, 111, 3, 2, 2, 2, 111, 112, 7, 5, 2, 2, 112, 13, 3, 2, 2, 2, 113,
+	114, 5, 16, 9, 2, 114, 15, 3, 2, 2, 2, 115, 116, 8, 9, 1, 2, 116, 117,
+	7, 22, 2, 2, 117, 17, 3, 2, 2, 2, 118, 119, 8, 10, 1, 2, 119, 120, 7, 25,
+	2, 2, 120, 122, 7, 4, 2, 2, 121, 123, 5, 70, 36, 2, 122, 121, 3, 2, 2,
+	2, 123, 124, 3, 2, 2, 2, 124, 122, 3, 2, 2, 2, 124, 125, 3, 2, 2, 2, 125,
+	126, 3, 2, 2, 2, 126, 127, 7, 5, 2, 2, 127, 19, 3, 2, 2, 2, 128, 131, 5,
+	22, 12, 2, 129, 131, 5, 24, 13, 2, 130, 128, 3, 2, 2, 2, 130, 129, 3, 2,
+	2, 2, 131, 21, 3, 2, 2, 2, 132, 133, 8, 12, 1, 2, 133, 134, 7, 25, 2, 2,
+	134, 135, 5, 26, 14, 2, 135, 23, 3, 2, 2, 2, 136, 137, 8, 13, 1, 2, 137,
+	138, 7, 25, 2, 2, 138, 142, 7, 4, 2, 2, 139, 141, 5, 28, 15, 2, 140, 139,
+	3, 2, 2, 2, 141, 144, 3, 2, 2, 2, 142, 140, 3, 2, 2, 2, 142, 143, 3, 2,
+	2, 2, 143, 145, 3, 2, 2, 2, 144, 142, 3, 2, 2, 2, 145, 146, 7, 5, 2, 2,
+	146, 25, 3, 2, 2, 2, 147, 150, 5, 30, 16, 2, 148, 150, 5, 32, 17, 2, 149,
+	147, 3, 2, 2, 2, 149, 148, 3, 2, 2, 2, 150, 27, 3, 2, 2, 2, 151, 154, 5,
+	34, 18, 2, 152, 154, 5, 36, 19, 2, 153, 151, 3, 2, 2, 2, 153, 152, 3, 2,
+	2, 2, 154, 29, 3, 2, 2, 2, 155, 156, 8, 16, 1, 2, 156, 158, 7, 25, 2, 2,
+	157, 159, 7, 25, 2, 2, 158, 157, 3, 2, 2, 2, 158, 159, 3, 2, 2, 2, 159,
+	160, 3, 2, 2, 2, 160, 164, 7, 6, 2, 2, 161, 163, 5, 38, 20, 2, 162, 161,
+	3, 2, 2, 2, 163, 166, 3, 2, 2, 2, 164, 162, 3, 2, 2, 2, 164, 165, 3, 2,
+	2, 2, 165, 167, 3, 2, 2, 2, 166, 164, 3, 2, 2, 2, 167, 168, 7, 7, 2, 2,
+	168, 31, 3, 2, 2, 2, 169, 170, 8, 17, 1, 2, 170, 172, 7, 25, 2, 2, 171,
+	173, 7, 3, 2, 2, 172, 171, 3, 2, 2, 2, 172, 173, 3, 2, 2, 2, 173, 174,
+	3, 2, 2, 2, 174, 175, 5, 44, 23, 2, 175, 33, 3, 2, 2, 2, 176, 177, 8, 18,
+	1, 2, 177, 179, 7, 25, 2, 2, 178, 180, 7, 25, 2, 2, 179, 178, 3, 2, 2,
+	2, 179, 180, 3, 2, 2, 2, 180, 181, 3, 2, 2, 2, 181, 185, 7, 6, 2, 2, 182,
+	184, 5, 38, 20, 2, 183, 182, 3, 2, 2, 2, 184, 187, 3, 2, 2, 2, 185, 183,
+	3, 2, 2, 2, 185, 186, 3, 2, 2, 2, 186, 188, 3, 2, 2, 2, 187, 185, 3, 2,
+	2, 2, 188, 189, 7, 7, 2, 2, 189, 35, 3, 2, 2, 2, 190, 191, 8, 19, 1, 2,
+	191, 193, 7, 25, 2, 2, 192, 194, 7, 3, 2, 2, 193, 192, 3, 2, 2, 2, 193,
+	194, 3, 2, 2, 2, 194, 195, 3, 2, 2, 2, 195, 196, 5, 44, 23, 2, 196, 37,
+	3, 2, 2, 2, 197, 198, 6, 20, 2, 2, 198, 201, 5, 40, 21, 2, 199, 201, 5,
+	42, 22, 2, 200, 197, 3, 2, 2, 2, 200, 199, 3, 2, 2, 2, 201, 39, 3, 2, 2,
+	2, 202, 203, 8, 21, 1, 2, 203, 204, 7, 25, 2, 2, 204, 206, 5, 44, 23, 2,
+	205, 207, 7, 23, 2, 2, 206, 205, 3, 2, 2, 2, 206, 207, 3, 2, 2, 2, 207,
+	41, 3, 2, 2, 2, 208, 210, 7, 8, 2, 2, 209, 208, 3, 2, 2, 2, 209, 210, 3,
+	2, 2, 2, 210, 211, 3, 2, 2, 2, 211, 212, 7, 25, 2, 2, 212, 43, 3, 2, 2,
+	2, 213, 214, 8, 23, 1, 2, 214, 222, 7, 25, 2, 2, 215, 222, 5, 48, 25, 2,
+	216, 222, 5, 50, 26, 2, 217, 222, 7, 17, 2, 2, 218, 222, 7, 9, 2, 2, 219,
+	222, 5, 46, 24, 2, 220, 222, 5, 30, 16, 2, 221, 213, 3, 2, 2, 2, 221, 215,
+	3, 2, 2, 2, 221, 216, 3, 2, 2, 2, 221, 217, 3, 2, 2, 2, 221, 218, 3, 2,
+	2, 2, 221, 219, 3, 2, 2, 2, 221, 220, 3, 2, 2, 2, 222, 45, 3, 2, 2, 2,
+	223, 224, 7, 8, 2, 2, 224, 225, 8, 24, 1, 2, 225, 226, 7, 25, 2, 2, 226,
+	47, 3, 2, 2, 2, 227, 228, 8, 25, 1, 2, 228, 229, 7, 25, 2, 2, 229, 230,
+	7, 10, 2, 2, 230, 231, 8, 25, 1, 2, 231, 232, 7, 25, 2, 2, 232, 233, 7,
+	11, 2, 2, 233, 234, 5, 44, 23, 2, 234, 49, 3, 2, 2, 2, 235, 236, 7, 10,
+	2, 2, 236, 237, 7, 11, 2, 2, 237, 238, 5, 44, 23, 2, 238, 51, 3, 2, 2,
+	2, 239, 241, 5, 54, 28, 2, 240, 239, 3, 2, 2, 2, 240, 241, 3, 2, 2, 2,
+	241, 242, 3, 2, 2, 2, 242, 243, 5, 56, 29, 2, 243, 53, 3, 2, 2, 2, 244,
+	245, 7, 18, 2, 2, 245, 247, 7, 4, 2, 2, 246, 248, 5, 70, 36, 2, 247, 246,
+	3, 2, 2, 2, 248, 249, 3, 2, 2, 2, 249, 247, 3, 2, 2, 2, 249, 250, 3, 2,
+	2, 2, 250, 251, 3, 2, 2, 2, 251, 252, 7, 5, 2, 2, 252, 55, 3, 2, 2, 2,
+	253, 254, 8, 29, 1, 2, 254, 255, 7, 25, 2, 2, 255, 256, 5, 72, 37, 2, 256,
+	260, 7, 6, 2, 2, 257, 259, 5, 58, 30, 2, 258, 257, 3, 2, 2, 2, 259, 262,
+	3, 2, 2, 2, 260, 258, 3, 2, 2, 2, 260, 261, 3, 2, 2, 2, 261, 263, 3, 2,
+	2, 2, 262, 260, 3, 2, 2, 2, 263, 264, 7, 7, 2, 2, 264, 57, 3, 2, 2, 2,
+	265, 267, 5, 60, 31, 2, 266, 265, 3, 2, 2, 2, 266, 267, 3, 2, 2, 2, 267,
+	270, 3, 2, 2, 2, 268, 271, 5, 54, 28, 2, 269, 271, 5, 62, 32, 2, 270, 268,
+	3, 2, 2, 2, 270, 269, 3, 2, 2, 2, 271, 272, 3, 2, 2, 2, 272, 273, 5, 64,
+	33, 2, 273, 59, 3, 2, 2, 2, 274, 276, 7, 15, 2, 2, 275, 277, 7, 4, 2, 2,
+	276, 275, 3, 2, 2, 2, 276, 277, 3, 2, 2, 2, 277, 284, 3, 2, 2, 2, 278,
+	280, 5, 70, 36, 2, 279, 278, 3, 2, 2, 2, 280, 281, 3, 2, 2, 2, 281, 279,
+	3, 2, 2, 2, 281, 282, 3, 2, 2, 2, 282, 285, 3, 2, 2, 2, 283, 285, 7, 22,
+	2, 2, 284, 279, 3, 2, 2, 2, 284, 283, 3, 2, 2, 2, 285, 287, 3, 2, 2, 2,
+	286, 288, 7, 5, 2, 2, 287, 286, 3, 2, 2, 2, 287, 288, 3, 2, 2, 2, 288,
+	61, 3, 2, 2, 2, 289, 290, 7, 16, 2, 2, 290, 291, 7, 25, 2, 2, 291, 63,
+	3, 2, 2, 2, 292, 293, 8, 33, 1, 2, 293, 294, 7, 25, 2, 2, 294, 296, 5,
+	74, 38, 2, 295, 297, 5, 66, 34, 2, 296, 295, 3, 2, 2, 2, 296, 297, 3, 2,
+	2, 2, 297, 299, 3, 2, 2, 2, 298, 300, 7, 25, 2, 2, 299, 298, 3, 2, 2, 2,
+	299, 300, 3, 2, 2, 2, 300, 302, 3, 2, 2, 2, 301, 303, 5, 68, 35, 2, 302,
+	301, 3, 2, 2, 2, 302, 303, 3, 2, 2, 2, 303, 65, 3, 2, 2, 2, 304, 306, 7,
+	4, 2, 2, 305, 307, 7, 25, 2, 2, 306, 305, 3, 2, 2, 2, 306, 307, 3, 2, 2,
+	2, 307, 308, 3, 2, 2, 2, 308, 309, 7, 5, 2, 2, 309, 67, 3, 2, 2, 2, 310,
+	312, 7, 4, 2, 2, 311, 313, 5, 44, 23, 2, 312, 311, 3, 2, 2, 2, 312, 313,
+	3, 2, 2, 2, 313, 314, 3, 2, 2, 2, 314, 315, 7, 5, 2, 2, 315, 69, 3, 2,
+	2, 2, 316, 317, 7, 25, 2, 2, 317, 318, 8, 36, 1, 2, 318, 319, 7, 24, 2,
+	2, 319, 71, 3, 2, 2, 2, 320, 322, 7, 25, 2, 2, 321, 323, 7, 12, 2, 2, 322,
+	321, 3, 2, 2, 2, 322, 323, 3, 2, 2, 2, 323, 325, 3, 2, 2, 2, 324, 320,
+	3, 2, 2, 2, 325, 326, 3, 2, 2, 2, 326, 324, 3, 2, 2, 2, 326, 327, 3, 2,
+	2, 2, 327, 73, 3, 2, 2, 2, 328, 329, 7, 13, 2, 2, 329, 334, 7, 25, 2, 2,
+	330, 331, 7, 12, 2, 2, 331, 333, 7, 25, 2, 2, 332, 330, 3, 2, 2, 2, 333,
+	336, 3, 2, 2, 2, 334, 332, 3, 2, 2, 2, 334, 335, 3, 2, 2, 2, 335, 344,
+	3, 2, 2, 2, 336, 334, 3, 2, 2, 2, 337, 338, 7, 14, 2, 2, 338, 341, 7, 25,
+	2, 2, 339, 340, 7, 12, 2, 2, 340, 342, 7, 25, 2, 2, 341, 339, 3, 2, 2,
+	2, 341, 342, 3, 2, 2, 2, 342, 344, 3, 2, 2, 2, 343, 328, 3, 2, 2, 2, 343,
+	337, 3, 2, 2, 2, 344, 345, 3, 2, 2, 2, 345, 343, 3, 2, 2, 2, 345, 346,
+	3, 2, 2, 2, 346, 349, 3, 2, 2, 2, 347, 349, 7, 13, 2, 2, 348, 343, 3, 2,
+	2, 2, 348, 347, 3, 2, 2, 2, 349, 75, 3, 2, 2, 2, 42, 79, 87, 97, 109, 124,
+	130, 142, 149, 153, 158, 164, 172, 179, 185, 193, 200, 206, 209, 221, 240,
+	249, 260, 266, 270, 276, 281, 284, 287, 296, 299, 302, 306, 312, 322, 326,
+	334, 341, 343, 345, 348,
 }
-
 var literalNames = []string{
 	"", "'='", "'('", "')'", "'{'", "'}'", "'*'", "'time.Time'", "'['", "']'",
 	"'-'", "'/'", "'/:'", "'@doc'", "'@handler'", "'interface{}'", "'@server'",
 }
-
 var symbolicNames = []string{
 	"", "", "", "", "", "", "", "", "", "", "", "", "", "ATDOC", "ATHANDLER",
 	"INTERFACE", "ATSERVER", "WS", "COMMENT", "LINE_COMMENT", "STRING", "RAW_STRING",
@@ -305,7 +301,7 @@ type ApiContext struct {
 }
 
 func NewEmptyApiContext() *ApiContext {
-	p := new(ApiContext)
+	var p = new(ApiContext)
 	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
 	p.RuleIndex = ApiParserParserRULE_api
 	return p
@@ -314,7 +310,7 @@ func NewEmptyApiContext() *ApiContext {
 func (*ApiContext) IsApiContext() {}
 
 func NewApiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ApiContext {
-	p := new(ApiContext)
+	var p = new(ApiContext)
 
 	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
 
@@ -327,8 +323,8 @@ func NewApiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invoking
 func (s *ApiContext) GetParser() antlr.Parser { return s.parser }
 
 func (s *ApiContext) AllSpec() []ISpecContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*ISpecContext)(nil)).Elem())
-	tst := make([]ISpecContext, len(ts))
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ISpecContext)(nil)).Elem())
+	var tst = make([]ISpecContext, len(ts))
 
 	for i, t := range ts {
 		if t != nil {
@@ -340,7 +336,7 @@ func (s *ApiContext) AllSpec() []ISpecContext {
 }
 
 func (s *ApiContext) Spec(i int) ISpecContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ISpecContext)(nil)).Elem(), i)
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISpecContext)(nil)).Elem(), i)
 
 	if t == nil {
 		return nil
@@ -424,7 +420,7 @@ type SpecContext struct {
 }
 
 func NewEmptySpecContext() *SpecContext {
-	p := new(SpecContext)
+	var p = new(SpecContext)
 	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
 	p.RuleIndex = ApiParserParserRULE_spec
 	return p
@@ -433,7 +429,7 @@ func NewEmptySpecContext() *SpecContext {
 func (*SpecContext) IsSpecContext() {}
 
 func NewSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecContext {
-	p := new(SpecContext)
+	var p = new(SpecContext)
 
 	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
 
@@ -446,7 +442,7 @@ func NewSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokin
 func (s *SpecContext) GetParser() antlr.Parser { return s.parser }
 
 func (s *SpecContext) SyntaxLit() ISyntaxLitContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxLitContext)(nil)).Elem(), 0)
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ISyntaxLitContext)(nil)).Elem(), 0)
 
 	if t == nil {
 		return nil
@@ -456,7 +452,7 @@ func (s *SpecContext) SyntaxLit() ISyntaxLitContext {
 }
 
 func (s *SpecContext) ImportSpec() IImportSpecContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IImportSpecContext)(nil)).Elem(), 0)
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportSpecContext)(nil)).Elem(), 0)
 
 	if t == nil {
 		return nil
@@ -466,7 +462,7 @@ func (s *SpecContext) ImportSpec() IImportSpecContext {
 }
 
 func (s *SpecContext) InfoSpec() IInfoSpecContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IInfoSpecContext)(nil)).Elem(), 0)
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IInfoSpecContext)(nil)).Elem(), 0)
 
 	if t == nil {
 		return nil
@@ -476,7 +472,7 @@ func (s *SpecContext) InfoSpec() IInfoSpecContext {
 }
 
 func (s *SpecContext) TypeSpec() ITypeSpecContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecContext)(nil)).Elem(), 0)
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeSpecContext)(nil)).Elem(), 0)
 
 	if t == nil {
 		return nil
@@ -486,7 +482,7 @@ func (s *SpecContext) TypeSpec() ITypeSpecContext {
 }
 
 func (s *SpecContext) ServiceSpec() IServiceSpecContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IServiceSpecContext)(nil)).Elem(), 0)
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IServiceSpecContext)(nil)).Elem(), 0)
 
 	if t == nil {
 		return nil
@@ -614,7 +610,7 @@ type SyntaxLitContext struct {
 }
 
 func NewEmptySyntaxLitContext() *SyntaxLitContext {
-	p := new(SyntaxLitContext)
+	var p = new(SyntaxLitContext)
 	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
 	p.RuleIndex = ApiParserParserRULE_syntaxLit
 	return p
@@ -623,7 +619,7 @@ func NewEmptySyntaxLitContext() *SyntaxLitContext {
 func (*SyntaxLitContext) IsSyntaxLitContext() {}
 
 func NewSyntaxLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxLitContext {
-	p := new(SyntaxLitContext)
+	var p = new(SyntaxLitContext)
 
 	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
 
@@ -633,5036 +629,4 @@ func NewSyntaxLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, in
 	return p
 }
 
-func (s *SyntaxLitContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *SyntaxLitContext) GetSyntaxToken() antlr.Token { return s.syntaxToken }
-
-func (s *SyntaxLitContext) GetAssign() antlr.Token { return s.assign }
-
-func (s *SyntaxLitContext) GetVersion() antlr.Token { return s.version }
-
-func (s *SyntaxLitContext) SetSyntaxToken(v antlr.Token) { s.syntaxToken = v }
-
-func (s *SyntaxLitContext) SetAssign(v antlr.Token) { s.assign = v }
-
-func (s *SyntaxLitContext) SetVersion(v antlr.Token) { s.version = v }
-
-func (s *SyntaxLitContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *SyntaxLitContext) STRING() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserSTRING, 0)
-}
-
-func (s *SyntaxLitContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *SyntaxLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *SyntaxLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitSyntaxLit(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) SyntaxLit() (localctx ISyntaxLitContext) {
-	localctx = NewSyntaxLitContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 4, ApiParserParserRULE_syntaxLit)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "syntax")
-	{
-		p.SetState(88)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*SyntaxLitContext).syntaxToken = _m
-	}
-	{
-		p.SetState(89)
-
-		_m := p.Match(ApiParserParserT__0)
-
-		localctx.(*SyntaxLitContext).assign = _m
-	}
-	checkVersion(p)
-	{
-		p.SetState(91)
-
-		_m := p.Match(ApiParserParserSTRING)
-
-		localctx.(*SyntaxLitContext).version = _m
-	}
-
-	return localctx
-}
-
-// IImportSpecContext is an interface to support dynamic dispatch.
-type IImportSpecContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsImportSpecContext differentiates from other interfaces.
-	IsImportSpecContext()
-}
-
-type ImportSpecContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyImportSpecContext() *ImportSpecContext {
-	p := new(ImportSpecContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_importSpec
-	return p
-}
-
-func (*ImportSpecContext) IsImportSpecContext() {}
-
-func NewImportSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportSpecContext {
-	p := new(ImportSpecContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_importSpec
-
-	return p
-}
-
-func (s *ImportSpecContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ImportSpecContext) ImportLit() IImportLitContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IImportLitContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IImportLitContext)
-}
-
-func (s *ImportSpecContext) ImportBlock() IImportBlockContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IImportBlockContext)
-}
-
-func (s *ImportSpecContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ImportSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ImportSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitImportSpec(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ImportSpec() (localctx IImportSpecContext) {
-	localctx = NewImportSpecContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 6, ApiParserParserRULE_importSpec)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.SetState(95)
-	p.GetErrorHandler().Sync(p)
-	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
-	case 1:
-		p.EnterOuterAlt(localctx, 1)
-		{
-			p.SetState(93)
-			p.ImportLit()
-		}
-
-	case 2:
-		p.EnterOuterAlt(localctx, 2)
-		{
-			p.SetState(94)
-			p.ImportBlock()
-		}
-
-	}
-
-	return localctx
-}
-
-// IImportLitContext is an interface to support dynamic dispatch.
-type IImportLitContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetImportToken returns the importToken token.
-	GetImportToken() antlr.Token
-
-	// SetImportToken sets the importToken token.
-	SetImportToken(antlr.Token)
-
-	// IsImportLitContext differentiates from other interfaces.
-	IsImportLitContext()
-}
-
-type ImportLitContext struct {
-	*antlr.BaseParserRuleContext
-	parser      antlr.Parser
-	importToken antlr.Token
-}
-
-func NewEmptyImportLitContext() *ImportLitContext {
-	p := new(ImportLitContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_importLit
-	return p
-}
-
-func (*ImportLitContext) IsImportLitContext() {}
-
-func NewImportLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportLitContext {
-	p := new(ImportLitContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_importLit
-
-	return p
-}
-
-func (s *ImportLitContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ImportLitContext) GetImportToken() antlr.Token { return s.importToken }
-
-func (s *ImportLitContext) SetImportToken(v antlr.Token) { s.importToken = v }
-
-func (s *ImportLitContext) ImportValue() IImportValueContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IImportValueContext)
-}
-
-func (s *ImportLitContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *ImportLitContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ImportLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ImportLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitImportLit(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ImportLit() (localctx IImportLitContext) {
-	localctx = NewImportLitContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 8, ApiParserParserRULE_importLit)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "import")
-	{
-		p.SetState(98)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*ImportLitContext).importToken = _m
-	}
-	{
-		p.SetState(99)
-		p.ImportValue()
-	}
-
-	return localctx
-}
-
-// IImportBlockContext is an interface to support dynamic dispatch.
-type IImportBlockContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetImportToken returns the importToken token.
-	GetImportToken() antlr.Token
-
-	// SetImportToken sets the importToken token.
-	SetImportToken(antlr.Token)
-
-	// IsImportBlockContext differentiates from other interfaces.
-	IsImportBlockContext()
-}
-
-type ImportBlockContext struct {
-	*antlr.BaseParserRuleContext
-	parser      antlr.Parser
-	importToken antlr.Token
-}
-
-func NewEmptyImportBlockContext() *ImportBlockContext {
-	p := new(ImportBlockContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_importBlock
-	return p
-}
-
-func (*ImportBlockContext) IsImportBlockContext() {}
-
-func NewImportBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockContext {
-	p := new(ImportBlockContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_importBlock
-
-	return p
-}
-
-func (s *ImportBlockContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ImportBlockContext) GetImportToken() antlr.Token { return s.importToken }
-
-func (s *ImportBlockContext) SetImportToken(v antlr.Token) { s.importToken = v }
-
-func (s *ImportBlockContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *ImportBlockContext) AllImportBlockValue() []IImportBlockValueContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem())
-	tst := make([]IImportBlockValueContext, len(ts))
 
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IImportBlockValueContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *ImportBlockContext) ImportBlockValue(i int) IImportBlockValueContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IImportBlockValueContext)
-}
-
-func (s *ImportBlockContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ImportBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ImportBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitImportBlock(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ImportBlock() (localctx IImportBlockContext) {
-	localctx = NewImportBlockContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 10, ApiParserParserRULE_importBlock)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "import")
-	{
-		p.SetState(102)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*ImportBlockContext).importToken = _m
-	}
-	{
-		p.SetState(103)
-		p.Match(ApiParserParserT__1)
-	}
-	p.SetState(105)
-	p.GetErrorHandler().Sync(p)
-
-	for ok := true; ok; ok = _la == ApiParserParserSTRING {
-		{
-			p.SetState(104)
-			p.ImportBlockValue()
-		}
-
-		p.SetState(107)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-	{
-		p.SetState(109)
-		p.Match(ApiParserParserT__2)
-	}
-
-	return localctx
-}
-
-// IImportBlockValueContext is an interface to support dynamic dispatch.
-type IImportBlockValueContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsImportBlockValueContext differentiates from other interfaces.
-	IsImportBlockValueContext()
-}
-
-type ImportBlockValueContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyImportBlockValueContext() *ImportBlockValueContext {
-	p := new(ImportBlockValueContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_importBlockValue
-	return p
-}
-
-func (*ImportBlockValueContext) IsImportBlockValueContext() {}
-
-func NewImportBlockValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockValueContext {
-	p := new(ImportBlockValueContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_importBlockValue
-
-	return p
-}
-
-func (s *ImportBlockValueContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ImportBlockValueContext) ImportValue() IImportValueContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IImportValueContext)
-}
-
-func (s *ImportBlockValueContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ImportBlockValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ImportBlockValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitImportBlockValue(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ImportBlockValue() (localctx IImportBlockValueContext) {
-	localctx = NewImportBlockValueContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 12, ApiParserParserRULE_importBlockValue)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(111)
-		p.ImportValue()
-	}
-
-	return localctx
-}
-
-// IImportValueContext is an interface to support dynamic dispatch.
-type IImportValueContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsImportValueContext differentiates from other interfaces.
-	IsImportValueContext()
-}
-
-type ImportValueContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyImportValueContext() *ImportValueContext {
-	p := new(ImportValueContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_importValue
-	return p
-}
-
-func (*ImportValueContext) IsImportValueContext() {}
-
-func NewImportValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportValueContext {
-	p := new(ImportValueContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_importValue
-
-	return p
-}
-
-func (s *ImportValueContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ImportValueContext) STRING() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserSTRING, 0)
-}
-
-func (s *ImportValueContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ImportValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ImportValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitImportValue(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ImportValue() (localctx IImportValueContext) {
-	localctx = NewImportValueContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 14, ApiParserParserRULE_importValue)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	checkImportValue(p)
-	{
-		p.SetState(114)
-		p.Match(ApiParserParserSTRING)
-	}
-
-	return localctx
-}
-
-// IInfoSpecContext is an interface to support dynamic dispatch.
-type IInfoSpecContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetInfoToken returns the infoToken token.
-	GetInfoToken() antlr.Token
-
-	// GetLp returns the lp token.
-	GetLp() antlr.Token
-
-	// GetRp returns the rp token.
-	GetRp() antlr.Token
-
-	// SetInfoToken sets the infoToken token.
-	SetInfoToken(antlr.Token)
-
-	// SetLp sets the lp token.
-	SetLp(antlr.Token)
-
-	// SetRp sets the rp token.
-	SetRp(antlr.Token)
-
-	// IsInfoSpecContext differentiates from other interfaces.
-	IsInfoSpecContext()
-}
-
-type InfoSpecContext struct {
-	*antlr.BaseParserRuleContext
-	parser    antlr.Parser
-	infoToken antlr.Token
-	lp        antlr.Token
-	rp        antlr.Token
-}
-
-func NewEmptyInfoSpecContext() *InfoSpecContext {
-	p := new(InfoSpecContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_infoSpec
-	return p
-}
-
-func (*InfoSpecContext) IsInfoSpecContext() {}
-
-func NewInfoSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InfoSpecContext {
-	p := new(InfoSpecContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_infoSpec
-
-	return p
-}
-
-func (s *InfoSpecContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *InfoSpecContext) GetInfoToken() antlr.Token { return s.infoToken }
-
-func (s *InfoSpecContext) GetLp() antlr.Token { return s.lp }
-
-func (s *InfoSpecContext) GetRp() antlr.Token { return s.rp }
-
-func (s *InfoSpecContext) SetInfoToken(v antlr.Token) { s.infoToken = v }
-
-func (s *InfoSpecContext) SetLp(v antlr.Token) { s.lp = v }
-
-func (s *InfoSpecContext) SetRp(v antlr.Token) { s.rp = v }
-
-func (s *InfoSpecContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *InfoSpecContext) AllKvLit() []IKvLitContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())
-	tst := make([]IKvLitContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IKvLitContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *InfoSpecContext) KvLit(i int) IKvLitContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IKvLitContext)
-}
-
-func (s *InfoSpecContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *InfoSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *InfoSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitInfoSpec(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) InfoSpec() (localctx IInfoSpecContext) {
-	localctx = NewInfoSpecContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 16, ApiParserParserRULE_infoSpec)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "info")
-	{
-		p.SetState(117)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*InfoSpecContext).infoToken = _m
-	}
-	{
-		p.SetState(118)
-
-		_m := p.Match(ApiParserParserT__1)
-
-		localctx.(*InfoSpecContext).lp = _m
-	}
-	p.SetState(120)
-	p.GetErrorHandler().Sync(p)
-
-	for ok := true; ok; ok = _la == ApiParserParserID {
-		{
-			p.SetState(119)
-			p.KvLit()
-		}
-
-		p.SetState(122)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-	{
-		p.SetState(124)
-
-		_m := p.Match(ApiParserParserT__2)
-
-		localctx.(*InfoSpecContext).rp = _m
-	}
-
-	return localctx
-}
-
-// ITypeSpecContext is an interface to support dynamic dispatch.
-type ITypeSpecContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsTypeSpecContext differentiates from other interfaces.
-	IsTypeSpecContext()
-}
-
-type TypeSpecContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyTypeSpecContext() *TypeSpecContext {
-	p := new(TypeSpecContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeSpec
-	return p
-}
-
-func (*TypeSpecContext) IsTypeSpecContext() {}
-
-func NewTypeSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeSpecContext {
-	p := new(TypeSpecContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeSpec
-
-	return p
-}
-
-func (s *TypeSpecContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeSpecContext) TypeLit() ITypeLitContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeLitContext)
-}
-
-func (s *TypeSpecContext) TypeBlock() ITypeBlockContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeBlockContext)
-}
-
-func (s *TypeSpecContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeSpec(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeSpec() (localctx ITypeSpecContext) {
-	localctx = NewTypeSpecContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 18, ApiParserParserRULE_typeSpec)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.SetState(128)
-	p.GetErrorHandler().Sync(p)
-	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) {
-	case 1:
-		p.EnterOuterAlt(localctx, 1)
-		{
-			p.SetState(126)
-			p.TypeLit()
-		}
-
-	case 2:
-		p.EnterOuterAlt(localctx, 2)
-		{
-			p.SetState(127)
-			p.TypeBlock()
-		}
-
-	}
-
-	return localctx
-}
-
-// ITypeLitContext is an interface to support dynamic dispatch.
-type ITypeLitContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetTypeToken returns the typeToken token.
-	GetTypeToken() antlr.Token
-
-	// SetTypeToken sets the typeToken token.
-	SetTypeToken(antlr.Token)
-
-	// IsTypeLitContext differentiates from other interfaces.
-	IsTypeLitContext()
-}
-
-type TypeLitContext struct {
-	*antlr.BaseParserRuleContext
-	parser    antlr.Parser
-	typeToken antlr.Token
-}
-
-func NewEmptyTypeLitContext() *TypeLitContext {
-	p := new(TypeLitContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeLit
-	return p
-}
-
-func (*TypeLitContext) IsTypeLitContext() {}
-
-func NewTypeLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeLitContext {
-	p := new(TypeLitContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeLit
-
-	return p
-}
-
-func (s *TypeLitContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeLitContext) GetTypeToken() antlr.Token { return s.typeToken }
-
-func (s *TypeLitContext) SetTypeToken(v antlr.Token) { s.typeToken = v }
-
-func (s *TypeLitContext) TypeLitBody() ITypeLitBodyContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitBodyContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeLitBodyContext)
-}
-
-func (s *TypeLitContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *TypeLitContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeLit(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeLit() (localctx ITypeLitContext) {
-	localctx = NewTypeLitContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 20, ApiParserParserRULE_typeLit)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "type")
-	{
-		p.SetState(131)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*TypeLitContext).typeToken = _m
-	}
-	{
-		p.SetState(132)
-		p.TypeLitBody()
-	}
-
-	return localctx
-}
-
-// ITypeBlockContext is an interface to support dynamic dispatch.
-type ITypeBlockContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetTypeToken returns the typeToken token.
-	GetTypeToken() antlr.Token
-
-	// GetLp returns the lp token.
-	GetLp() antlr.Token
-
-	// GetRp returns the rp token.
-	GetRp() antlr.Token
-
-	// SetTypeToken sets the typeToken token.
-	SetTypeToken(antlr.Token)
-
-	// SetLp sets the lp token.
-	SetLp(antlr.Token)
-
-	// SetRp sets the rp token.
-	SetRp(antlr.Token)
-
-	// IsTypeBlockContext differentiates from other interfaces.
-	IsTypeBlockContext()
-}
-
-type TypeBlockContext struct {
-	*antlr.BaseParserRuleContext
-	parser    antlr.Parser
-	typeToken antlr.Token
-	lp        antlr.Token
-	rp        antlr.Token
-}
-
-func NewEmptyTypeBlockContext() *TypeBlockContext {
-	p := new(TypeBlockContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeBlock
-	return p
-}
-
-func (*TypeBlockContext) IsTypeBlockContext() {}
-
-func NewTypeBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockContext {
-	p := new(TypeBlockContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeBlock
-
-	return p
-}
-
-func (s *TypeBlockContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeBlockContext) GetTypeToken() antlr.Token { return s.typeToken }
-
-func (s *TypeBlockContext) GetLp() antlr.Token { return s.lp }
-
-func (s *TypeBlockContext) GetRp() antlr.Token { return s.rp }
-
-func (s *TypeBlockContext) SetTypeToken(v antlr.Token) { s.typeToken = v }
-
-func (s *TypeBlockContext) SetLp(v antlr.Token) { s.lp = v }
-
-func (s *TypeBlockContext) SetRp(v antlr.Token) { s.rp = v }
-
-func (s *TypeBlockContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *TypeBlockContext) AllTypeBlockBody() []ITypeBlockBodyContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*ITypeBlockBodyContext)(nil)).Elem())
-	tst := make([]ITypeBlockBodyContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(ITypeBlockBodyContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *TypeBlockContext) TypeBlockBody(i int) ITypeBlockBodyContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockBodyContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeBlockBodyContext)
-}
-
-func (s *TypeBlockContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeBlock(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeBlock() (localctx ITypeBlockContext) {
-	localctx = NewTypeBlockContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 22, ApiParserParserRULE_typeBlock)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "type")
-	{
-		p.SetState(135)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*TypeBlockContext).typeToken = _m
-	}
-	{
-		p.SetState(136)
-
-		_m := p.Match(ApiParserParserT__1)
-
-		localctx.(*TypeBlockContext).lp = _m
-	}
-	p.SetState(140)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	for _la == ApiParserParserID {
-		{
-			p.SetState(137)
-			p.TypeBlockBody()
-		}
-
-		p.SetState(142)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-	{
-		p.SetState(143)
-
-		_m := p.Match(ApiParserParserT__2)
-
-		localctx.(*TypeBlockContext).rp = _m
-	}
-
-	return localctx
-}
-
-// ITypeLitBodyContext is an interface to support dynamic dispatch.
-type ITypeLitBodyContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsTypeLitBodyContext differentiates from other interfaces.
-	IsTypeLitBodyContext()
-}
-
-type TypeLitBodyContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyTypeLitBodyContext() *TypeLitBodyContext {
-	p := new(TypeLitBodyContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeLitBody
-	return p
-}
-
-func (*TypeLitBodyContext) IsTypeLitBodyContext() {}
-
-func NewTypeLitBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeLitBodyContext {
-	p := new(TypeLitBodyContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeLitBody
-
-	return p
-}
-
-func (s *TypeLitBodyContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeLitBodyContext) TypeStruct() ITypeStructContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeStructContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeStructContext)
-}
-
-func (s *TypeLitBodyContext) TypeAlias() ITypeAliasContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeAliasContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeAliasContext)
-}
-
-func (s *TypeLitBodyContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeLitBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeLitBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeLitBody(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeLitBody() (localctx ITypeLitBodyContext) {
-	localctx = NewTypeLitBodyContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 24, ApiParserParserRULE_typeLitBody)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.SetState(147)
-	p.GetErrorHandler().Sync(p)
-	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
-	case 1:
-		p.EnterOuterAlt(localctx, 1)
-		{
-			p.SetState(145)
-			p.TypeStruct()
-		}
-
-	case 2:
-		p.EnterOuterAlt(localctx, 2)
-		{
-			p.SetState(146)
-			p.TypeAlias()
-		}
-
-	}
-
-	return localctx
-}
-
-// ITypeBlockBodyContext is an interface to support dynamic dispatch.
-type ITypeBlockBodyContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsTypeBlockBodyContext differentiates from other interfaces.
-	IsTypeBlockBodyContext()
-}
-
-type TypeBlockBodyContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyTypeBlockBodyContext() *TypeBlockBodyContext {
-	p := new(TypeBlockBodyContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeBlockBody
-	return p
-}
-
-func (*TypeBlockBodyContext) IsTypeBlockBodyContext() {}
-
-func NewTypeBlockBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockBodyContext {
-	p := new(TypeBlockBodyContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeBlockBody
-
-	return p
-}
-
-func (s *TypeBlockBodyContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeBlockBodyContext) TypeBlockStruct() ITypeBlockStructContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockStructContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeBlockStructContext)
-}
-
-func (s *TypeBlockBodyContext) TypeBlockAlias() ITypeBlockAliasContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockAliasContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeBlockAliasContext)
-}
-
-func (s *TypeBlockBodyContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeBlockBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeBlockBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeBlockBody(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeBlockBody() (localctx ITypeBlockBodyContext) {
-	localctx = NewTypeBlockBodyContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 26, ApiParserParserRULE_typeBlockBody)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.SetState(151)
-	p.GetErrorHandler().Sync(p)
-	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) {
-	case 1:
-		p.EnterOuterAlt(localctx, 1)
-		{
-			p.SetState(149)
-			p.TypeBlockStruct()
-		}
-
-	case 2:
-		p.EnterOuterAlt(localctx, 2)
-		{
-			p.SetState(150)
-			p.TypeBlockAlias()
-		}
-
-	}
-
-	return localctx
-}
-
-// ITypeStructContext is an interface to support dynamic dispatch.
-type ITypeStructContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetStructName returns the structName token.
-	GetStructName() antlr.Token
-
-	// GetStructToken returns the structToken token.
-	GetStructToken() antlr.Token
-
-	// GetLbrace returns the lbrace token.
-	GetLbrace() antlr.Token
-
-	// GetRbrace returns the rbrace token.
-	GetRbrace() antlr.Token
-
-	// SetStructName sets the structName token.
-	SetStructName(antlr.Token)
-
-	// SetStructToken sets the structToken token.
-	SetStructToken(antlr.Token)
-
-	// SetLbrace sets the lbrace token.
-	SetLbrace(antlr.Token)
-
-	// SetRbrace sets the rbrace token.
-	SetRbrace(antlr.Token)
-
-	// IsTypeStructContext differentiates from other interfaces.
-	IsTypeStructContext()
-}
-
-type TypeStructContext struct {
-	*antlr.BaseParserRuleContext
-	parser      antlr.Parser
-	structName  antlr.Token
-	structToken antlr.Token
-	lbrace      antlr.Token
-	rbrace      antlr.Token
-}
-
-func NewEmptyTypeStructContext() *TypeStructContext {
-	p := new(TypeStructContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeStruct
-	return p
-}
-
-func (*TypeStructContext) IsTypeStructContext() {}
-
-func NewTypeStructContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeStructContext {
-	p := new(TypeStructContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeStruct
-
-	return p
-}
-
-func (s *TypeStructContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeStructContext) GetStructName() antlr.Token { return s.structName }
-
-func (s *TypeStructContext) GetStructToken() antlr.Token { return s.structToken }
-
-func (s *TypeStructContext) GetLbrace() antlr.Token { return s.lbrace }
-
-func (s *TypeStructContext) GetRbrace() antlr.Token { return s.rbrace }
-
-func (s *TypeStructContext) SetStructName(v antlr.Token) { s.structName = v }
-
-func (s *TypeStructContext) SetStructToken(v antlr.Token) { s.structToken = v }
-
-func (s *TypeStructContext) SetLbrace(v antlr.Token) { s.lbrace = v }
-
-func (s *TypeStructContext) SetRbrace(v antlr.Token) { s.rbrace = v }
-
-func (s *TypeStructContext) AllID() []antlr.TerminalNode {
-	return s.GetTokens(ApiParserParserID)
-}
-
-func (s *TypeStructContext) ID(i int) antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, i)
-}
-
-func (s *TypeStructContext) AllField() []IFieldContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IFieldContext)(nil)).Elem())
-	tst := make([]IFieldContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IFieldContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *TypeStructContext) Field(i int) IFieldContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IFieldContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IFieldContext)
-}
-
-func (s *TypeStructContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeStructContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeStructContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeStruct(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeStruct() (localctx ITypeStructContext) {
-	localctx = NewTypeStructContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 28, ApiParserParserRULE_typeStruct)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	var _alt int
-
-	p.EnterOuterAlt(localctx, 1)
-	checkKeyword(p)
-	{
-		p.SetState(154)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*TypeStructContext).structName = _m
-	}
-	p.SetState(156)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserID {
-		{
-			p.SetState(155)
-
-			_m := p.Match(ApiParserParserID)
-
-			localctx.(*TypeStructContext).structToken = _m
-		}
-	}
-	{
-		p.SetState(158)
-
-		_m := p.Match(ApiParserParserT__3)
-
-		localctx.(*TypeStructContext).lbrace = _m
-	}
-	p.SetState(162)
-	p.GetErrorHandler().Sync(p)
-	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext())
-
-	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
-		if _alt == 1 {
-			{
-				p.SetState(159)
-				p.Field()
-			}
-		}
-		p.SetState(164)
-		p.GetErrorHandler().Sync(p)
-		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext())
-	}
-	{
-		p.SetState(165)
-
-		_m := p.Match(ApiParserParserT__4)
-
-		localctx.(*TypeStructContext).rbrace = _m
-	}
-
-	return localctx
-}
-
-// ITypeAliasContext is an interface to support dynamic dispatch.
-type ITypeAliasContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetAlias returns the alias token.
-	GetAlias() antlr.Token
-
-	// GetAssign returns the assign token.
-	GetAssign() antlr.Token
-
-	// SetAlias sets the alias token.
-	SetAlias(antlr.Token)
-
-	// SetAssign sets the assign token.
-	SetAssign(antlr.Token)
-
-	// IsTypeAliasContext differentiates from other interfaces.
-	IsTypeAliasContext()
-}
-
-type TypeAliasContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	alias  antlr.Token
-	assign antlr.Token
-}
-
-func NewEmptyTypeAliasContext() *TypeAliasContext {
-	p := new(TypeAliasContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeAlias
-	return p
-}
-
-func (*TypeAliasContext) IsTypeAliasContext() {}
-
-func NewTypeAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeAliasContext {
-	p := new(TypeAliasContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeAlias
-
-	return p
-}
-
-func (s *TypeAliasContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeAliasContext) GetAlias() antlr.Token { return s.alias }
-
-func (s *TypeAliasContext) GetAssign() antlr.Token { return s.assign }
-
-func (s *TypeAliasContext) SetAlias(v antlr.Token) { s.alias = v }
-
-func (s *TypeAliasContext) SetAssign(v antlr.Token) { s.assign = v }
-
-func (s *TypeAliasContext) DataType() IDataTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IDataTypeContext)
-}
-
-func (s *TypeAliasContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *TypeAliasContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeAlias(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeAlias() (localctx ITypeAliasContext) {
-	localctx = NewTypeAliasContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 30, ApiParserParserRULE_typeAlias)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	checkKeyword(p)
-	{
-		p.SetState(168)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*TypeAliasContext).alias = _m
-	}
-	p.SetState(170)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserT__0 {
-		{
-			p.SetState(169)
-
-			_m := p.Match(ApiParserParserT__0)
-
-			localctx.(*TypeAliasContext).assign = _m
-		}
-	}
-	{
-		p.SetState(172)
-		p.DataType()
-	}
-
-	return localctx
-}
-
-// ITypeBlockStructContext is an interface to support dynamic dispatch.
-type ITypeBlockStructContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetStructName returns the structName token.
-	GetStructName() antlr.Token
-
-	// GetStructToken returns the structToken token.
-	GetStructToken() antlr.Token
-
-	// GetLbrace returns the lbrace token.
-	GetLbrace() antlr.Token
-
-	// GetRbrace returns the rbrace token.
-	GetRbrace() antlr.Token
-
-	// SetStructName sets the structName token.
-	SetStructName(antlr.Token)
-
-	// SetStructToken sets the structToken token.
-	SetStructToken(antlr.Token)
-
-	// SetLbrace sets the lbrace token.
-	SetLbrace(antlr.Token)
-
-	// SetRbrace sets the rbrace token.
-	SetRbrace(antlr.Token)
-
-	// IsTypeBlockStructContext differentiates from other interfaces.
-	IsTypeBlockStructContext()
-}
-
-type TypeBlockStructContext struct {
-	*antlr.BaseParserRuleContext
-	parser      antlr.Parser
-	structName  antlr.Token
-	structToken antlr.Token
-	lbrace      antlr.Token
-	rbrace      antlr.Token
-}
-
-func NewEmptyTypeBlockStructContext() *TypeBlockStructContext {
-	p := new(TypeBlockStructContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeBlockStruct
-	return p
-}
-
-func (*TypeBlockStructContext) IsTypeBlockStructContext() {}
-
-func NewTypeBlockStructContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockStructContext {
-	p := new(TypeBlockStructContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeBlockStruct
-
-	return p
-}
-
-func (s *TypeBlockStructContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeBlockStructContext) GetStructName() antlr.Token { return s.structName }
-
-func (s *TypeBlockStructContext) GetStructToken() antlr.Token { return s.structToken }
-
-func (s *TypeBlockStructContext) GetLbrace() antlr.Token { return s.lbrace }
-
-func (s *TypeBlockStructContext) GetRbrace() antlr.Token { return s.rbrace }
-
-func (s *TypeBlockStructContext) SetStructName(v antlr.Token) { s.structName = v }
-
-func (s *TypeBlockStructContext) SetStructToken(v antlr.Token) { s.structToken = v }
-
-func (s *TypeBlockStructContext) SetLbrace(v antlr.Token) { s.lbrace = v }
-
-func (s *TypeBlockStructContext) SetRbrace(v antlr.Token) { s.rbrace = v }
-
-func (s *TypeBlockStructContext) AllID() []antlr.TerminalNode {
-	return s.GetTokens(ApiParserParserID)
-}
-
-func (s *TypeBlockStructContext) ID(i int) antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, i)
-}
-
-func (s *TypeBlockStructContext) AllField() []IFieldContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IFieldContext)(nil)).Elem())
-	tst := make([]IFieldContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IFieldContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *TypeBlockStructContext) Field(i int) IFieldContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IFieldContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IFieldContext)
-}
-
-func (s *TypeBlockStructContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeBlockStructContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeBlockStructContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeBlockStruct(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeBlockStruct() (localctx ITypeBlockStructContext) {
-	localctx = NewTypeBlockStructContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 32, ApiParserParserRULE_typeBlockStruct)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	var _alt int
-
-	p.EnterOuterAlt(localctx, 1)
-	checkKeyword(p)
-	{
-		p.SetState(175)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*TypeBlockStructContext).structName = _m
-	}
-	p.SetState(177)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserID {
-		{
-			p.SetState(176)
-
-			_m := p.Match(ApiParserParserID)
-
-			localctx.(*TypeBlockStructContext).structToken = _m
-		}
-	}
-	{
-		p.SetState(179)
-
-		_m := p.Match(ApiParserParserT__3)
-
-		localctx.(*TypeBlockStructContext).lbrace = _m
-	}
-	p.SetState(183)
-	p.GetErrorHandler().Sync(p)
-	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())
-
-	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
-		if _alt == 1 {
-			{
-				p.SetState(180)
-				p.Field()
-			}
-		}
-		p.SetState(185)
-		p.GetErrorHandler().Sync(p)
-		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())
-	}
-	{
-		p.SetState(186)
-
-		_m := p.Match(ApiParserParserT__4)
-
-		localctx.(*TypeBlockStructContext).rbrace = _m
-	}
-
-	return localctx
-}
-
-// ITypeBlockAliasContext is an interface to support dynamic dispatch.
-type ITypeBlockAliasContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetAlias returns the alias token.
-	GetAlias() antlr.Token
-
-	// GetAssign returns the assign token.
-	GetAssign() antlr.Token
-
-	// SetAlias sets the alias token.
-	SetAlias(antlr.Token)
-
-	// SetAssign sets the assign token.
-	SetAssign(antlr.Token)
-
-	// IsTypeBlockAliasContext differentiates from other interfaces.
-	IsTypeBlockAliasContext()
-}
-
-type TypeBlockAliasContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	alias  antlr.Token
-	assign antlr.Token
-}
-
-func NewEmptyTypeBlockAliasContext() *TypeBlockAliasContext {
-	p := new(TypeBlockAliasContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_typeBlockAlias
-	return p
-}
-
-func (*TypeBlockAliasContext) IsTypeBlockAliasContext() {}
-
-func NewTypeBlockAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockAliasContext {
-	p := new(TypeBlockAliasContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_typeBlockAlias
-
-	return p
-}
-
-func (s *TypeBlockAliasContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *TypeBlockAliasContext) GetAlias() antlr.Token { return s.alias }
-
-func (s *TypeBlockAliasContext) GetAssign() antlr.Token { return s.assign }
-
-func (s *TypeBlockAliasContext) SetAlias(v antlr.Token) { s.alias = v }
-
-func (s *TypeBlockAliasContext) SetAssign(v antlr.Token) { s.assign = v }
-
-func (s *TypeBlockAliasContext) DataType() IDataTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IDataTypeContext)
-}
-
-func (s *TypeBlockAliasContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *TypeBlockAliasContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *TypeBlockAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *TypeBlockAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitTypeBlockAlias(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) TypeBlockAlias() (localctx ITypeBlockAliasContext) {
-	localctx = NewTypeBlockAliasContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 34, ApiParserParserRULE_typeBlockAlias)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	checkKeyword(p)
-	{
-		p.SetState(189)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*TypeBlockAliasContext).alias = _m
-	}
-	p.SetState(191)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserT__0 {
-		{
-			p.SetState(190)
-
-			_m := p.Match(ApiParserParserT__0)
-
-			localctx.(*TypeBlockAliasContext).assign = _m
-		}
-	}
-	{
-		p.SetState(193)
-		p.DataType()
-	}
-
-	return localctx
-}
-
-// IFieldContext is an interface to support dynamic dispatch.
-type IFieldContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsFieldContext differentiates from other interfaces.
-	IsFieldContext()
-}
-
-type FieldContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyFieldContext() *FieldContext {
-	p := new(FieldContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_field
-	return p
-}
-
-func (*FieldContext) IsFieldContext() {}
-
-func NewFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldContext {
-	p := new(FieldContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_field
-
-	return p
-}
-
-func (s *FieldContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *FieldContext) NormalField() INormalFieldContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*INormalFieldContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(INormalFieldContext)
-}
-
-func (s *FieldContext) AnonymousFiled() IAnonymousFiledContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IAnonymousFiledContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IAnonymousFiledContext)
-}
-
-func (s *FieldContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *FieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *FieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitField(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) Field() (localctx IFieldContext) {
-	localctx = NewFieldContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 36, ApiParserParserRULE_field)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.SetState(198)
-	p.GetErrorHandler().Sync(p)
-	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) {
-	case 1:
-		p.EnterOuterAlt(localctx, 1)
-		p.SetState(195)
-
-		if !(isNormal(p)) {
-			panic(antlr.NewFailedPredicateException(p, "isNormal(p)", ""))
-		}
-		{
-			p.SetState(196)
-			p.NormalField()
-		}
-
-	case 2:
-		p.EnterOuterAlt(localctx, 2)
-		{
-			p.SetState(197)
-			p.AnonymousFiled()
-		}
-
-	}
-
-	return localctx
-}
-
-// INormalFieldContext is an interface to support dynamic dispatch.
-type INormalFieldContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetFieldName returns the fieldName token.
-	GetFieldName() antlr.Token
-
-	// GetTag returns the tag token.
-	GetTag() antlr.Token
-
-	// SetFieldName sets the fieldName token.
-	SetFieldName(antlr.Token)
-
-	// SetTag sets the tag token.
-	SetTag(antlr.Token)
-
-	// IsNormalFieldContext differentiates from other interfaces.
-	IsNormalFieldContext()
-}
-
-type NormalFieldContext struct {
-	*antlr.BaseParserRuleContext
-	parser    antlr.Parser
-	fieldName antlr.Token
-	tag       antlr.Token
-}
-
-func NewEmptyNormalFieldContext() *NormalFieldContext {
-	p := new(NormalFieldContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_normalField
-	return p
-}
-
-func (*NormalFieldContext) IsNormalFieldContext() {}
-
-func NewNormalFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NormalFieldContext {
-	p := new(NormalFieldContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_normalField
-
-	return p
-}
-
-func (s *NormalFieldContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *NormalFieldContext) GetFieldName() antlr.Token { return s.fieldName }
-
-func (s *NormalFieldContext) GetTag() antlr.Token { return s.tag }
-
-func (s *NormalFieldContext) SetFieldName(v antlr.Token) { s.fieldName = v }
-
-func (s *NormalFieldContext) SetTag(v antlr.Token) { s.tag = v }
-
-func (s *NormalFieldContext) DataType() IDataTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IDataTypeContext)
-}
-
-func (s *NormalFieldContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *NormalFieldContext) RAW_STRING() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserRAW_STRING, 0)
-}
-
-func (s *NormalFieldContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *NormalFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *NormalFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitNormalField(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) NormalField() (localctx INormalFieldContext) {
-	localctx = NewNormalFieldContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 38, ApiParserParserRULE_normalField)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	checkKeyword(p)
-	{
-		p.SetState(201)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*NormalFieldContext).fieldName = _m
-	}
-	{
-		p.SetState(202)
-		p.DataType()
-	}
-	p.SetState(204)
-	p.GetErrorHandler().Sync(p)
-
-	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 {
-		{
-			p.SetState(203)
-
-			_m := p.Match(ApiParserParserRAW_STRING)
-
-			localctx.(*NormalFieldContext).tag = _m
-		}
-	}
-
-	return localctx
-}
-
-// IAnonymousFiledContext is an interface to support dynamic dispatch.
-type IAnonymousFiledContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetStar returns the star token.
-	GetStar() antlr.Token
-
-	// SetStar sets the star token.
-	SetStar(antlr.Token)
-
-	// IsAnonymousFiledContext differentiates from other interfaces.
-	IsAnonymousFiledContext()
-}
-
-type AnonymousFiledContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	star   antlr.Token
-}
-
-func NewEmptyAnonymousFiledContext() *AnonymousFiledContext {
-	p := new(AnonymousFiledContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_anonymousFiled
-	return p
-}
-
-func (*AnonymousFiledContext) IsAnonymousFiledContext() {}
-
-func NewAnonymousFiledContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousFiledContext {
-	p := new(AnonymousFiledContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_anonymousFiled
-
-	return p
-}
-
-func (s *AnonymousFiledContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *AnonymousFiledContext) GetStar() antlr.Token { return s.star }
-
-func (s *AnonymousFiledContext) SetStar(v antlr.Token) { s.star = v }
-
-func (s *AnonymousFiledContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *AnonymousFiledContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *AnonymousFiledContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *AnonymousFiledContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitAnonymousFiled(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) AnonymousFiled() (localctx IAnonymousFiledContext) {
-	localctx = NewAnonymousFiledContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 40, ApiParserParserRULE_anonymousFiled)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	p.SetState(207)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserT__5 {
-		{
-			p.SetState(206)
-
-			_m := p.Match(ApiParserParserT__5)
-
-			localctx.(*AnonymousFiledContext).star = _m
-		}
-	}
-	{
-		p.SetState(209)
-		p.Match(ApiParserParserID)
-	}
-
-	return localctx
-}
-
-// IDataTypeContext is an interface to support dynamic dispatch.
-type IDataTypeContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetInter returns the inter token.
-	GetInter() antlr.Token
-
-	// GetTime returns the time token.
-	GetTime() antlr.Token
-
-	// SetInter sets the inter token.
-	SetInter(antlr.Token)
-
-	// SetTime sets the time token.
-	SetTime(antlr.Token)
-
-	// IsDataTypeContext differentiates from other interfaces.
-	IsDataTypeContext()
-}
-
-type DataTypeContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	inter  antlr.Token
-	time   antlr.Token
-}
-
-func NewEmptyDataTypeContext() *DataTypeContext {
-	p := new(DataTypeContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_dataType
-	return p
-}
-
-func (*DataTypeContext) IsDataTypeContext() {}
-
-func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext {
-	p := new(DataTypeContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_dataType
-
-	return p
-}
-
-func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *DataTypeContext) GetInter() antlr.Token { return s.inter }
-
-func (s *DataTypeContext) GetTime() antlr.Token { return s.time }
-
-func (s *DataTypeContext) SetInter(v antlr.Token) { s.inter = v }
-
-func (s *DataTypeContext) SetTime(v antlr.Token) { s.time = v }
-
-func (s *DataTypeContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *DataTypeContext) MapType() IMapTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IMapTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IMapTypeContext)
-}
-
-func (s *DataTypeContext) ArrayType() IArrayTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IArrayTypeContext)
-}
-
-func (s *DataTypeContext) INTERFACE() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserINTERFACE, 0)
-}
-
-func (s *DataTypeContext) PointerType() IPointerTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IPointerTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IPointerTypeContext)
-}
-
-func (s *DataTypeContext) TypeStruct() ITypeStructContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*ITypeStructContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(ITypeStructContext)
-}
-
-func (s *DataTypeContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *DataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitDataType(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) DataType() (localctx IDataTypeContext) {
-	localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 42, ApiParserParserRULE_dataType)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.SetState(219)
-	p.GetErrorHandler().Sync(p)
-	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) {
-	case 1:
-		p.EnterOuterAlt(localctx, 1)
-		isInterface(p)
-		{
-			p.SetState(212)
-			p.Match(ApiParserParserID)
-		}
-
-	case 2:
-		p.EnterOuterAlt(localctx, 2)
-		{
-			p.SetState(213)
-			p.MapType()
-		}
-
-	case 3:
-		p.EnterOuterAlt(localctx, 3)
-		{
-			p.SetState(214)
-			p.ArrayType()
-		}
-
-	case 4:
-		p.EnterOuterAlt(localctx, 4)
-		{
-			p.SetState(215)
-
-			_m := p.Match(ApiParserParserINTERFACE)
-
-			localctx.(*DataTypeContext).inter = _m
-		}
-
-	case 5:
-		p.EnterOuterAlt(localctx, 5)
-		{
-			p.SetState(216)
-
-			_m := p.Match(ApiParserParserT__6)
-
-			localctx.(*DataTypeContext).time = _m
-		}
-
-	case 6:
-		p.EnterOuterAlt(localctx, 6)
-		{
-			p.SetState(217)
-			p.PointerType()
-		}
-
-	case 7:
-		p.EnterOuterAlt(localctx, 7)
-		{
-			p.SetState(218)
-			p.TypeStruct()
-		}
-
-	}
-
-	return localctx
-}
-
-// IPointerTypeContext is an interface to support dynamic dispatch.
-type IPointerTypeContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetStar returns the star token.
-	GetStar() antlr.Token
-
-	// SetStar sets the star token.
-	SetStar(antlr.Token)
-
-	// IsPointerTypeContext differentiates from other interfaces.
-	IsPointerTypeContext()
-}
-
-type PointerTypeContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	star   antlr.Token
-}
-
-func NewEmptyPointerTypeContext() *PointerTypeContext {
-	p := new(PointerTypeContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_pointerType
-	return p
-}
-
-func (*PointerTypeContext) IsPointerTypeContext() {}
-
-func NewPointerTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PointerTypeContext {
-	p := new(PointerTypeContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_pointerType
-
-	return p
-}
-
-func (s *PointerTypeContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *PointerTypeContext) GetStar() antlr.Token { return s.star }
-
-func (s *PointerTypeContext) SetStar(v antlr.Token) { s.star = v }
-
-func (s *PointerTypeContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *PointerTypeContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *PointerTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *PointerTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitPointerType(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) PointerType() (localctx IPointerTypeContext) {
-	localctx = NewPointerTypeContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 44, ApiParserParserRULE_pointerType)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(221)
-
-		_m := p.Match(ApiParserParserT__5)
-
-		localctx.(*PointerTypeContext).star = _m
-	}
-	checkKeyword(p)
-	{
-		p.SetState(223)
-		p.Match(ApiParserParserID)
-	}
-
-	return localctx
-}
-
-// IMapTypeContext is an interface to support dynamic dispatch.
-type IMapTypeContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetMapToken returns the mapToken token.
-	GetMapToken() antlr.Token
-
-	// GetLbrack returns the lbrack token.
-	GetLbrack() antlr.Token
-
-	// GetKey returns the key token.
-	GetKey() antlr.Token
-
-	// GetRbrack returns the rbrack token.
-	GetRbrack() antlr.Token
-
-	// SetMapToken sets the mapToken token.
-	SetMapToken(antlr.Token)
-
-	// SetLbrack sets the lbrack token.
-	SetLbrack(antlr.Token)
-
-	// SetKey sets the key token.
-	SetKey(antlr.Token)
-
-	// SetRbrack sets the rbrack token.
-	SetRbrack(antlr.Token)
-
-	// GetValue returns the value rule contexts.
-	GetValue() IDataTypeContext
-
-	// SetValue sets the value rule contexts.
-	SetValue(IDataTypeContext)
-
-	// IsMapTypeContext differentiates from other interfaces.
-	IsMapTypeContext()
-}
-
-type MapTypeContext struct {
-	*antlr.BaseParserRuleContext
-	parser   antlr.Parser
-	mapToken antlr.Token
-	lbrack   antlr.Token
-	key      antlr.Token
-	rbrack   antlr.Token
-	value    IDataTypeContext
-}
-
-func NewEmptyMapTypeContext() *MapTypeContext {
-	p := new(MapTypeContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_mapType
-	return p
-}
-
-func (*MapTypeContext) IsMapTypeContext() {}
-
-func NewMapTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapTypeContext {
-	p := new(MapTypeContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_mapType
-
-	return p
-}
-
-func (s *MapTypeContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *MapTypeContext) GetMapToken() antlr.Token { return s.mapToken }
-
-func (s *MapTypeContext) GetLbrack() antlr.Token { return s.lbrack }
-
-func (s *MapTypeContext) GetKey() antlr.Token { return s.key }
-
-func (s *MapTypeContext) GetRbrack() antlr.Token { return s.rbrack }
-
-func (s *MapTypeContext) SetMapToken(v antlr.Token) { s.mapToken = v }
-
-func (s *MapTypeContext) SetLbrack(v antlr.Token) { s.lbrack = v }
-
-func (s *MapTypeContext) SetKey(v antlr.Token) { s.key = v }
-
-func (s *MapTypeContext) SetRbrack(v antlr.Token) { s.rbrack = v }
-
-func (s *MapTypeContext) GetValue() IDataTypeContext { return s.value }
-
-func (s *MapTypeContext) SetValue(v IDataTypeContext) { s.value = v }
-
-func (s *MapTypeContext) AllID() []antlr.TerminalNode {
-	return s.GetTokens(ApiParserParserID)
-}
-
-func (s *MapTypeContext) ID(i int) antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, i)
-}
-
-func (s *MapTypeContext) DataType() IDataTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IDataTypeContext)
-}
-
-func (s *MapTypeContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *MapTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *MapTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitMapType(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) MapType() (localctx IMapTypeContext) {
-	localctx = NewMapTypeContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 46, ApiParserParserRULE_mapType)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "map")
-	{
-		p.SetState(226)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*MapTypeContext).mapToken = _m
-	}
-	{
-		p.SetState(227)
-
-		_m := p.Match(ApiParserParserT__7)
-
-		localctx.(*MapTypeContext).lbrack = _m
-	}
-	checkKey(p)
-	{
-		p.SetState(229)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*MapTypeContext).key = _m
-	}
-	{
-		p.SetState(230)
-
-		_m := p.Match(ApiParserParserT__8)
-
-		localctx.(*MapTypeContext).rbrack = _m
-	}
-	{
-		p.SetState(231)
-
-		_x := p.DataType()
-
-		localctx.(*MapTypeContext).value = _x
-	}
-
-	return localctx
-}
-
-// IArrayTypeContext is an interface to support dynamic dispatch.
-type IArrayTypeContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetLbrack returns the lbrack token.
-	GetLbrack() antlr.Token
-
-	// GetRbrack returns the rbrack token.
-	GetRbrack() antlr.Token
-
-	// SetLbrack sets the lbrack token.
-	SetLbrack(antlr.Token)
-
-	// SetRbrack sets the rbrack token.
-	SetRbrack(antlr.Token)
-
-	// IsArrayTypeContext differentiates from other interfaces.
-	IsArrayTypeContext()
-}
-
-type ArrayTypeContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	lbrack antlr.Token
-	rbrack antlr.Token
-}
-
-func NewEmptyArrayTypeContext() *ArrayTypeContext {
-	p := new(ArrayTypeContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_arrayType
-	return p
-}
-
-func (*ArrayTypeContext) IsArrayTypeContext() {}
-
-func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayTypeContext {
-	p := new(ArrayTypeContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_arrayType
-
-	return p
-}
-
-func (s *ArrayTypeContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ArrayTypeContext) GetLbrack() antlr.Token { return s.lbrack }
-
-func (s *ArrayTypeContext) GetRbrack() antlr.Token { return s.rbrack }
-
-func (s *ArrayTypeContext) SetLbrack(v antlr.Token) { s.lbrack = v }
-
-func (s *ArrayTypeContext) SetRbrack(v antlr.Token) { s.rbrack = v }
-
-func (s *ArrayTypeContext) DataType() IDataTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IDataTypeContext)
-}
-
-func (s *ArrayTypeContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ArrayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ArrayTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitArrayType(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ArrayType() (localctx IArrayTypeContext) {
-	localctx = NewArrayTypeContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 48, ApiParserParserRULE_arrayType)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(233)
-
-		_m := p.Match(ApiParserParserT__7)
-
-		localctx.(*ArrayTypeContext).lbrack = _m
-	}
-	{
-		p.SetState(234)
-
-		_m := p.Match(ApiParserParserT__8)
-
-		localctx.(*ArrayTypeContext).rbrack = _m
-	}
-	{
-		p.SetState(235)
-		p.DataType()
-	}
-
-	return localctx
-}
-
-// IServiceSpecContext is an interface to support dynamic dispatch.
-type IServiceSpecContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsServiceSpecContext differentiates from other interfaces.
-	IsServiceSpecContext()
-}
-
-type ServiceSpecContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyServiceSpecContext() *ServiceSpecContext {
-	p := new(ServiceSpecContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_serviceSpec
-	return p
-}
-
-func (*ServiceSpecContext) IsServiceSpecContext() {}
-
-func NewServiceSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceSpecContext {
-	p := new(ServiceSpecContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_serviceSpec
-
-	return p
-}
-
-func (s *ServiceSpecContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ServiceSpecContext) ServiceApi() IServiceApiContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IServiceApiContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IServiceApiContext)
-}
-
-func (s *ServiceSpecContext) AtServer() IAtServerContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IAtServerContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IAtServerContext)
-}
-
-func (s *ServiceSpecContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ServiceSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ServiceSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitServiceSpec(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ServiceSpec() (localctx IServiceSpecContext) {
-	localctx = NewServiceSpecContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 50, ApiParserParserRULE_serviceSpec)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	p.SetState(238)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserATSERVER {
-		{
-			p.SetState(237)
-			p.AtServer()
-		}
-	}
-	{
-		p.SetState(240)
-		p.ServiceApi()
-	}
-
-	return localctx
-}
-
-// IAtServerContext is an interface to support dynamic dispatch.
-type IAtServerContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetLp returns the lp token.
-	GetLp() antlr.Token
-
-	// GetRp returns the rp token.
-	GetRp() antlr.Token
-
-	// SetLp sets the lp token.
-	SetLp(antlr.Token)
-
-	// SetRp sets the rp token.
-	SetRp(antlr.Token)
-
-	// IsAtServerContext differentiates from other interfaces.
-	IsAtServerContext()
-}
-
-type AtServerContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	lp     antlr.Token
-	rp     antlr.Token
-}
-
-func NewEmptyAtServerContext() *AtServerContext {
-	p := new(AtServerContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_atServer
-	return p
-}
-
-func (*AtServerContext) IsAtServerContext() {}
-
-func NewAtServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtServerContext {
-	p := new(AtServerContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_atServer
-
-	return p
-}
-
-func (s *AtServerContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *AtServerContext) GetLp() antlr.Token { return s.lp }
-
-func (s *AtServerContext) GetRp() antlr.Token { return s.rp }
-
-func (s *AtServerContext) SetLp(v antlr.Token) { s.lp = v }
-
-func (s *AtServerContext) SetRp(v antlr.Token) { s.rp = v }
-
-func (s *AtServerContext) ATSERVER() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserATSERVER, 0)
-}
-
-func (s *AtServerContext) AllKvLit() []IKvLitContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())
-	tst := make([]IKvLitContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IKvLitContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *AtServerContext) KvLit(i int) IKvLitContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IKvLitContext)
-}
-
-func (s *AtServerContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *AtServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *AtServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitAtServer(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) AtServer() (localctx IAtServerContext) {
-	localctx = NewAtServerContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 52, ApiParserParserRULE_atServer)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(242)
-		p.Match(ApiParserParserATSERVER)
-	}
-	{
-		p.SetState(243)
-
-		_m := p.Match(ApiParserParserT__1)
-
-		localctx.(*AtServerContext).lp = _m
-	}
-	p.SetState(245)
-	p.GetErrorHandler().Sync(p)
-
-	for ok := true; ok; ok = _la == ApiParserParserID {
-		{
-			p.SetState(244)
-			p.KvLit()
-		}
-
-		p.SetState(247)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-	{
-		p.SetState(249)
-
-		_m := p.Match(ApiParserParserT__2)
-
-		localctx.(*AtServerContext).rp = _m
-	}
-
-	return localctx
-}
-
-// IServiceApiContext is an interface to support dynamic dispatch.
-type IServiceApiContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetServiceToken returns the serviceToken token.
-	GetServiceToken() antlr.Token
-
-	// GetLbrace returns the lbrace token.
-	GetLbrace() antlr.Token
-
-	// GetRbrace returns the rbrace token.
-	GetRbrace() antlr.Token
-
-	// SetServiceToken sets the serviceToken token.
-	SetServiceToken(antlr.Token)
-
-	// SetLbrace sets the lbrace token.
-	SetLbrace(antlr.Token)
-
-	// SetRbrace sets the rbrace token.
-	SetRbrace(antlr.Token)
-
-	// IsServiceApiContext differentiates from other interfaces.
-	IsServiceApiContext()
-}
-
-type ServiceApiContext struct {
-	*antlr.BaseParserRuleContext
-	parser       antlr.Parser
-	serviceToken antlr.Token
-	lbrace       antlr.Token
-	rbrace       antlr.Token
-}
-
-func NewEmptyServiceApiContext() *ServiceApiContext {
-	p := new(ServiceApiContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_serviceApi
-	return p
-}
-
-func (*ServiceApiContext) IsServiceApiContext() {}
-
-func NewServiceApiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceApiContext {
-	p := new(ServiceApiContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_serviceApi
-
-	return p
-}
-
-func (s *ServiceApiContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ServiceApiContext) GetServiceToken() antlr.Token { return s.serviceToken }
-
-func (s *ServiceApiContext) GetLbrace() antlr.Token { return s.lbrace }
-
-func (s *ServiceApiContext) GetRbrace() antlr.Token { return s.rbrace }
-
-func (s *ServiceApiContext) SetServiceToken(v antlr.Token) { s.serviceToken = v }
-
-func (s *ServiceApiContext) SetLbrace(v antlr.Token) { s.lbrace = v }
-
-func (s *ServiceApiContext) SetRbrace(v antlr.Token) { s.rbrace = v }
-
-func (s *ServiceApiContext) ServiceName() IServiceNameContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IServiceNameContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IServiceNameContext)
-}
-
-func (s *ServiceApiContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *ServiceApiContext) AllServiceRoute() []IServiceRouteContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IServiceRouteContext)(nil)).Elem())
-	tst := make([]IServiceRouteContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IServiceRouteContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *ServiceApiContext) ServiceRoute(i int) IServiceRouteContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IServiceRouteContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IServiceRouteContext)
-}
-
-func (s *ServiceApiContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ServiceApiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ServiceApiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitServiceApi(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ServiceApi() (localctx IServiceApiContext) {
-	localctx = NewServiceApiContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 54, ApiParserParserRULE_serviceApi)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	match(p, "service")
-	{
-		p.SetState(252)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*ServiceApiContext).serviceToken = _m
-	}
-	{
-		p.SetState(253)
-		p.ServiceName()
-	}
-	{
-		p.SetState(254)
-
-		_m := p.Match(ApiParserParserT__3)
-
-		localctx.(*ServiceApiContext).lbrace = _m
-	}
-	p.SetState(258)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	for ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ApiParserParserATDOC)|(1<<ApiParserParserATHANDLER)|(1<<ApiParserParserATSERVER))) != 0 {
-		{
-			p.SetState(255)
-			p.ServiceRoute()
-		}
-
-		p.SetState(260)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-	{
-		p.SetState(261)
-
-		_m := p.Match(ApiParserParserT__4)
-
-		localctx.(*ServiceApiContext).rbrace = _m
-	}
-
-	return localctx
-}
-
-// IServiceRouteContext is an interface to support dynamic dispatch.
-type IServiceRouteContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsServiceRouteContext differentiates from other interfaces.
-	IsServiceRouteContext()
-}
-
-type ServiceRouteContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyServiceRouteContext() *ServiceRouteContext {
-	p := new(ServiceRouteContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_serviceRoute
-	return p
-}
-
-func (*ServiceRouteContext) IsServiceRouteContext() {}
-
-func NewServiceRouteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceRouteContext {
-	p := new(ServiceRouteContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_serviceRoute
-
-	return p
-}
-
-func (s *ServiceRouteContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ServiceRouteContext) Route() IRouteContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IRouteContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IRouteContext)
-}
-
-func (s *ServiceRouteContext) AtServer() IAtServerContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IAtServerContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IAtServerContext)
-}
-
-func (s *ServiceRouteContext) AtHandler() IAtHandlerContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IAtHandlerContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IAtHandlerContext)
-}
-
-func (s *ServiceRouteContext) AtDoc() IAtDocContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IAtDocContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IAtDocContext)
-}
-
-func (s *ServiceRouteContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ServiceRouteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ServiceRouteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitServiceRoute(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ServiceRoute() (localctx IServiceRouteContext) {
-	localctx = NewServiceRouteContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 56, ApiParserParserRULE_serviceRoute)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	p.SetState(264)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserATDOC {
-		{
-			p.SetState(263)
-			p.AtDoc()
-		}
-	}
-	p.SetState(268)
-	p.GetErrorHandler().Sync(p)
-
-	switch p.GetTokenStream().LA(1) {
-	case ApiParserParserATSERVER:
-		{
-			p.SetState(266)
-			p.AtServer()
-		}
-
-	case ApiParserParserATHANDLER:
-		{
-			p.SetState(267)
-			p.AtHandler()
-		}
-
-	default:
-		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
-	}
-	{
-		p.SetState(270)
-		p.Route()
-	}
-
-	return localctx
-}
-
-// IAtDocContext is an interface to support dynamic dispatch.
-type IAtDocContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetLp returns the lp token.
-	GetLp() antlr.Token
-
-	// GetRp returns the rp token.
-	GetRp() antlr.Token
-
-	// SetLp sets the lp token.
-	SetLp(antlr.Token)
-
-	// SetRp sets the rp token.
-	SetRp(antlr.Token)
-
-	// IsAtDocContext differentiates from other interfaces.
-	IsAtDocContext()
-}
-
-type AtDocContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	lp     antlr.Token
-	rp     antlr.Token
-}
-
-func NewEmptyAtDocContext() *AtDocContext {
-	p := new(AtDocContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_atDoc
-	return p
-}
-
-func (*AtDocContext) IsAtDocContext() {}
-
-func NewAtDocContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtDocContext {
-	p := new(AtDocContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_atDoc
-
-	return p
-}
-
-func (s *AtDocContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *AtDocContext) GetLp() antlr.Token { return s.lp }
-
-func (s *AtDocContext) GetRp() antlr.Token { return s.rp }
-
-func (s *AtDocContext) SetLp(v antlr.Token) { s.lp = v }
-
-func (s *AtDocContext) SetRp(v antlr.Token) { s.rp = v }
-
-func (s *AtDocContext) ATDOC() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserATDOC, 0)
-}
-
-func (s *AtDocContext) STRING() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserSTRING, 0)
-}
-
-func (s *AtDocContext) AllKvLit() []IKvLitContext {
-	ts := s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())
-	tst := make([]IKvLitContext, len(ts))
-
-	for i, t := range ts {
-		if t != nil {
-			tst[i] = t.(IKvLitContext)
-		}
-	}
-
-	return tst
-}
-
-func (s *AtDocContext) KvLit(i int) IKvLitContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IKvLitContext)
-}
-
-func (s *AtDocContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *AtDocContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *AtDocContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitAtDoc(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) AtDoc() (localctx IAtDocContext) {
-	localctx = NewAtDocContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 58, ApiParserParserRULE_atDoc)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(272)
-		p.Match(ApiParserParserATDOC)
-	}
-	p.SetState(274)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserT__1 {
-		{
-			p.SetState(273)
-
-			_m := p.Match(ApiParserParserT__1)
-
-			localctx.(*AtDocContext).lp = _m
-		}
-	}
-	p.SetState(282)
-	p.GetErrorHandler().Sync(p)
-
-	switch p.GetTokenStream().LA(1) {
-	case ApiParserParserID:
-		p.SetState(277)
-		p.GetErrorHandler().Sync(p)
-
-		for ok := true; ok; ok = _la == ApiParserParserID {
-			{
-				p.SetState(276)
-				p.KvLit()
-			}
-
-			p.SetState(279)
-			p.GetErrorHandler().Sync(p)
-			_la = p.GetTokenStream().LA(1)
-		}
-
-	case ApiParserParserSTRING:
-		{
-			p.SetState(281)
-			p.Match(ApiParserParserSTRING)
-		}
-
-	default:
-		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
-	}
-	p.SetState(285)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserT__2 {
-		{
-			p.SetState(284)
-
-			_m := p.Match(ApiParserParserT__2)
-
-			localctx.(*AtDocContext).rp = _m
-		}
-	}
-
-	return localctx
-}
-
-// IAtHandlerContext is an interface to support dynamic dispatch.
-type IAtHandlerContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsAtHandlerContext differentiates from other interfaces.
-	IsAtHandlerContext()
-}
-
-type AtHandlerContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyAtHandlerContext() *AtHandlerContext {
-	p := new(AtHandlerContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_atHandler
-	return p
-}
-
-func (*AtHandlerContext) IsAtHandlerContext() {}
-
-func NewAtHandlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtHandlerContext {
-	p := new(AtHandlerContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_atHandler
-
-	return p
-}
-
-func (s *AtHandlerContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *AtHandlerContext) ATHANDLER() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserATHANDLER, 0)
-}
-
-func (s *AtHandlerContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *AtHandlerContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *AtHandlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *AtHandlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitAtHandler(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) AtHandler() (localctx IAtHandlerContext) {
-	localctx = NewAtHandlerContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 60, ApiParserParserRULE_atHandler)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(287)
-		p.Match(ApiParserParserATHANDLER)
-	}
-	{
-		p.SetState(288)
-		p.Match(ApiParserParserID)
-	}
-
-	return localctx
-}
-
-// IRouteContext is an interface to support dynamic dispatch.
-type IRouteContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetHttpMethod returns the httpMethod token.
-	GetHttpMethod() antlr.Token
-
-	// GetReturnToken returns the returnToken token.
-	GetReturnToken() antlr.Token
-
-	// SetHttpMethod sets the httpMethod token.
-	SetHttpMethod(antlr.Token)
-
-	// SetReturnToken sets the returnToken token.
-	SetReturnToken(antlr.Token)
-
-	// GetRequest returns the request rule contexts.
-	GetRequest() IBodyContext
-
-	// GetResponse returns the response rule contexts.
-	GetResponse() IReplybodyContext
-
-	// SetRequest sets the request rule contexts.
-	SetRequest(IBodyContext)
-
-	// SetResponse sets the response rule contexts.
-	SetResponse(IReplybodyContext)
-
-	// IsRouteContext differentiates from other interfaces.
-	IsRouteContext()
-}
-
-type RouteContext struct {
-	*antlr.BaseParserRuleContext
-	parser      antlr.Parser
-	httpMethod  antlr.Token
-	request     IBodyContext
-	returnToken antlr.Token
-	response    IReplybodyContext
-}
-
-func NewEmptyRouteContext() *RouteContext {
-	p := new(RouteContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_route
-	return p
-}
-
-func (*RouteContext) IsRouteContext() {}
-
-func NewRouteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RouteContext {
-	p := new(RouteContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_route
-
-	return p
-}
-
-func (s *RouteContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *RouteContext) GetHttpMethod() antlr.Token { return s.httpMethod }
-
-func (s *RouteContext) GetReturnToken() antlr.Token { return s.returnToken }
-
-func (s *RouteContext) SetHttpMethod(v antlr.Token) { s.httpMethod = v }
-
-func (s *RouteContext) SetReturnToken(v antlr.Token) { s.returnToken = v }
-
-func (s *RouteContext) GetRequest() IBodyContext { return s.request }
-
-func (s *RouteContext) GetResponse() IReplybodyContext { return s.response }
-
-func (s *RouteContext) SetRequest(v IBodyContext) { s.request = v }
-
-func (s *RouteContext) SetResponse(v IReplybodyContext) { s.response = v }
-
-func (s *RouteContext) Path() IPathContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IPathContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IPathContext)
-}
-
-func (s *RouteContext) AllID() []antlr.TerminalNode {
-	return s.GetTokens(ApiParserParserID)
-}
-
-func (s *RouteContext) ID(i int) antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, i)
-}
-
-func (s *RouteContext) Body() IBodyContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IBodyContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IBodyContext)
-}
-
-func (s *RouteContext) Replybody() IReplybodyContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IReplybodyContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IReplybodyContext)
-}
-
-func (s *RouteContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *RouteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *RouteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitRoute(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) Route() (localctx IRouteContext) {
-	localctx = NewRouteContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 62, ApiParserParserRULE_route)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	checkHTTPMethod(p)
-	{
-		p.SetState(291)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*RouteContext).httpMethod = _m
-	}
-	{
-		p.SetState(292)
-		p.Path()
-	}
-	p.SetState(294)
-	p.GetErrorHandler().Sync(p)
-
-	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 {
-		{
-			p.SetState(293)
-
-			_x := p.Body()
-
-			localctx.(*RouteContext).request = _x
-		}
-	}
-	p.SetState(297)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserID {
-		{
-			p.SetState(296)
-
-			_m := p.Match(ApiParserParserID)
-
-			localctx.(*RouteContext).returnToken = _m
-		}
-	}
-	p.SetState(300)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserT__1 {
-		{
-			p.SetState(299)
-
-			_x := p.Replybody()
-
-			localctx.(*RouteContext).response = _x
-		}
-	}
-
-	return localctx
-}
-
-// IBodyContext is an interface to support dynamic dispatch.
-type IBodyContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetLp returns the lp token.
-	GetLp() antlr.Token
-
-	// GetRp returns the rp token.
-	GetRp() antlr.Token
-
-	// SetLp sets the lp token.
-	SetLp(antlr.Token)
-
-	// SetRp sets the rp token.
-	SetRp(antlr.Token)
-
-	// IsBodyContext differentiates from other interfaces.
-	IsBodyContext()
-}
-
-type BodyContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	lp     antlr.Token
-	rp     antlr.Token
-}
-
-func NewEmptyBodyContext() *BodyContext {
-	p := new(BodyContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_body
-	return p
-}
-
-func (*BodyContext) IsBodyContext() {}
-
-func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext {
-	p := new(BodyContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_body
-
-	return p
-}
-
-func (s *BodyContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *BodyContext) GetLp() antlr.Token { return s.lp }
-
-func (s *BodyContext) GetRp() antlr.Token { return s.rp }
-
-func (s *BodyContext) SetLp(v antlr.Token) { s.lp = v }
-
-func (s *BodyContext) SetRp(v antlr.Token) { s.rp = v }
-
-func (s *BodyContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *BodyContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *BodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *BodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitBody(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) Body() (localctx IBodyContext) {
-	localctx = NewBodyContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 64, ApiParserParserRULE_body)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(302)
-
-		_m := p.Match(ApiParserParserT__1)
-
-		localctx.(*BodyContext).lp = _m
-	}
-	p.SetState(304)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if _la == ApiParserParserID {
-		{
-			p.SetState(303)
-			p.Match(ApiParserParserID)
-		}
-	}
-	{
-		p.SetState(306)
-
-		_m := p.Match(ApiParserParserT__2)
-
-		localctx.(*BodyContext).rp = _m
-	}
-
-	return localctx
-}
-
-// IReplybodyContext is an interface to support dynamic dispatch.
-type IReplybodyContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetLp returns the lp token.
-	GetLp() antlr.Token
-
-	// GetRp returns the rp token.
-	GetRp() antlr.Token
-
-	// SetLp sets the lp token.
-	SetLp(antlr.Token)
-
-	// SetRp sets the rp token.
-	SetRp(antlr.Token)
-
-	// IsReplybodyContext differentiates from other interfaces.
-	IsReplybodyContext()
-}
-
-type ReplybodyContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	lp     antlr.Token
-	rp     antlr.Token
-}
-
-func NewEmptyReplybodyContext() *ReplybodyContext {
-	p := new(ReplybodyContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_replybody
-	return p
-}
-
-func (*ReplybodyContext) IsReplybodyContext() {}
-
-func NewReplybodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplybodyContext {
-	p := new(ReplybodyContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_replybody
-
-	return p
-}
-
-func (s *ReplybodyContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ReplybodyContext) GetLp() antlr.Token { return s.lp }
-
-func (s *ReplybodyContext) GetRp() antlr.Token { return s.rp }
-
-func (s *ReplybodyContext) SetLp(v antlr.Token) { s.lp = v }
-
-func (s *ReplybodyContext) SetRp(v antlr.Token) { s.rp = v }
-
-func (s *ReplybodyContext) DataType() IDataTypeContext {
-	t := s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
-
-	if t == nil {
-		return nil
-	}
-
-	return t.(IDataTypeContext)
-}
-
-func (s *ReplybodyContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ReplybodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ReplybodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitReplybody(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) Replybody() (localctx IReplybodyContext) {
-	localctx = NewReplybodyContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 66, ApiParserParserRULE_replybody)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(308)
-
-		_m := p.Match(ApiParserParserT__1)
-
-		localctx.(*ReplybodyContext).lp = _m
-	}
-	p.SetState(310)
-	p.GetErrorHandler().Sync(p)
-	_la = p.GetTokenStream().LA(1)
-
-	if ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ApiParserParserT__5)|(1<<ApiParserParserT__6)|(1<<ApiParserParserT__7)|(1<<ApiParserParserINTERFACE)|(1<<ApiParserParserID))) != 0 {
-		{
-			p.SetState(309)
-			p.DataType()
-		}
-	}
-	{
-		p.SetState(312)
-
-		_m := p.Match(ApiParserParserT__2)
-
-		localctx.(*ReplybodyContext).rp = _m
-	}
-
-	return localctx
-}
-
-// IKvLitContext is an interface to support dynamic dispatch.
-type IKvLitContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// GetKey returns the key token.
-	GetKey() antlr.Token
-
-	// GetValue returns the value token.
-	GetValue() antlr.Token
-
-	// SetKey sets the key token.
-	SetKey(antlr.Token)
-
-	// SetValue sets the value token.
-	SetValue(antlr.Token)
-
-	// IsKvLitContext differentiates from other interfaces.
-	IsKvLitContext()
-}
-
-type KvLitContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-	key    antlr.Token
-	value  antlr.Token
-}
-
-func NewEmptyKvLitContext() *KvLitContext {
-	p := new(KvLitContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_kvLit
-	return p
-}
-
-func (*KvLitContext) IsKvLitContext() {}
-
-func NewKvLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KvLitContext {
-	p := new(KvLitContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_kvLit
-
-	return p
-}
-
-func (s *KvLitContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *KvLitContext) GetKey() antlr.Token { return s.key }
-
-func (s *KvLitContext) GetValue() antlr.Token { return s.value }
-
-func (s *KvLitContext) SetKey(v antlr.Token) { s.key = v }
-
-func (s *KvLitContext) SetValue(v antlr.Token) { s.value = v }
-
-func (s *KvLitContext) ID() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, 0)
-}
-
-func (s *KvLitContext) LINE_VALUE() antlr.TerminalNode {
-	return s.GetToken(ApiParserParserLINE_VALUE, 0)
-}
-
-func (s *KvLitContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *KvLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *KvLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitKvLit(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) KvLit() (localctx IKvLitContext) {
-	localctx = NewKvLitContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 68, ApiParserParserRULE_kvLit)
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	{
-		p.SetState(314)
-
-		_m := p.Match(ApiParserParserID)
-
-		localctx.(*KvLitContext).key = _m
-	}
-	checkKeyValue(p)
-	{
-		p.SetState(316)
-
-		_m := p.Match(ApiParserParserLINE_VALUE)
-
-		localctx.(*KvLitContext).value = _m
-	}
-
-	return localctx
-}
-
-// IServiceNameContext is an interface to support dynamic dispatch.
-type IServiceNameContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsServiceNameContext differentiates from other interfaces.
-	IsServiceNameContext()
-}
-
-type ServiceNameContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyServiceNameContext() *ServiceNameContext {
-	p := new(ServiceNameContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_serviceName
-	return p
-}
-
-func (*ServiceNameContext) IsServiceNameContext() {}
-
-func NewServiceNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceNameContext {
-	p := new(ServiceNameContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_serviceName
-
-	return p
-}
-
-func (s *ServiceNameContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *ServiceNameContext) AllID() []antlr.TerminalNode {
-	return s.GetTokens(ApiParserParserID)
-}
-
-func (s *ServiceNameContext) ID(i int) antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, i)
-}
-
-func (s *ServiceNameContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *ServiceNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *ServiceNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitServiceName(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) ServiceName() (localctx IServiceNameContext) {
-	localctx = NewServiceNameContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 70, ApiParserParserRULE_serviceName)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	p.SetState(322)
-	p.GetErrorHandler().Sync(p)
-
-	for ok := true; ok; ok = _la == ApiParserParserID {
-		{
-			p.SetState(318)
-			p.Match(ApiParserParserID)
-		}
-		p.SetState(320)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-
-		if _la == ApiParserParserT__9 {
-			{
-				p.SetState(319)
-				p.Match(ApiParserParserT__9)
-			}
-		}
-
-		p.SetState(324)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-
-	return localctx
-}
-
-// IPathContext is an interface to support dynamic dispatch.
-type IPathContext interface {
-	antlr.ParserRuleContext
-
-	// GetParser returns the parser.
-	GetParser() antlr.Parser
-
-	// IsPathContext differentiates from other interfaces.
-	IsPathContext()
-}
-
-type PathContext struct {
-	*antlr.BaseParserRuleContext
-	parser antlr.Parser
-}
-
-func NewEmptyPathContext() *PathContext {
-	p := new(PathContext)
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
-	p.RuleIndex = ApiParserParserRULE_path
-	return p
-}
-
-func (*PathContext) IsPathContext() {}
-
-func NewPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PathContext {
-	p := new(PathContext)
-
-	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
-
-	p.parser = parser
-	p.RuleIndex = ApiParserParserRULE_path
-
-	return p
-}
-
-func (s *PathContext) GetParser() antlr.Parser { return s.parser }
-
-func (s *PathContext) AllID() []antlr.TerminalNode {
-	return s.GetTokens(ApiParserParserID)
-}
-
-func (s *PathContext) ID(i int) antlr.TerminalNode {
-	return s.GetToken(ApiParserParserID, i)
-}
-
-func (s *PathContext) GetRuleContext() antlr.RuleContext {
-	return s
-}
-
-func (s *PathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
-	return antlr.TreesStringTree(s, ruleNames, recog)
-}
-
-func (s *PathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
-	switch t := visitor.(type) {
-	case ApiParserVisitor:
-		return t.VisitPath(s)
-
-	default:
-		return t.VisitChildren(s)
-	}
-}
-
-func (p *ApiParserParser) Path() (localctx IPathContext) {
-	localctx = NewPathContext(p, p.GetParserRuleContext(), p.GetState())
-	p.EnterRule(localctx, 72, ApiParserParserRULE_path)
-	var _la int
-
-	defer func() {
-		p.ExitRule()
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			if v, ok := err.(antlr.RecognitionException); ok {
-				localctx.SetException(v)
-				p.GetErrorHandler().ReportError(p, v)
-				p.GetErrorHandler().Recover(p, v)
-			} else {
-				panic(err)
-			}
-		}
-	}()
-
-	p.EnterOuterAlt(localctx, 1)
-	p.SetState(341)
-	p.GetErrorHandler().Sync(p)
-
-	for ok := true; ok; ok = _la == ApiParserParserT__10 || _la == ApiParserParserT__11 {
-		p.SetState(341)
-		p.GetErrorHandler().Sync(p)
-
-		switch p.GetTokenStream().LA(1) {
-		case ApiParserParserT__10:
-			{
-				p.SetState(326)
-				p.Match(ApiParserParserT__10)
-			}
-
-			{
-				p.SetState(327)
-				p.Match(ApiParserParserID)
-			}
-			p.SetState(332)
-			p.GetErrorHandler().Sync(p)
-			_la = p.GetTokenStream().LA(1)
-
-			for _la == ApiParserParserT__9 {
-				{
-					p.SetState(328)
-					p.Match(ApiParserParserT__9)
-				}
-				{
-					p.SetState(329)
-					p.Match(ApiParserParserID)
-				}
-
-				p.SetState(334)
-				p.GetErrorHandler().Sync(p)
-				_la = p.GetTokenStream().LA(1)
-			}
-
-		case ApiParserParserT__11:
-			{
-				p.SetState(335)
-				p.Match(ApiParserParserT__11)
-			}
-
-			{
-				p.SetState(336)
-				p.Match(ApiParserParserID)
-			}
-			p.SetState(339)
-			p.GetErrorHandler().Sync(p)
-			_la = p.GetTokenStream().LA(1)
-
-			if _la == ApiParserParserT__9 {
-				{
-					p.SetState(337)
-					p.Match(ApiParserParserT__9)
-				}
-				{
-					p.SetState(338)
-					p.Match(ApiParserParserID)
-				}
-
-			}
-
-		default:
-			panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
-		}
-
-		p.SetState(343)
-		p.GetErrorHandler().Sync(p)
-		_la = p.GetTokenStream().LA(1)
-	}
-
-	return localctx
-}
-
-func (p *ApiParserParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
-	switch ruleIndex {
-	case 18:
-		var t *FieldContext = nil
-		if localctx != nil {
-			t = localctx.(*FieldContext)
-		}
-		return p.Field_Sempred(t, predIndex)
-
-	default:
-		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
-	}
-}
-
-func (p *ApiParserParser) Field_Sempred(localctx antlr.RuleContext, predIndex int) bool {
-	switch predIndex {
-	case 0:
-		return isNormal(p)
-
-	default:
-		panic("No predicate with index: " + fmt.Sprint(predIndex))
-	}
-}

tools/goctl/api/parser/g4/gen/api/apiparser_parser1.go

@@ -0,0 +1,615 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 1
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+func (s *SyntaxLitContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *SyntaxLitContext) GetSyntaxToken() antlr.Token { return s.syntaxToken }
+
+func (s *SyntaxLitContext) GetAssign() antlr.Token { return s.assign }
+
+func (s *SyntaxLitContext) GetVersion() antlr.Token { return s.version }
+
+func (s *SyntaxLitContext) SetSyntaxToken(v antlr.Token) { s.syntaxToken = v }
+
+func (s *SyntaxLitContext) SetAssign(v antlr.Token) { s.assign = v }
+
+func (s *SyntaxLitContext) SetVersion(v antlr.Token) { s.version = v }
+
+func (s *SyntaxLitContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *SyntaxLitContext) STRING() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserSTRING, 0)
+}
+
+func (s *SyntaxLitContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *SyntaxLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *SyntaxLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitSyntaxLit(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) SyntaxLit() (localctx ISyntaxLitContext) {
+	localctx = NewSyntaxLitContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 4, ApiParserParserRULE_syntaxLit)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "syntax")
+	{
+		p.SetState(88)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*SyntaxLitContext).syntaxToken = _m
+	}
+	{
+		p.SetState(89)
+
+		var _m = p.Match(ApiParserParserT__0)
+
+		localctx.(*SyntaxLitContext).assign = _m
+	}
+	checkVersion(p)
+	{
+		p.SetState(91)
+
+		var _m = p.Match(ApiParserParserSTRING)
+
+		localctx.(*SyntaxLitContext).version = _m
+	}
+
+	return localctx
+}
+
+// IImportSpecContext is an interface to support dynamic dispatch.
+type IImportSpecContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsImportSpecContext differentiates from other interfaces.
+	IsImportSpecContext()
+}
+
+type ImportSpecContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyImportSpecContext() *ImportSpecContext {
+	var p = new(ImportSpecContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_importSpec
+	return p
+}
+
+func (*ImportSpecContext) IsImportSpecContext() {}
+
+func NewImportSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportSpecContext {
+	var p = new(ImportSpecContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_importSpec
+
+	return p
+}
+
+func (s *ImportSpecContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ImportSpecContext) ImportLit() IImportLitContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportLitContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IImportLitContext)
+}
+
+func (s *ImportSpecContext) ImportBlock() IImportBlockContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IImportBlockContext)
+}
+
+func (s *ImportSpecContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ImportSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ImportSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitImportSpec(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ImportSpec() (localctx IImportSpecContext) {
+	localctx = NewImportSpecContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 6, ApiParserParserRULE_importSpec)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(95)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 2, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		{
+			p.SetState(93)
+			p.ImportLit()
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(94)
+			p.ImportBlock()
+		}
+
+	}
+
+	return localctx
+}
+
+// IImportLitContext is an interface to support dynamic dispatch.
+type IImportLitContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetImportToken returns the importToken token.
+	GetImportToken() antlr.Token
+
+	// SetImportToken sets the importToken token.
+	SetImportToken(antlr.Token)
+
+	// IsImportLitContext differentiates from other interfaces.
+	IsImportLitContext()
+}
+
+type ImportLitContext struct {
+	*antlr.BaseParserRuleContext
+	parser      antlr.Parser
+	importToken antlr.Token
+}
+
+func NewEmptyImportLitContext() *ImportLitContext {
+	var p = new(ImportLitContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_importLit
+	return p
+}
+
+func (*ImportLitContext) IsImportLitContext() {}
+
+func NewImportLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportLitContext {
+	var p = new(ImportLitContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_importLit
+
+	return p
+}
+
+func (s *ImportLitContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ImportLitContext) GetImportToken() antlr.Token { return s.importToken }
+
+func (s *ImportLitContext) SetImportToken(v antlr.Token) { s.importToken = v }
+
+func (s *ImportLitContext) ImportValue() IImportValueContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IImportValueContext)
+}
+
+func (s *ImportLitContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *ImportLitContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ImportLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ImportLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitImportLit(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ImportLit() (localctx IImportLitContext) {
+	localctx = NewImportLitContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 8, ApiParserParserRULE_importLit)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "import")
+	{
+		p.SetState(98)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*ImportLitContext).importToken = _m
+	}
+	{
+		p.SetState(99)
+		p.ImportValue()
+	}
+
+	return localctx
+}
+
+// IImportBlockContext is an interface to support dynamic dispatch.
+type IImportBlockContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetImportToken returns the importToken token.
+	GetImportToken() antlr.Token
+
+	// SetImportToken sets the importToken token.
+	SetImportToken(antlr.Token)
+
+	// IsImportBlockContext differentiates from other interfaces.
+	IsImportBlockContext()
+}
+
+type ImportBlockContext struct {
+	*antlr.BaseParserRuleContext
+	parser      antlr.Parser
+	importToken antlr.Token
+}
+
+func NewEmptyImportBlockContext() *ImportBlockContext {
+	var p = new(ImportBlockContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_importBlock
+	return p
+}
+
+func (*ImportBlockContext) IsImportBlockContext() {}
+
+func NewImportBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockContext {
+	var p = new(ImportBlockContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_importBlock
+
+	return p
+}
+
+func (s *ImportBlockContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ImportBlockContext) GetImportToken() antlr.Token { return s.importToken }
+
+func (s *ImportBlockContext) SetImportToken(v antlr.Token) { s.importToken = v }
+
+func (s *ImportBlockContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *ImportBlockContext) AllImportBlockValue() []IImportBlockValueContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem())
+	var tst = make([]IImportBlockValueContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IImportBlockValueContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *ImportBlockContext) ImportBlockValue(i int) IImportBlockValueContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportBlockValueContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IImportBlockValueContext)
+}
+
+func (s *ImportBlockContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ImportBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ImportBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitImportBlock(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ImportBlock() (localctx IImportBlockContext) {
+	localctx = NewImportBlockContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 10, ApiParserParserRULE_importBlock)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "import")
+	{
+		p.SetState(102)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*ImportBlockContext).importToken = _m
+	}
+	{
+		p.SetState(103)
+		p.Match(ApiParserParserT__1)
+	}
+	p.SetState(105)
+	p.GetErrorHandler().Sync(p)
+
+	for ok := true; ok; ok = _la == ApiParserParserSTRING {
+		{
+			p.SetState(104)
+			p.ImportBlockValue()
+		}
+
+		p.SetState(107)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+	}
+	{
+		p.SetState(109)
+		p.Match(ApiParserParserT__2)
+	}
+
+	return localctx
+}
+
+// IImportBlockValueContext is an interface to support dynamic dispatch.
+type IImportBlockValueContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsImportBlockValueContext differentiates from other interfaces.
+	IsImportBlockValueContext()
+}
+
+type ImportBlockValueContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyImportBlockValueContext() *ImportBlockValueContext {
+	var p = new(ImportBlockValueContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_importBlockValue
+	return p
+}
+
+func (*ImportBlockValueContext) IsImportBlockValueContext() {}
+
+func NewImportBlockValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportBlockValueContext {
+	var p = new(ImportBlockValueContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_importBlockValue
+
+	return p
+}
+
+func (s *ImportBlockValueContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ImportBlockValueContext) ImportValue() IImportValueContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IImportValueContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IImportValueContext)
+}
+
+func (s *ImportBlockValueContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ImportBlockValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ImportBlockValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitImportBlockValue(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ImportBlockValue() (localctx IImportBlockValueContext) {
+	localctx = NewImportBlockValueContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 12, ApiParserParserRULE_importBlockValue)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(111)
+		p.ImportValue()
+	}
+
+	return localctx
+}
+
+// IImportValueContext is an interface to support dynamic dispatch.
+type IImportValueContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsImportValueContext differentiates from other interfaces.
+	IsImportValueContext()
+}
+
+type ImportValueContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyImportValueContext() *ImportValueContext {
+	var p = new(ImportValueContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_importValue
+	return p
+}
+
+func (*ImportValueContext) IsImportValueContext() {}
+
+func NewImportValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportValueContext {
+	var p = new(ImportValueContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_importValue
+
+	return p
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser2.go

@@ -0,0 +1,656 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 2
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+func (s *ImportValueContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ImportValueContext) STRING() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserSTRING, 0)
+}
+
+func (s *ImportValueContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ImportValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ImportValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitImportValue(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ImportValue() (localctx IImportValueContext) {
+	localctx = NewImportValueContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 14, ApiParserParserRULE_importValue)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	checkImportValue(p)
+	{
+		p.SetState(114)
+		p.Match(ApiParserParserSTRING)
+	}
+
+	return localctx
+}
+
+// IInfoSpecContext is an interface to support dynamic dispatch.
+type IInfoSpecContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetInfoToken returns the infoToken token.
+	GetInfoToken() antlr.Token
+
+	// GetLp returns the lp token.
+	GetLp() antlr.Token
+
+	// GetRp returns the rp token.
+	GetRp() antlr.Token
+
+	// SetInfoToken sets the infoToken token.
+	SetInfoToken(antlr.Token)
+
+	// SetLp sets the lp token.
+	SetLp(antlr.Token)
+
+	// SetRp sets the rp token.
+	SetRp(antlr.Token)
+
+	// IsInfoSpecContext differentiates from other interfaces.
+	IsInfoSpecContext()
+}
+
+type InfoSpecContext struct {
+	*antlr.BaseParserRuleContext
+	parser    antlr.Parser
+	infoToken antlr.Token
+	lp        antlr.Token
+	rp        antlr.Token
+}
+
+func NewEmptyInfoSpecContext() *InfoSpecContext {
+	var p = new(InfoSpecContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_infoSpec
+	return p
+}
+
+func (*InfoSpecContext) IsInfoSpecContext() {}
+
+func NewInfoSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InfoSpecContext {
+	var p = new(InfoSpecContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_infoSpec
+
+	return p
+}
+
+func (s *InfoSpecContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *InfoSpecContext) GetInfoToken() antlr.Token { return s.infoToken }
+
+func (s *InfoSpecContext) GetLp() antlr.Token { return s.lp }
+
+func (s *InfoSpecContext) GetRp() antlr.Token { return s.rp }
+
+func (s *InfoSpecContext) SetInfoToken(v antlr.Token) { s.infoToken = v }
+
+func (s *InfoSpecContext) SetLp(v antlr.Token) { s.lp = v }
+
+func (s *InfoSpecContext) SetRp(v antlr.Token) { s.rp = v }
+
+func (s *InfoSpecContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *InfoSpecContext) AllKvLit() []IKvLitContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())
+	var tst = make([]IKvLitContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IKvLitContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *InfoSpecContext) KvLit(i int) IKvLitContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IKvLitContext)
+}
+
+func (s *InfoSpecContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *InfoSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *InfoSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitInfoSpec(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) InfoSpec() (localctx IInfoSpecContext) {
+	localctx = NewInfoSpecContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 16, ApiParserParserRULE_infoSpec)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "info")
+	{
+		p.SetState(117)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*InfoSpecContext).infoToken = _m
+	}
+	{
+		p.SetState(118)
+
+		var _m = p.Match(ApiParserParserT__1)
+
+		localctx.(*InfoSpecContext).lp = _m
+	}
+	p.SetState(120)
+	p.GetErrorHandler().Sync(p)
+
+	for ok := true; ok; ok = _la == ApiParserParserID {
+		{
+			p.SetState(119)
+			p.KvLit()
+		}
+
+		p.SetState(122)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+	}
+	{
+		p.SetState(124)
+
+		var _m = p.Match(ApiParserParserT__2)
+
+		localctx.(*InfoSpecContext).rp = _m
+	}
+
+	return localctx
+}
+
+// ITypeSpecContext is an interface to support dynamic dispatch.
+type ITypeSpecContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsTypeSpecContext differentiates from other interfaces.
+	IsTypeSpecContext()
+}
+
+type TypeSpecContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyTypeSpecContext() *TypeSpecContext {
+	var p = new(TypeSpecContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeSpec
+	return p
+}
+
+func (*TypeSpecContext) IsTypeSpecContext() {}
+
+func NewTypeSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeSpecContext {
+	var p = new(TypeSpecContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeSpec
+
+	return p
+}
+
+func (s *TypeSpecContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeSpecContext) TypeLit() ITypeLitContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeLitContext)
+}
+
+func (s *TypeSpecContext) TypeBlock() ITypeBlockContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeBlockContext)
+}
+
+func (s *TypeSpecContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeSpec(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeSpec() (localctx ITypeSpecContext) {
+	localctx = NewTypeSpecContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 18, ApiParserParserRULE_typeSpec)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(128)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		{
+			p.SetState(126)
+			p.TypeLit()
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(127)
+			p.TypeBlock()
+		}
+
+	}
+
+	return localctx
+}
+
+// ITypeLitContext is an interface to support dynamic dispatch.
+type ITypeLitContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetTypeToken returns the typeToken token.
+	GetTypeToken() antlr.Token
+
+	// SetTypeToken sets the typeToken token.
+	SetTypeToken(antlr.Token)
+
+	// IsTypeLitContext differentiates from other interfaces.
+	IsTypeLitContext()
+}
+
+type TypeLitContext struct {
+	*antlr.BaseParserRuleContext
+	parser    antlr.Parser
+	typeToken antlr.Token
+}
+
+func NewEmptyTypeLitContext() *TypeLitContext {
+	var p = new(TypeLitContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeLit
+	return p
+}
+
+func (*TypeLitContext) IsTypeLitContext() {}
+
+func NewTypeLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeLitContext {
+	var p = new(TypeLitContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeLit
+
+	return p
+}
+
+func (s *TypeLitContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeLitContext) GetTypeToken() antlr.Token { return s.typeToken }
+
+func (s *TypeLitContext) SetTypeToken(v antlr.Token) { s.typeToken = v }
+
+func (s *TypeLitContext) TypeLitBody() ITypeLitBodyContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeLitBodyContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeLitBodyContext)
+}
+
+func (s *TypeLitContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *TypeLitContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeLit(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeLit() (localctx ITypeLitContext) {
+	localctx = NewTypeLitContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 20, ApiParserParserRULE_typeLit)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "type")
+	{
+		p.SetState(131)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*TypeLitContext).typeToken = _m
+	}
+	{
+		p.SetState(132)
+		p.TypeLitBody()
+	}
+
+	return localctx
+}
+
+// ITypeBlockContext is an interface to support dynamic dispatch.
+type ITypeBlockContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetTypeToken returns the typeToken token.
+	GetTypeToken() antlr.Token
+
+	// GetLp returns the lp token.
+	GetLp() antlr.Token
+
+	// GetRp returns the rp token.
+	GetRp() antlr.Token
+
+	// SetTypeToken sets the typeToken token.
+	SetTypeToken(antlr.Token)
+
+	// SetLp sets the lp token.
+	SetLp(antlr.Token)
+
+	// SetRp sets the rp token.
+	SetRp(antlr.Token)
+
+	// IsTypeBlockContext differentiates from other interfaces.
+	IsTypeBlockContext()
+}
+
+type TypeBlockContext struct {
+	*antlr.BaseParserRuleContext
+	parser    antlr.Parser
+	typeToken antlr.Token
+	lp        antlr.Token
+	rp        antlr.Token
+}
+
+func NewEmptyTypeBlockContext() *TypeBlockContext {
+	var p = new(TypeBlockContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeBlock
+	return p
+}
+
+func (*TypeBlockContext) IsTypeBlockContext() {}
+
+func NewTypeBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockContext {
+	var p = new(TypeBlockContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeBlock
+
+	return p
+}
+
+func (s *TypeBlockContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeBlockContext) GetTypeToken() antlr.Token { return s.typeToken }
+
+func (s *TypeBlockContext) GetLp() antlr.Token { return s.lp }
+
+func (s *TypeBlockContext) GetRp() antlr.Token { return s.rp }
+
+func (s *TypeBlockContext) SetTypeToken(v antlr.Token) { s.typeToken = v }
+
+func (s *TypeBlockContext) SetLp(v antlr.Token) { s.lp = v }
+
+func (s *TypeBlockContext) SetRp(v antlr.Token) { s.rp = v }
+
+func (s *TypeBlockContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *TypeBlockContext) AllTypeBlockBody() []ITypeBlockBodyContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*ITypeBlockBodyContext)(nil)).Elem())
+	var tst = make([]ITypeBlockBodyContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(ITypeBlockBodyContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *TypeBlockContext) TypeBlockBody(i int) ITypeBlockBodyContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockBodyContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeBlockBodyContext)
+}
+
+func (s *TypeBlockContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeBlock(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeBlock() (localctx ITypeBlockContext) {
+	localctx = NewTypeBlockContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 22, ApiParserParserRULE_typeBlock)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "type")
+	{
+		p.SetState(135)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*TypeBlockContext).typeToken = _m
+	}
+	{
+		p.SetState(136)
+
+		var _m = p.Match(ApiParserParserT__1)
+
+		localctx.(*TypeBlockContext).lp = _m
+	}
+	p.SetState(140)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	for _la == ApiParserParserID {
+		{
+			p.SetState(137)
+			p.TypeBlockBody()
+		}
+
+		p.SetState(142)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+	}
+	{
+		p.SetState(143)
+
+		var _m = p.Match(ApiParserParserT__2)
+
+		localctx.(*TypeBlockContext).rp = _m
+	}
+
+	return localctx
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser3.go

@@ -0,0 +1,637 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 3
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+// ITypeLitBodyContext is an interface to support dynamic dispatch.
+type ITypeLitBodyContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsTypeLitBodyContext differentiates from other interfaces.
+	IsTypeLitBodyContext()
+}
+
+type TypeLitBodyContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyTypeLitBodyContext() *TypeLitBodyContext {
+	var p = new(TypeLitBodyContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeLitBody
+	return p
+}
+
+func (*TypeLitBodyContext) IsTypeLitBodyContext() {}
+
+func NewTypeLitBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeLitBodyContext {
+	var p = new(TypeLitBodyContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeLitBody
+
+	return p
+}
+
+func (s *TypeLitBodyContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeLitBodyContext) TypeStruct() ITypeStructContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeStructContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeStructContext)
+}
+
+func (s *TypeLitBodyContext) TypeAlias() ITypeAliasContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeAliasContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeAliasContext)
+}
+
+func (s *TypeLitBodyContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeLitBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeLitBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeLitBody(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeLitBody() (localctx ITypeLitBodyContext) {
+	localctx = NewTypeLitBodyContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 24, ApiParserParserRULE_typeLitBody)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(147)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 7, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		{
+			p.SetState(145)
+			p.TypeStruct()
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(146)
+			p.TypeAlias()
+		}
+
+	}
+
+	return localctx
+}
+
+// ITypeBlockBodyContext is an interface to support dynamic dispatch.
+type ITypeBlockBodyContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsTypeBlockBodyContext differentiates from other interfaces.
+	IsTypeBlockBodyContext()
+}
+
+type TypeBlockBodyContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyTypeBlockBodyContext() *TypeBlockBodyContext {
+	var p = new(TypeBlockBodyContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeBlockBody
+	return p
+}
+
+func (*TypeBlockBodyContext) IsTypeBlockBodyContext() {}
+
+func NewTypeBlockBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockBodyContext {
+	var p = new(TypeBlockBodyContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeBlockBody
+
+	return p
+}
+
+func (s *TypeBlockBodyContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeBlockBodyContext) TypeBlockStruct() ITypeBlockStructContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockStructContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeBlockStructContext)
+}
+
+func (s *TypeBlockBodyContext) TypeBlockAlias() ITypeBlockAliasContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeBlockAliasContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeBlockAliasContext)
+}
+
+func (s *TypeBlockBodyContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeBlockBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeBlockBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeBlockBody(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeBlockBody() (localctx ITypeBlockBodyContext) {
+	localctx = NewTypeBlockBodyContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 26, ApiParserParserRULE_typeBlockBody)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(151)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 8, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		{
+			p.SetState(149)
+			p.TypeBlockStruct()
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(150)
+			p.TypeBlockAlias()
+		}
+
+	}
+
+	return localctx
+}
+
+// ITypeStructContext is an interface to support dynamic dispatch.
+type ITypeStructContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetStructName returns the structName token.
+	GetStructName() antlr.Token
+
+	// GetStructToken returns the structToken token.
+	GetStructToken() antlr.Token
+
+	// GetLbrace returns the lbrace token.
+	GetLbrace() antlr.Token
+
+	// GetRbrace returns the rbrace token.
+	GetRbrace() antlr.Token
+
+	// SetStructName sets the structName token.
+	SetStructName(antlr.Token)
+
+	// SetStructToken sets the structToken token.
+	SetStructToken(antlr.Token)
+
+	// SetLbrace sets the lbrace token.
+	SetLbrace(antlr.Token)
+
+	// SetRbrace sets the rbrace token.
+	SetRbrace(antlr.Token)
+
+	// IsTypeStructContext differentiates from other interfaces.
+	IsTypeStructContext()
+}
+
+type TypeStructContext struct {
+	*antlr.BaseParserRuleContext
+	parser      antlr.Parser
+	structName  antlr.Token
+	structToken antlr.Token
+	lbrace      antlr.Token
+	rbrace      antlr.Token
+}
+
+func NewEmptyTypeStructContext() *TypeStructContext {
+	var p = new(TypeStructContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeStruct
+	return p
+}
+
+func (*TypeStructContext) IsTypeStructContext() {}
+
+func NewTypeStructContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeStructContext {
+	var p = new(TypeStructContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeStruct
+
+	return p
+}
+
+func (s *TypeStructContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeStructContext) GetStructName() antlr.Token { return s.structName }
+
+func (s *TypeStructContext) GetStructToken() antlr.Token { return s.structToken }
+
+func (s *TypeStructContext) GetLbrace() antlr.Token { return s.lbrace }
+
+func (s *TypeStructContext) GetRbrace() antlr.Token { return s.rbrace }
+
+func (s *TypeStructContext) SetStructName(v antlr.Token) { s.structName = v }
+
+func (s *TypeStructContext) SetStructToken(v antlr.Token) { s.structToken = v }
+
+func (s *TypeStructContext) SetLbrace(v antlr.Token) { s.lbrace = v }
+
+func (s *TypeStructContext) SetRbrace(v antlr.Token) { s.rbrace = v }
+
+func (s *TypeStructContext) AllID() []antlr.TerminalNode {
+	return s.GetTokens(ApiParserParserID)
+}
+
+func (s *TypeStructContext) ID(i int) antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, i)
+}
+
+func (s *TypeStructContext) AllField() []IFieldContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFieldContext)(nil)).Elem())
+	var tst = make([]IFieldContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IFieldContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *TypeStructContext) Field(i int) IFieldContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IFieldContext)
+}
+
+func (s *TypeStructContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeStructContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeStructContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeStruct(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeStruct() (localctx ITypeStructContext) {
+	localctx = NewTypeStructContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 28, ApiParserParserRULE_typeStruct)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	var _alt int
+
+	p.EnterOuterAlt(localctx, 1)
+	checkKeyword(p)
+	{
+		p.SetState(154)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*TypeStructContext).structName = _m
+	}
+	p.SetState(156)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserID {
+		{
+			p.SetState(155)
+
+			var _m = p.Match(ApiParserParserID)
+
+			localctx.(*TypeStructContext).structToken = _m
+		}
+
+	}
+	{
+		p.SetState(158)
+
+		var _m = p.Match(ApiParserParserT__3)
+
+		localctx.(*TypeStructContext).lbrace = _m
+	}
+	p.SetState(162)
+	p.GetErrorHandler().Sync(p)
+	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext())
+
+	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
+		if _alt == 1 {
+			{
+				p.SetState(159)
+				p.Field()
+			}
+
+		}
+		p.SetState(164)
+		p.GetErrorHandler().Sync(p)
+		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 10, p.GetParserRuleContext())
+	}
+	{
+		p.SetState(165)
+
+		var _m = p.Match(ApiParserParserT__4)
+
+		localctx.(*TypeStructContext).rbrace = _m
+	}
+
+	return localctx
+}
+
+// ITypeAliasContext is an interface to support dynamic dispatch.
+type ITypeAliasContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetAlias returns the alias token.
+	GetAlias() antlr.Token
+
+	// GetAssign returns the assign token.
+	GetAssign() antlr.Token
+
+	// SetAlias sets the alias token.
+	SetAlias(antlr.Token)
+
+	// SetAssign sets the assign token.
+	SetAssign(antlr.Token)
+
+	// IsTypeAliasContext differentiates from other interfaces.
+	IsTypeAliasContext()
+}
+
+type TypeAliasContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	alias  antlr.Token
+	assign antlr.Token
+}
+
+func NewEmptyTypeAliasContext() *TypeAliasContext {
+	var p = new(TypeAliasContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeAlias
+	return p
+}
+
+func (*TypeAliasContext) IsTypeAliasContext() {}
+
+func NewTypeAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeAliasContext {
+	var p = new(TypeAliasContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeAlias
+
+	return p
+}
+
+func (s *TypeAliasContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeAliasContext) GetAlias() antlr.Token { return s.alias }
+
+func (s *TypeAliasContext) GetAssign() antlr.Token { return s.assign }
+
+func (s *TypeAliasContext) SetAlias(v antlr.Token) { s.alias = v }
+
+func (s *TypeAliasContext) SetAssign(v antlr.Token) { s.assign = v }
+
+func (s *TypeAliasContext) DataType() IDataTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IDataTypeContext)
+}
+
+func (s *TypeAliasContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *TypeAliasContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeAlias(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeAlias() (localctx ITypeAliasContext) {
+	localctx = NewTypeAliasContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 30, ApiParserParserRULE_typeAlias)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	checkKeyword(p)
+	{
+		p.SetState(168)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*TypeAliasContext).alias = _m
+	}
+	p.SetState(170)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserT__0 {
+		{
+			p.SetState(169)
+
+			var _m = p.Match(ApiParserParserT__0)
+
+			localctx.(*TypeAliasContext).assign = _m
+		}
+
+	}
+	{
+		p.SetState(172)
+		p.DataType()
+	}
+
+	return localctx
+}
+
+// ITypeBlockStructContext is an interface to support dynamic dispatch.
+type ITypeBlockStructContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetStructName returns the structName token.
+	GetStructName() antlr.Token
+
+	// GetStructToken returns the structToken token.
+	GetStructToken() antlr.Token
+
+	// GetLbrace returns the lbrace token.
+	GetLbrace() antlr.Token
+
+	// GetRbrace returns the rbrace token.
+	GetRbrace() antlr.Token
+
+	// SetStructName sets the structName token.
+	SetStructName(antlr.Token)
+
+	// SetStructToken sets the structToken token.
+	SetStructToken(antlr.Token)
+
+	// SetLbrace sets the lbrace token.
+	SetLbrace(antlr.Token)
+
+	// SetRbrace sets the rbrace token.
+	SetRbrace(antlr.Token)
+
+	// IsTypeBlockStructContext differentiates from other interfaces.
+	IsTypeBlockStructContext()
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser4.go

@@ -0,0 +1,617 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 4
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+type TypeBlockStructContext struct {
+	*antlr.BaseParserRuleContext
+	parser      antlr.Parser
+	structName  antlr.Token
+	structToken antlr.Token
+	lbrace      antlr.Token
+	rbrace      antlr.Token
+}
+
+func NewEmptyTypeBlockStructContext() *TypeBlockStructContext {
+	var p = new(TypeBlockStructContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeBlockStruct
+	return p
+}
+
+func (*TypeBlockStructContext) IsTypeBlockStructContext() {}
+
+func NewTypeBlockStructContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockStructContext {
+	var p = new(TypeBlockStructContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeBlockStruct
+
+	return p
+}
+
+func (s *TypeBlockStructContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeBlockStructContext) GetStructName() antlr.Token { return s.structName }
+
+func (s *TypeBlockStructContext) GetStructToken() antlr.Token { return s.structToken }
+
+func (s *TypeBlockStructContext) GetLbrace() antlr.Token { return s.lbrace }
+
+func (s *TypeBlockStructContext) GetRbrace() antlr.Token { return s.rbrace }
+
+func (s *TypeBlockStructContext) SetStructName(v antlr.Token) { s.structName = v }
+
+func (s *TypeBlockStructContext) SetStructToken(v antlr.Token) { s.structToken = v }
+
+func (s *TypeBlockStructContext) SetLbrace(v antlr.Token) { s.lbrace = v }
+
+func (s *TypeBlockStructContext) SetRbrace(v antlr.Token) { s.rbrace = v }
+
+func (s *TypeBlockStructContext) AllID() []antlr.TerminalNode {
+	return s.GetTokens(ApiParserParserID)
+}
+
+func (s *TypeBlockStructContext) ID(i int) antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, i)
+}
+
+func (s *TypeBlockStructContext) AllField() []IFieldContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IFieldContext)(nil)).Elem())
+	var tst = make([]IFieldContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IFieldContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *TypeBlockStructContext) Field(i int) IFieldContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IFieldContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IFieldContext)
+}
+
+func (s *TypeBlockStructContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeBlockStructContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeBlockStructContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeBlockStruct(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeBlockStruct() (localctx ITypeBlockStructContext) {
+	localctx = NewTypeBlockStructContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 32, ApiParserParserRULE_typeBlockStruct)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	var _alt int
+
+	p.EnterOuterAlt(localctx, 1)
+	checkKeyword(p)
+	{
+		p.SetState(175)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*TypeBlockStructContext).structName = _m
+	}
+	p.SetState(177)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserID {
+		{
+			p.SetState(176)
+
+			var _m = p.Match(ApiParserParserID)
+
+			localctx.(*TypeBlockStructContext).structToken = _m
+		}
+
+	}
+	{
+		p.SetState(179)
+
+		var _m = p.Match(ApiParserParserT__3)
+
+		localctx.(*TypeBlockStructContext).lbrace = _m
+	}
+	p.SetState(183)
+	p.GetErrorHandler().Sync(p)
+	_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())
+
+	for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
+		if _alt == 1 {
+			{
+				p.SetState(180)
+				p.Field()
+			}
+
+		}
+		p.SetState(185)
+		p.GetErrorHandler().Sync(p)
+		_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 13, p.GetParserRuleContext())
+	}
+	{
+		p.SetState(186)
+
+		var _m = p.Match(ApiParserParserT__4)
+
+		localctx.(*TypeBlockStructContext).rbrace = _m
+	}
+
+	return localctx
+}
+
+// ITypeBlockAliasContext is an interface to support dynamic dispatch.
+type ITypeBlockAliasContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetAlias returns the alias token.
+	GetAlias() antlr.Token
+
+	// GetAssign returns the assign token.
+	GetAssign() antlr.Token
+
+	// SetAlias sets the alias token.
+	SetAlias(antlr.Token)
+
+	// SetAssign sets the assign token.
+	SetAssign(antlr.Token)
+
+	// IsTypeBlockAliasContext differentiates from other interfaces.
+	IsTypeBlockAliasContext()
+}
+
+type TypeBlockAliasContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	alias  antlr.Token
+	assign antlr.Token
+}
+
+func NewEmptyTypeBlockAliasContext() *TypeBlockAliasContext {
+	var p = new(TypeBlockAliasContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_typeBlockAlias
+	return p
+}
+
+func (*TypeBlockAliasContext) IsTypeBlockAliasContext() {}
+
+func NewTypeBlockAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeBlockAliasContext {
+	var p = new(TypeBlockAliasContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_typeBlockAlias
+
+	return p
+}
+
+func (s *TypeBlockAliasContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *TypeBlockAliasContext) GetAlias() antlr.Token { return s.alias }
+
+func (s *TypeBlockAliasContext) GetAssign() antlr.Token { return s.assign }
+
+func (s *TypeBlockAliasContext) SetAlias(v antlr.Token) { s.alias = v }
+
+func (s *TypeBlockAliasContext) SetAssign(v antlr.Token) { s.assign = v }
+
+func (s *TypeBlockAliasContext) DataType() IDataTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IDataTypeContext)
+}
+
+func (s *TypeBlockAliasContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *TypeBlockAliasContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *TypeBlockAliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *TypeBlockAliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitTypeBlockAlias(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) TypeBlockAlias() (localctx ITypeBlockAliasContext) {
+	localctx = NewTypeBlockAliasContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 34, ApiParserParserRULE_typeBlockAlias)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	checkKeyword(p)
+	{
+		p.SetState(189)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*TypeBlockAliasContext).alias = _m
+	}
+	p.SetState(191)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserT__0 {
+		{
+			p.SetState(190)
+
+			var _m = p.Match(ApiParserParserT__0)
+
+			localctx.(*TypeBlockAliasContext).assign = _m
+		}
+
+	}
+	{
+		p.SetState(193)
+		p.DataType()
+	}
+
+	return localctx
+}
+
+// IFieldContext is an interface to support dynamic dispatch.
+type IFieldContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsFieldContext differentiates from other interfaces.
+	IsFieldContext()
+}
+
+type FieldContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyFieldContext() *FieldContext {
+	var p = new(FieldContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_field
+	return p
+}
+
+func (*FieldContext) IsFieldContext() {}
+
+func NewFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldContext {
+	var p = new(FieldContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_field
+
+	return p
+}
+
+func (s *FieldContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *FieldContext) NormalField() INormalFieldContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*INormalFieldContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(INormalFieldContext)
+}
+
+func (s *FieldContext) AnonymousFiled() IAnonymousFiledContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAnonymousFiledContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IAnonymousFiledContext)
+}
+
+func (s *FieldContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *FieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *FieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitField(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) Field() (localctx IFieldContext) {
+	localctx = NewFieldContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 36, ApiParserParserRULE_field)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(198)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 15, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		p.SetState(195)
+
+		if !(isNormal(p)) {
+			panic(antlr.NewFailedPredicateException(p, "isNormal(p)", ""))
+		}
+		{
+			p.SetState(196)
+			p.NormalField()
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(197)
+			p.AnonymousFiled()
+		}
+
+	}
+
+	return localctx
+}
+
+// INormalFieldContext is an interface to support dynamic dispatch.
+type INormalFieldContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetFieldName returns the fieldName token.
+	GetFieldName() antlr.Token
+
+	// GetTag returns the tag token.
+	GetTag() antlr.Token
+
+	// SetFieldName sets the fieldName token.
+	SetFieldName(antlr.Token)
+
+	// SetTag sets the tag token.
+	SetTag(antlr.Token)
+
+	// IsNormalFieldContext differentiates from other interfaces.
+	IsNormalFieldContext()
+}
+
+type NormalFieldContext struct {
+	*antlr.BaseParserRuleContext
+	parser    antlr.Parser
+	fieldName antlr.Token
+	tag       antlr.Token
+}
+
+func NewEmptyNormalFieldContext() *NormalFieldContext {
+	var p = new(NormalFieldContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_normalField
+	return p
+}
+
+func (*NormalFieldContext) IsNormalFieldContext() {}
+
+func NewNormalFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NormalFieldContext {
+	var p = new(NormalFieldContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_normalField
+
+	return p
+}
+
+func (s *NormalFieldContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *NormalFieldContext) GetFieldName() antlr.Token { return s.fieldName }
+
+func (s *NormalFieldContext) GetTag() antlr.Token { return s.tag }
+
+func (s *NormalFieldContext) SetFieldName(v antlr.Token) { s.fieldName = v }
+
+func (s *NormalFieldContext) SetTag(v antlr.Token) { s.tag = v }
+
+func (s *NormalFieldContext) DataType() IDataTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IDataTypeContext)
+}
+
+func (s *NormalFieldContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *NormalFieldContext) RAW_STRING() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserRAW_STRING, 0)
+}
+
+func (s *NormalFieldContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *NormalFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *NormalFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitNormalField(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) NormalField() (localctx INormalFieldContext) {
+	localctx = NewNormalFieldContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 38, ApiParserParserRULE_normalField)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	checkKeyword(p)
+	{
+		p.SetState(201)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*NormalFieldContext).fieldName = _m
+	}
+	{
+		p.SetState(202)
+		p.DataType()
+	}
+	p.SetState(204)
+	p.GetErrorHandler().Sync(p)
+
+	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 16, p.GetParserRuleContext()) == 1 {
+		{
+			p.SetState(203)
+
+			var _m = p.Match(ApiParserParserRAW_STRING)
+
+			localctx.(*NormalFieldContext).tag = _m
+		}
+
+	}
+
+	return localctx
+}
+
+// IAnonymousFiledContext is an interface to support dynamic dispatch.
+type IAnonymousFiledContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetStar returns the star token.
+	GetStar() antlr.Token
+
+	// SetStar sets the star token.
+	SetStar(antlr.Token)
+
+	// IsAnonymousFiledContext differentiates from other interfaces.
+	IsAnonymousFiledContext()
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser5.go

@@ -0,0 +1,618 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 5
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+type AnonymousFiledContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	star   antlr.Token
+}
+
+func NewEmptyAnonymousFiledContext() *AnonymousFiledContext {
+	var p = new(AnonymousFiledContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_anonymousFiled
+	return p
+}
+
+func (*AnonymousFiledContext) IsAnonymousFiledContext() {}
+
+func NewAnonymousFiledContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnonymousFiledContext {
+	var p = new(AnonymousFiledContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_anonymousFiled
+
+	return p
+}
+
+func (s *AnonymousFiledContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *AnonymousFiledContext) GetStar() antlr.Token { return s.star }
+
+func (s *AnonymousFiledContext) SetStar(v antlr.Token) { s.star = v }
+
+func (s *AnonymousFiledContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *AnonymousFiledContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *AnonymousFiledContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *AnonymousFiledContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitAnonymousFiled(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) AnonymousFiled() (localctx IAnonymousFiledContext) {
+	localctx = NewAnonymousFiledContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 40, ApiParserParserRULE_anonymousFiled)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	p.SetState(207)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserT__5 {
+		{
+			p.SetState(206)
+
+			var _m = p.Match(ApiParserParserT__5)
+
+			localctx.(*AnonymousFiledContext).star = _m
+		}
+
+	}
+	{
+		p.SetState(209)
+		p.Match(ApiParserParserID)
+	}
+
+	return localctx
+}
+
+// IDataTypeContext is an interface to support dynamic dispatch.
+type IDataTypeContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetInter returns the inter token.
+	GetInter() antlr.Token
+
+	// GetTime returns the time token.
+	GetTime() antlr.Token
+
+	// SetInter sets the inter token.
+	SetInter(antlr.Token)
+
+	// SetTime sets the time token.
+	SetTime(antlr.Token)
+
+	// IsDataTypeContext differentiates from other interfaces.
+	IsDataTypeContext()
+}
+
+type DataTypeContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	inter  antlr.Token
+	time   antlr.Token
+}
+
+func NewEmptyDataTypeContext() *DataTypeContext {
+	var p = new(DataTypeContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_dataType
+	return p
+}
+
+func (*DataTypeContext) IsDataTypeContext() {}
+
+func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext {
+	var p = new(DataTypeContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_dataType
+
+	return p
+}
+
+func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *DataTypeContext) GetInter() antlr.Token { return s.inter }
+
+func (s *DataTypeContext) GetTime() antlr.Token { return s.time }
+
+func (s *DataTypeContext) SetInter(v antlr.Token) { s.inter = v }
+
+func (s *DataTypeContext) SetTime(v antlr.Token) { s.time = v }
+
+func (s *DataTypeContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *DataTypeContext) MapType() IMapTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IMapTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IMapTypeContext)
+}
+
+func (s *DataTypeContext) ArrayType() IArrayTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IArrayTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IArrayTypeContext)
+}
+
+func (s *DataTypeContext) INTERFACE() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserINTERFACE, 0)
+}
+
+func (s *DataTypeContext) PointerType() IPointerTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPointerTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IPointerTypeContext)
+}
+
+func (s *DataTypeContext) TypeStruct() ITypeStructContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*ITypeStructContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(ITypeStructContext)
+}
+
+func (s *DataTypeContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *DataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitDataType(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) DataType() (localctx IDataTypeContext) {
+	localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 42, ApiParserParserRULE_dataType)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(219)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 18, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		isInterface(p)
+		{
+			p.SetState(212)
+			p.Match(ApiParserParserID)
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(213)
+			p.MapType()
+		}
+
+	case 3:
+		p.EnterOuterAlt(localctx, 3)
+		{
+			p.SetState(214)
+			p.ArrayType()
+		}
+
+	case 4:
+		p.EnterOuterAlt(localctx, 4)
+		{
+			p.SetState(215)
+
+			var _m = p.Match(ApiParserParserINTERFACE)
+
+			localctx.(*DataTypeContext).inter = _m
+		}
+
+	case 5:
+		p.EnterOuterAlt(localctx, 5)
+		{
+			p.SetState(216)
+
+			var _m = p.Match(ApiParserParserT__6)
+
+			localctx.(*DataTypeContext).time = _m
+		}
+
+	case 6:
+		p.EnterOuterAlt(localctx, 6)
+		{
+			p.SetState(217)
+			p.PointerType()
+		}
+
+	case 7:
+		p.EnterOuterAlt(localctx, 7)
+		{
+			p.SetState(218)
+			p.TypeStruct()
+		}
+
+	}
+
+	return localctx
+}
+
+// IPointerTypeContext is an interface to support dynamic dispatch.
+type IPointerTypeContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetStar returns the star token.
+	GetStar() antlr.Token
+
+	// SetStar sets the star token.
+	SetStar(antlr.Token)
+
+	// IsPointerTypeContext differentiates from other interfaces.
+	IsPointerTypeContext()
+}
+
+type PointerTypeContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	star   antlr.Token
+}
+
+func NewEmptyPointerTypeContext() *PointerTypeContext {
+	var p = new(PointerTypeContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_pointerType
+	return p
+}
+
+func (*PointerTypeContext) IsPointerTypeContext() {}
+
+func NewPointerTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PointerTypeContext {
+	var p = new(PointerTypeContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_pointerType
+
+	return p
+}
+
+func (s *PointerTypeContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *PointerTypeContext) GetStar() antlr.Token { return s.star }
+
+func (s *PointerTypeContext) SetStar(v antlr.Token) { s.star = v }
+
+func (s *PointerTypeContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *PointerTypeContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *PointerTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *PointerTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitPointerType(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) PointerType() (localctx IPointerTypeContext) {
+	localctx = NewPointerTypeContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 44, ApiParserParserRULE_pointerType)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(221)
+
+		var _m = p.Match(ApiParserParserT__5)
+
+		localctx.(*PointerTypeContext).star = _m
+	}
+	checkKeyword(p)
+	{
+		p.SetState(223)
+		p.Match(ApiParserParserID)
+	}
+
+	return localctx
+}
+
+// IMapTypeContext is an interface to support dynamic dispatch.
+type IMapTypeContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetMapToken returns the mapToken token.
+	GetMapToken() antlr.Token
+
+	// GetLbrack returns the lbrack token.
+	GetLbrack() antlr.Token
+
+	// GetKey returns the key token.
+	GetKey() antlr.Token
+
+	// GetRbrack returns the rbrack token.
+	GetRbrack() antlr.Token
+
+	// SetMapToken sets the mapToken token.
+	SetMapToken(antlr.Token)
+
+	// SetLbrack sets the lbrack token.
+	SetLbrack(antlr.Token)
+
+	// SetKey sets the key token.
+	SetKey(antlr.Token)
+
+	// SetRbrack sets the rbrack token.
+	SetRbrack(antlr.Token)
+
+	// GetValue returns the value rule contexts.
+	GetValue() IDataTypeContext
+
+	// SetValue sets the value rule contexts.
+	SetValue(IDataTypeContext)
+
+	// IsMapTypeContext differentiates from other interfaces.
+	IsMapTypeContext()
+}
+
+type MapTypeContext struct {
+	*antlr.BaseParserRuleContext
+	parser   antlr.Parser
+	mapToken antlr.Token
+	lbrack   antlr.Token
+	key      antlr.Token
+	rbrack   antlr.Token
+	value    IDataTypeContext
+}
+
+func NewEmptyMapTypeContext() *MapTypeContext {
+	var p = new(MapTypeContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_mapType
+	return p
+}
+
+func (*MapTypeContext) IsMapTypeContext() {}
+
+func NewMapTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapTypeContext {
+	var p = new(MapTypeContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_mapType
+
+	return p
+}
+
+func (s *MapTypeContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *MapTypeContext) GetMapToken() antlr.Token { return s.mapToken }
+
+func (s *MapTypeContext) GetLbrack() antlr.Token { return s.lbrack }
+
+func (s *MapTypeContext) GetKey() antlr.Token { return s.key }
+
+func (s *MapTypeContext) GetRbrack() antlr.Token { return s.rbrack }
+
+func (s *MapTypeContext) SetMapToken(v antlr.Token) { s.mapToken = v }
+
+func (s *MapTypeContext) SetLbrack(v antlr.Token) { s.lbrack = v }
+
+func (s *MapTypeContext) SetKey(v antlr.Token) { s.key = v }
+
+func (s *MapTypeContext) SetRbrack(v antlr.Token) { s.rbrack = v }
+
+func (s *MapTypeContext) GetValue() IDataTypeContext { return s.value }
+
+func (s *MapTypeContext) SetValue(v IDataTypeContext) { s.value = v }
+
+func (s *MapTypeContext) AllID() []antlr.TerminalNode {
+	return s.GetTokens(ApiParserParserID)
+}
+
+func (s *MapTypeContext) ID(i int) antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, i)
+}
+
+func (s *MapTypeContext) DataType() IDataTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IDataTypeContext)
+}
+
+func (s *MapTypeContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *MapTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *MapTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitMapType(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) MapType() (localctx IMapTypeContext) {
+	localctx = NewMapTypeContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 46, ApiParserParserRULE_mapType)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "map")
+	{
+		p.SetState(226)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*MapTypeContext).mapToken = _m
+	}
+	{
+		p.SetState(227)
+
+		var _m = p.Match(ApiParserParserT__7)
+
+		localctx.(*MapTypeContext).lbrack = _m
+	}
+	checkKey(p)
+	{
+		p.SetState(229)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*MapTypeContext).key = _m
+	}
+	{
+		p.SetState(230)
+
+		var _m = p.Match(ApiParserParserT__8)
+
+		localctx.(*MapTypeContext).rbrack = _m
+	}
+	{
+		p.SetState(231)
+
+		var _x = p.DataType()
+
+		localctx.(*MapTypeContext).value = _x
+	}
+
+	return localctx
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser6.go

@@ -0,0 +1,613 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 6
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+// IArrayTypeContext is an interface to support dynamic dispatch.
+type IArrayTypeContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetLbrack returns the lbrack token.
+	GetLbrack() antlr.Token
+
+	// GetRbrack returns the rbrack token.
+	GetRbrack() antlr.Token
+
+	// SetLbrack sets the lbrack token.
+	SetLbrack(antlr.Token)
+
+	// SetRbrack sets the rbrack token.
+	SetRbrack(antlr.Token)
+
+	// IsArrayTypeContext differentiates from other interfaces.
+	IsArrayTypeContext()
+}
+
+type ArrayTypeContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	lbrack antlr.Token
+	rbrack antlr.Token
+}
+
+func NewEmptyArrayTypeContext() *ArrayTypeContext {
+	var p = new(ArrayTypeContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_arrayType
+	return p
+}
+
+func (*ArrayTypeContext) IsArrayTypeContext() {}
+
+func NewArrayTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayTypeContext {
+	var p = new(ArrayTypeContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_arrayType
+
+	return p
+}
+
+func (s *ArrayTypeContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ArrayTypeContext) GetLbrack() antlr.Token { return s.lbrack }
+
+func (s *ArrayTypeContext) GetRbrack() antlr.Token { return s.rbrack }
+
+func (s *ArrayTypeContext) SetLbrack(v antlr.Token) { s.lbrack = v }
+
+func (s *ArrayTypeContext) SetRbrack(v antlr.Token) { s.rbrack = v }
+
+func (s *ArrayTypeContext) DataType() IDataTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IDataTypeContext)
+}
+
+func (s *ArrayTypeContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ArrayTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ArrayTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitArrayType(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ArrayType() (localctx IArrayTypeContext) {
+	localctx = NewArrayTypeContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 48, ApiParserParserRULE_arrayType)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(233)
+
+		var _m = p.Match(ApiParserParserT__7)
+
+		localctx.(*ArrayTypeContext).lbrack = _m
+	}
+	{
+		p.SetState(234)
+
+		var _m = p.Match(ApiParserParserT__8)
+
+		localctx.(*ArrayTypeContext).rbrack = _m
+	}
+	{
+		p.SetState(235)
+		p.DataType()
+	}
+
+	return localctx
+}
+
+// IServiceSpecContext is an interface to support dynamic dispatch.
+type IServiceSpecContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsServiceSpecContext differentiates from other interfaces.
+	IsServiceSpecContext()
+}
+
+type ServiceSpecContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyServiceSpecContext() *ServiceSpecContext {
+	var p = new(ServiceSpecContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_serviceSpec
+	return p
+}
+
+func (*ServiceSpecContext) IsServiceSpecContext() {}
+
+func NewServiceSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceSpecContext {
+	var p = new(ServiceSpecContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_serviceSpec
+
+	return p
+}
+
+func (s *ServiceSpecContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ServiceSpecContext) ServiceApi() IServiceApiContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IServiceApiContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IServiceApiContext)
+}
+
+func (s *ServiceSpecContext) AtServer() IAtServerContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAtServerContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IAtServerContext)
+}
+
+func (s *ServiceSpecContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ServiceSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ServiceSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitServiceSpec(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ServiceSpec() (localctx IServiceSpecContext) {
+	localctx = NewServiceSpecContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 50, ApiParserParserRULE_serviceSpec)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	p.SetState(238)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserATSERVER {
+		{
+			p.SetState(237)
+			p.AtServer()
+		}
+
+	}
+	{
+		p.SetState(240)
+		p.ServiceApi()
+	}
+
+	return localctx
+}
+
+// IAtServerContext is an interface to support dynamic dispatch.
+type IAtServerContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetLp returns the lp token.
+	GetLp() antlr.Token
+
+	// GetRp returns the rp token.
+	GetRp() antlr.Token
+
+	// SetLp sets the lp token.
+	SetLp(antlr.Token)
+
+	// SetRp sets the rp token.
+	SetRp(antlr.Token)
+
+	// IsAtServerContext differentiates from other interfaces.
+	IsAtServerContext()
+}
+
+type AtServerContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	lp     antlr.Token
+	rp     antlr.Token
+}
+
+func NewEmptyAtServerContext() *AtServerContext {
+	var p = new(AtServerContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_atServer
+	return p
+}
+
+func (*AtServerContext) IsAtServerContext() {}
+
+func NewAtServerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtServerContext {
+	var p = new(AtServerContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_atServer
+
+	return p
+}
+
+func (s *AtServerContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *AtServerContext) GetLp() antlr.Token { return s.lp }
+
+func (s *AtServerContext) GetRp() antlr.Token { return s.rp }
+
+func (s *AtServerContext) SetLp(v antlr.Token) { s.lp = v }
+
+func (s *AtServerContext) SetRp(v antlr.Token) { s.rp = v }
+
+func (s *AtServerContext) ATSERVER() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserATSERVER, 0)
+}
+
+func (s *AtServerContext) AllKvLit() []IKvLitContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())
+	var tst = make([]IKvLitContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IKvLitContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *AtServerContext) KvLit(i int) IKvLitContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IKvLitContext)
+}
+
+func (s *AtServerContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *AtServerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *AtServerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitAtServer(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) AtServer() (localctx IAtServerContext) {
+	localctx = NewAtServerContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 52, ApiParserParserRULE_atServer)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(242)
+		p.Match(ApiParserParserATSERVER)
+	}
+	{
+		p.SetState(243)
+
+		var _m = p.Match(ApiParserParserT__1)
+
+		localctx.(*AtServerContext).lp = _m
+	}
+	p.SetState(245)
+	p.GetErrorHandler().Sync(p)
+
+	for ok := true; ok; ok = _la == ApiParserParserID {
+		{
+			p.SetState(244)
+			p.KvLit()
+		}
+
+		p.SetState(247)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+	}
+	{
+		p.SetState(249)
+
+		var _m = p.Match(ApiParserParserT__2)
+
+		localctx.(*AtServerContext).rp = _m
+	}
+
+	return localctx
+}
+
+// IServiceApiContext is an interface to support dynamic dispatch.
+type IServiceApiContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetServiceToken returns the serviceToken token.
+	GetServiceToken() antlr.Token
+
+	// GetLbrace returns the lbrace token.
+	GetLbrace() antlr.Token
+
+	// GetRbrace returns the rbrace token.
+	GetRbrace() antlr.Token
+
+	// SetServiceToken sets the serviceToken token.
+	SetServiceToken(antlr.Token)
+
+	// SetLbrace sets the lbrace token.
+	SetLbrace(antlr.Token)
+
+	// SetRbrace sets the rbrace token.
+	SetRbrace(antlr.Token)
+
+	// IsServiceApiContext differentiates from other interfaces.
+	IsServiceApiContext()
+}
+
+type ServiceApiContext struct {
+	*antlr.BaseParserRuleContext
+	parser       antlr.Parser
+	serviceToken antlr.Token
+	lbrace       antlr.Token
+	rbrace       antlr.Token
+}
+
+func NewEmptyServiceApiContext() *ServiceApiContext {
+	var p = new(ServiceApiContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_serviceApi
+	return p
+}
+
+func (*ServiceApiContext) IsServiceApiContext() {}
+
+func NewServiceApiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceApiContext {
+	var p = new(ServiceApiContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_serviceApi
+
+	return p
+}
+
+func (s *ServiceApiContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ServiceApiContext) GetServiceToken() antlr.Token { return s.serviceToken }
+
+func (s *ServiceApiContext) GetLbrace() antlr.Token { return s.lbrace }
+
+func (s *ServiceApiContext) GetRbrace() antlr.Token { return s.rbrace }
+
+func (s *ServiceApiContext) SetServiceToken(v antlr.Token) { s.serviceToken = v }
+
+func (s *ServiceApiContext) SetLbrace(v antlr.Token) { s.lbrace = v }
+
+func (s *ServiceApiContext) SetRbrace(v antlr.Token) { s.rbrace = v }
+
+func (s *ServiceApiContext) ServiceName() IServiceNameContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IServiceNameContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IServiceNameContext)
+}
+
+func (s *ServiceApiContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *ServiceApiContext) AllServiceRoute() []IServiceRouteContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IServiceRouteContext)(nil)).Elem())
+	var tst = make([]IServiceRouteContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IServiceRouteContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *ServiceApiContext) ServiceRoute(i int) IServiceRouteContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IServiceRouteContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IServiceRouteContext)
+}
+
+func (s *ServiceApiContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ServiceApiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ServiceApiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitServiceApi(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ServiceApi() (localctx IServiceApiContext) {
+	localctx = NewServiceApiContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 54, ApiParserParserRULE_serviceApi)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	match(p, "service")
+	{
+		p.SetState(252)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*ServiceApiContext).serviceToken = _m
+	}
+	{
+		p.SetState(253)
+		p.ServiceName()
+	}
+	{
+		p.SetState(254)
+
+		var _m = p.Match(ApiParserParserT__3)
+
+		localctx.(*ServiceApiContext).lbrace = _m
+	}
+	p.SetState(258)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	for ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ApiParserParserATDOC)|(1<<ApiParserParserATHANDLER)|(1<<ApiParserParserATSERVER))) != 0 {
+		{
+			p.SetState(255)
+			p.ServiceRoute()
+		}
+
+		p.SetState(260)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+	}
+	{
+		p.SetState(261)
+
+		var _m = p.Match(ApiParserParserT__4)
+
+		localctx.(*ServiceApiContext).rbrace = _m
+	}
+
+	return localctx
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser7.go

@@ -0,0 +1,676 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 7
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+// IServiceRouteContext is an interface to support dynamic dispatch.
+type IServiceRouteContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsServiceRouteContext differentiates from other interfaces.
+	IsServiceRouteContext()
+}
+
+type ServiceRouteContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyServiceRouteContext() *ServiceRouteContext {
+	var p = new(ServiceRouteContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_serviceRoute
+	return p
+}
+
+func (*ServiceRouteContext) IsServiceRouteContext() {}
+
+func NewServiceRouteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceRouteContext {
+	var p = new(ServiceRouteContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_serviceRoute
+
+	return p
+}
+
+func (s *ServiceRouteContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ServiceRouteContext) Route() IRouteContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IRouteContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IRouteContext)
+}
+
+func (s *ServiceRouteContext) AtServer() IAtServerContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAtServerContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IAtServerContext)
+}
+
+func (s *ServiceRouteContext) AtHandler() IAtHandlerContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAtHandlerContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IAtHandlerContext)
+}
+
+func (s *ServiceRouteContext) AtDoc() IAtDocContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IAtDocContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IAtDocContext)
+}
+
+func (s *ServiceRouteContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ServiceRouteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ServiceRouteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitServiceRoute(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ServiceRoute() (localctx IServiceRouteContext) {
+	localctx = NewServiceRouteContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 56, ApiParserParserRULE_serviceRoute)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	p.SetState(264)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserATDOC {
+		{
+			p.SetState(263)
+			p.AtDoc()
+		}
+
+	}
+	p.SetState(268)
+	p.GetErrorHandler().Sync(p)
+
+	switch p.GetTokenStream().LA(1) {
+	case ApiParserParserATSERVER:
+		{
+			p.SetState(266)
+			p.AtServer()
+		}
+
+	case ApiParserParserATHANDLER:
+		{
+			p.SetState(267)
+			p.AtHandler()
+		}
+
+	default:
+		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
+	}
+	{
+		p.SetState(270)
+		p.Route()
+	}
+
+	return localctx
+}
+
+// IAtDocContext is an interface to support dynamic dispatch.
+type IAtDocContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetLp returns the lp token.
+	GetLp() antlr.Token
+
+	// GetRp returns the rp token.
+	GetRp() antlr.Token
+
+	// SetLp sets the lp token.
+	SetLp(antlr.Token)
+
+	// SetRp sets the rp token.
+	SetRp(antlr.Token)
+
+	// IsAtDocContext differentiates from other interfaces.
+	IsAtDocContext()
+}
+
+type AtDocContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	lp     antlr.Token
+	rp     antlr.Token
+}
+
+func NewEmptyAtDocContext() *AtDocContext {
+	var p = new(AtDocContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_atDoc
+	return p
+}
+
+func (*AtDocContext) IsAtDocContext() {}
+
+func NewAtDocContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtDocContext {
+	var p = new(AtDocContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_atDoc
+
+	return p
+}
+
+func (s *AtDocContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *AtDocContext) GetLp() antlr.Token { return s.lp }
+
+func (s *AtDocContext) GetRp() antlr.Token { return s.rp }
+
+func (s *AtDocContext) SetLp(v antlr.Token) { s.lp = v }
+
+func (s *AtDocContext) SetRp(v antlr.Token) { s.rp = v }
+
+func (s *AtDocContext) ATDOC() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserATDOC, 0)
+}
+
+func (s *AtDocContext) STRING() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserSTRING, 0)
+}
+
+func (s *AtDocContext) AllKvLit() []IKvLitContext {
+	var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IKvLitContext)(nil)).Elem())
+	var tst = make([]IKvLitContext, len(ts))
+
+	for i, t := range ts {
+		if t != nil {
+			tst[i] = t.(IKvLitContext)
+		}
+	}
+
+	return tst
+}
+
+func (s *AtDocContext) KvLit(i int) IKvLitContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IKvLitContext)(nil)).Elem(), i)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IKvLitContext)
+}
+
+func (s *AtDocContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *AtDocContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *AtDocContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitAtDoc(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) AtDoc() (localctx IAtDocContext) {
+	localctx = NewAtDocContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 58, ApiParserParserRULE_atDoc)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(272)
+		p.Match(ApiParserParserATDOC)
+	}
+	p.SetState(274)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserT__1 {
+		{
+			p.SetState(273)
+
+			var _m = p.Match(ApiParserParserT__1)
+
+			localctx.(*AtDocContext).lp = _m
+		}
+
+	}
+	p.SetState(282)
+	p.GetErrorHandler().Sync(p)
+
+	switch p.GetTokenStream().LA(1) {
+	case ApiParserParserID:
+		p.SetState(277)
+		p.GetErrorHandler().Sync(p)
+
+		for ok := true; ok; ok = _la == ApiParserParserID {
+			{
+				p.SetState(276)
+				p.KvLit()
+			}
+
+			p.SetState(279)
+			p.GetErrorHandler().Sync(p)
+			_la = p.GetTokenStream().LA(1)
+		}
+
+	case ApiParserParserSTRING:
+		{
+			p.SetState(281)
+			p.Match(ApiParserParserSTRING)
+		}
+
+	default:
+		panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
+	}
+	p.SetState(285)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserT__2 {
+		{
+			p.SetState(284)
+
+			var _m = p.Match(ApiParserParserT__2)
+
+			localctx.(*AtDocContext).rp = _m
+		}
+
+	}
+
+	return localctx
+}
+
+// IAtHandlerContext is an interface to support dynamic dispatch.
+type IAtHandlerContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsAtHandlerContext differentiates from other interfaces.
+	IsAtHandlerContext()
+}
+
+type AtHandlerContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyAtHandlerContext() *AtHandlerContext {
+	var p = new(AtHandlerContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_atHandler
+	return p
+}
+
+func (*AtHandlerContext) IsAtHandlerContext() {}
+
+func NewAtHandlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtHandlerContext {
+	var p = new(AtHandlerContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_atHandler
+
+	return p
+}
+
+func (s *AtHandlerContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *AtHandlerContext) ATHANDLER() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserATHANDLER, 0)
+}
+
+func (s *AtHandlerContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *AtHandlerContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *AtHandlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *AtHandlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitAtHandler(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) AtHandler() (localctx IAtHandlerContext) {
+	localctx = NewAtHandlerContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 60, ApiParserParserRULE_atHandler)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(287)
+		p.Match(ApiParserParserATHANDLER)
+	}
+	{
+		p.SetState(288)
+		p.Match(ApiParserParserID)
+	}
+
+	return localctx
+}
+
+// IRouteContext is an interface to support dynamic dispatch.
+type IRouteContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetHttpMethod returns the httpMethod token.
+	GetHttpMethod() antlr.Token
+
+	// GetReturnToken returns the returnToken token.
+	GetReturnToken() antlr.Token
+
+	// SetHttpMethod sets the httpMethod token.
+	SetHttpMethod(antlr.Token)
+
+	// SetReturnToken sets the returnToken token.
+	SetReturnToken(antlr.Token)
+
+	// GetRequest returns the request rule contexts.
+	GetRequest() IBodyContext
+
+	// GetResponse returns the response rule contexts.
+	GetResponse() IReplybodyContext
+
+	// SetRequest sets the request rule contexts.
+	SetRequest(IBodyContext)
+
+	// SetResponse sets the response rule contexts.
+	SetResponse(IReplybodyContext)
+
+	// IsRouteContext differentiates from other interfaces.
+	IsRouteContext()
+}
+
+type RouteContext struct {
+	*antlr.BaseParserRuleContext
+	parser      antlr.Parser
+	httpMethod  antlr.Token
+	request     IBodyContext
+	returnToken antlr.Token
+	response    IReplybodyContext
+}
+
+func NewEmptyRouteContext() *RouteContext {
+	var p = new(RouteContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_route
+	return p
+}
+
+func (*RouteContext) IsRouteContext() {}
+
+func NewRouteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RouteContext {
+	var p = new(RouteContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_route
+
+	return p
+}
+
+func (s *RouteContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *RouteContext) GetHttpMethod() antlr.Token { return s.httpMethod }
+
+func (s *RouteContext) GetReturnToken() antlr.Token { return s.returnToken }
+
+func (s *RouteContext) SetHttpMethod(v antlr.Token) { s.httpMethod = v }
+
+func (s *RouteContext) SetReturnToken(v antlr.Token) { s.returnToken = v }
+
+func (s *RouteContext) GetRequest() IBodyContext { return s.request }
+
+func (s *RouteContext) GetResponse() IReplybodyContext { return s.response }
+
+func (s *RouteContext) SetRequest(v IBodyContext) { s.request = v }
+
+func (s *RouteContext) SetResponse(v IReplybodyContext) { s.response = v }
+
+func (s *RouteContext) Path() IPathContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IPathContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IPathContext)
+}
+
+func (s *RouteContext) AllID() []antlr.TerminalNode {
+	return s.GetTokens(ApiParserParserID)
+}
+
+func (s *RouteContext) ID(i int) antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, i)
+}
+
+func (s *RouteContext) Body() IBodyContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IBodyContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IBodyContext)
+}
+
+func (s *RouteContext) Replybody() IReplybodyContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IReplybodyContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IReplybodyContext)
+}
+
+func (s *RouteContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *RouteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *RouteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitRoute(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) Route() (localctx IRouteContext) {
+	localctx = NewRouteContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 62, ApiParserParserRULE_route)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	checkHTTPMethod(p)
+	{
+		p.SetState(291)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*RouteContext).httpMethod = _m
+	}
+	{
+		p.SetState(292)
+		p.Path()
+	}
+	p.SetState(294)
+	p.GetErrorHandler().Sync(p)
+
+	if p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 {
+		{
+			p.SetState(293)
+
+			var _x = p.Body()
+
+			localctx.(*RouteContext).request = _x
+		}
+
+	}
+	p.SetState(297)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserID {
+		{
+			p.SetState(296)
+
+			var _m = p.Match(ApiParserParserID)
+
+			localctx.(*RouteContext).returnToken = _m
+		}
+
+	}
+	p.SetState(300)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserT__1 {
+		{
+			p.SetState(299)
+
+			var _x = p.Replybody()
+
+			localctx.(*RouteContext).response = _x
+		}
+
+	}
+
+	return localctx
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser8.go

@@ -0,0 +1,697 @@
+package api
+
+import (
+	"reflect"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 8
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+// IBodyContext is an interface to support dynamic dispatch.
+type IBodyContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetLp returns the lp token.
+	GetLp() antlr.Token
+
+	// GetRp returns the rp token.
+	GetRp() antlr.Token
+
+	// SetLp sets the lp token.
+	SetLp(antlr.Token)
+
+	// SetRp sets the rp token.
+	SetRp(antlr.Token)
+
+	// IsBodyContext differentiates from other interfaces.
+	IsBodyContext()
+}
+
+type BodyContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	lp     antlr.Token
+	rp     antlr.Token
+}
+
+func NewEmptyBodyContext() *BodyContext {
+	var p = new(BodyContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_body
+	return p
+}
+
+func (*BodyContext) IsBodyContext() {}
+
+func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext {
+	var p = new(BodyContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_body
+
+	return p
+}
+
+func (s *BodyContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *BodyContext) GetLp() antlr.Token { return s.lp }
+
+func (s *BodyContext) GetRp() antlr.Token { return s.rp }
+
+func (s *BodyContext) SetLp(v antlr.Token) { s.lp = v }
+
+func (s *BodyContext) SetRp(v antlr.Token) { s.rp = v }
+
+func (s *BodyContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *BodyContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *BodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *BodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitBody(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) Body() (localctx IBodyContext) {
+	localctx = NewBodyContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 64, ApiParserParserRULE_body)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(302)
+
+		var _m = p.Match(ApiParserParserT__1)
+
+		localctx.(*BodyContext).lp = _m
+	}
+	p.SetState(304)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if _la == ApiParserParserID {
+		{
+			p.SetState(303)
+			p.Match(ApiParserParserID)
+		}
+
+	}
+	{
+		p.SetState(306)
+
+		var _m = p.Match(ApiParserParserT__2)
+
+		localctx.(*BodyContext).rp = _m
+	}
+
+	return localctx
+}
+
+// IReplybodyContext is an interface to support dynamic dispatch.
+type IReplybodyContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetLp returns the lp token.
+	GetLp() antlr.Token
+
+	// GetRp returns the rp token.
+	GetRp() antlr.Token
+
+	// SetLp sets the lp token.
+	SetLp(antlr.Token)
+
+	// SetRp sets the rp token.
+	SetRp(antlr.Token)
+
+	// IsReplybodyContext differentiates from other interfaces.
+	IsReplybodyContext()
+}
+
+type ReplybodyContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	lp     antlr.Token
+	rp     antlr.Token
+}
+
+func NewEmptyReplybodyContext() *ReplybodyContext {
+	var p = new(ReplybodyContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_replybody
+	return p
+}
+
+func (*ReplybodyContext) IsReplybodyContext() {}
+
+func NewReplybodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplybodyContext {
+	var p = new(ReplybodyContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_replybody
+
+	return p
+}
+
+func (s *ReplybodyContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ReplybodyContext) GetLp() antlr.Token { return s.lp }
+
+func (s *ReplybodyContext) GetRp() antlr.Token { return s.rp }
+
+func (s *ReplybodyContext) SetLp(v antlr.Token) { s.lp = v }
+
+func (s *ReplybodyContext) SetRp(v antlr.Token) { s.rp = v }
+
+func (s *ReplybodyContext) DataType() IDataTypeContext {
+	var t = s.GetTypedRuleContext(reflect.TypeOf((*IDataTypeContext)(nil)).Elem(), 0)
+
+	if t == nil {
+		return nil
+	}
+
+	return t.(IDataTypeContext)
+}
+
+func (s *ReplybodyContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ReplybodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ReplybodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitReplybody(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) Replybody() (localctx IReplybodyContext) {
+	localctx = NewReplybodyContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 66, ApiParserParserRULE_replybody)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(308)
+
+		var _m = p.Match(ApiParserParserT__1)
+
+		localctx.(*ReplybodyContext).lp = _m
+	}
+	p.SetState(310)
+	p.GetErrorHandler().Sync(p)
+	_la = p.GetTokenStream().LA(1)
+
+	if ((_la)&-(0x1f+1)) == 0 && ((1<<uint(_la))&((1<<ApiParserParserT__5)|(1<<ApiParserParserT__6)|(1<<ApiParserParserT__7)|(1<<ApiParserParserINTERFACE)|(1<<ApiParserParserID))) != 0 {
+		{
+			p.SetState(309)
+			p.DataType()
+		}
+
+	}
+	{
+		p.SetState(312)
+
+		var _m = p.Match(ApiParserParserT__2)
+
+		localctx.(*ReplybodyContext).rp = _m
+	}
+
+	return localctx
+}
+
+// IKvLitContext is an interface to support dynamic dispatch.
+type IKvLitContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// GetKey returns the key token.
+	GetKey() antlr.Token
+
+	// GetValue returns the value token.
+	GetValue() antlr.Token
+
+	// SetKey sets the key token.
+	SetKey(antlr.Token)
+
+	// SetValue sets the value token.
+	SetValue(antlr.Token)
+
+	// IsKvLitContext differentiates from other interfaces.
+	IsKvLitContext()
+}
+
+type KvLitContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+	key    antlr.Token
+	value  antlr.Token
+}
+
+func NewEmptyKvLitContext() *KvLitContext {
+	var p = new(KvLitContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_kvLit
+	return p
+}
+
+func (*KvLitContext) IsKvLitContext() {}
+
+func NewKvLitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KvLitContext {
+	var p = new(KvLitContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_kvLit
+
+	return p
+}
+
+func (s *KvLitContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *KvLitContext) GetKey() antlr.Token { return s.key }
+
+func (s *KvLitContext) GetValue() antlr.Token { return s.value }
+
+func (s *KvLitContext) SetKey(v antlr.Token) { s.key = v }
+
+func (s *KvLitContext) SetValue(v antlr.Token) { s.value = v }
+
+func (s *KvLitContext) ID() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, 0)
+}
+
+func (s *KvLitContext) LINE_VALUE() antlr.TerminalNode {
+	return s.GetToken(ApiParserParserLINE_VALUE, 0)
+}
+
+func (s *KvLitContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *KvLitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *KvLitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitKvLit(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) KvLit() (localctx IKvLitContext) {
+	localctx = NewKvLitContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 68, ApiParserParserRULE_kvLit)
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	{
+		p.SetState(314)
+
+		var _m = p.Match(ApiParserParserID)
+
+		localctx.(*KvLitContext).key = _m
+	}
+	checkKeyValue(p)
+	{
+		p.SetState(316)
+
+		var _m = p.Match(ApiParserParserLINE_VALUE)
+
+		localctx.(*KvLitContext).value = _m
+	}
+
+	return localctx
+}
+
+// IServiceNameContext is an interface to support dynamic dispatch.
+type IServiceNameContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsServiceNameContext differentiates from other interfaces.
+	IsServiceNameContext()
+}
+
+type ServiceNameContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyServiceNameContext() *ServiceNameContext {
+	var p = new(ServiceNameContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_serviceName
+	return p
+}
+
+func (*ServiceNameContext) IsServiceNameContext() {}
+
+func NewServiceNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ServiceNameContext {
+	var p = new(ServiceNameContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_serviceName
+
+	return p
+}
+
+func (s *ServiceNameContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *ServiceNameContext) AllID() []antlr.TerminalNode {
+	return s.GetTokens(ApiParserParserID)
+}
+
+func (s *ServiceNameContext) ID(i int) antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, i)
+}
+
+func (s *ServiceNameContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *ServiceNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *ServiceNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitServiceName(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) ServiceName() (localctx IServiceNameContext) {
+	localctx = NewServiceNameContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 70, ApiParserParserRULE_serviceName)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.EnterOuterAlt(localctx, 1)
+	p.SetState(322)
+	p.GetErrorHandler().Sync(p)
+
+	for ok := true; ok; ok = _la == ApiParserParserID {
+		{
+			p.SetState(318)
+			p.Match(ApiParserParserID)
+		}
+		p.SetState(320)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+
+		if _la == ApiParserParserT__9 {
+			{
+				p.SetState(319)
+				p.Match(ApiParserParserT__9)
+			}
+
+		}
+
+		p.SetState(324)
+		p.GetErrorHandler().Sync(p)
+		_la = p.GetTokenStream().LA(1)
+	}
+
+	return localctx
+}
+
+// IPathContext is an interface to support dynamic dispatch.
+type IPathContext interface {
+	antlr.ParserRuleContext
+
+	// GetParser returns the parser.
+	GetParser() antlr.Parser
+
+	// IsPathContext differentiates from other interfaces.
+	IsPathContext()
+}
+
+type PathContext struct {
+	*antlr.BaseParserRuleContext
+	parser antlr.Parser
+}
+
+func NewEmptyPathContext() *PathContext {
+	var p = new(PathContext)
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
+	p.RuleIndex = ApiParserParserRULE_path
+	return p
+}
+
+func (*PathContext) IsPathContext() {}
+
+func NewPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PathContext {
+	var p = new(PathContext)
+
+	p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
+
+	p.parser = parser
+	p.RuleIndex = ApiParserParserRULE_path
+
+	return p
+}
+
+func (s *PathContext) GetParser() antlr.Parser { return s.parser }
+
+func (s *PathContext) AllID() []antlr.TerminalNode {
+	return s.GetTokens(ApiParserParserID)
+}
+
+func (s *PathContext) ID(i int) antlr.TerminalNode {
+	return s.GetToken(ApiParserParserID, i)
+}
+
+func (s *PathContext) GetRuleContext() antlr.RuleContext {
+	return s
+}
+
+func (s *PathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
+	return antlr.TreesStringTree(s, ruleNames, recog)
+}
+
+func (s *PathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
+	switch t := visitor.(type) {
+	case ApiParserVisitor:
+		return t.VisitPath(s)
+
+	default:
+		return t.VisitChildren(s)
+	}
+}
+
+func (p *ApiParserParser) Path() (localctx IPathContext) {
+	localctx = NewPathContext(p, p.GetParserRuleContext(), p.GetState())
+	p.EnterRule(localctx, 72, ApiParserParserRULE_path)
+	var _la int
+
+	defer func() {
+		p.ExitRule()
+	}()
+
+	defer func() {
+		if err := recover(); err != nil {
+			if v, ok := err.(antlr.RecognitionException); ok {
+				localctx.SetException(v)
+				p.GetErrorHandler().ReportError(p, v)
+				p.GetErrorHandler().Recover(p, v)
+			} else {
+				panic(err)
+			}
+		}
+	}()
+
+	p.SetState(346)
+	p.GetErrorHandler().Sync(p)
+	switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 39, p.GetParserRuleContext()) {
+	case 1:
+		p.EnterOuterAlt(localctx, 1)
+		p.SetState(341)
+		p.GetErrorHandler().Sync(p)
+
+		for ok := true; ok; ok = _la == ApiParserParserT__10 || _la == ApiParserParserT__11 {
+			p.SetState(341)
+			p.GetErrorHandler().Sync(p)
+
+			switch p.GetTokenStream().LA(1) {
+			case ApiParserParserT__10:
+				{
+					p.SetState(326)
+					p.Match(ApiParserParserT__10)
+				}
+
+				{
+					p.SetState(327)
+					p.Match(ApiParserParserID)
+				}
+				p.SetState(332)
+				p.GetErrorHandler().Sync(p)
+				_la = p.GetTokenStream().LA(1)
+
+				for _la == ApiParserParserT__9 {
+					{
+						p.SetState(328)
+						p.Match(ApiParserParserT__9)
+					}
+					{
+						p.SetState(329)
+						p.Match(ApiParserParserID)
+					}
+
+					p.SetState(334)
+					p.GetErrorHandler().Sync(p)
+					_la = p.GetTokenStream().LA(1)
+				}
+
+			case ApiParserParserT__11:
+				{
+					p.SetState(335)
+					p.Match(ApiParserParserT__11)
+				}
+
+				{
+					p.SetState(336)
+					p.Match(ApiParserParserID)
+				}
+				p.SetState(339)
+				p.GetErrorHandler().Sync(p)
+				_la = p.GetTokenStream().LA(1)
+
+				if _la == ApiParserParserT__9 {
+					{
+						p.SetState(337)
+						p.Match(ApiParserParserT__9)
+					}
+					{
+						p.SetState(338)
+						p.Match(ApiParserParserID)
+					}
+
+				}
+
+			default:
+				panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
+			}
+
+			p.SetState(343)
+			p.GetErrorHandler().Sync(p)
+			_la = p.GetTokenStream().LA(1)
+		}
+
+	case 2:
+		p.EnterOuterAlt(localctx, 2)
+		{
+			p.SetState(345)
+			p.Match(ApiParserParserT__10)
+		}
+
+	}
+
+	return localctx
+}

tools/goctl/api/parser/g4/gen/api/apiparser_parser9.go

@@ -0,0 +1,35 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/zeromicro/antlr"
+)
+
+// Part 9
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+
+func (p *ApiParserParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {
+	switch ruleIndex {
+	case 18:
+		var t *FieldContext = nil
+		if localctx != nil {
+			t = localctx.(*FieldContext)
+		}
+		return p.Field_Sempred(t, predIndex)
+
+	default:
+		panic("No predicate with index: " + fmt.Sprint(ruleIndex))
+	}
+}
+
+func (p *ApiParserParser) Field_Sempred(localctx antlr.RuleContext, predIndex int) bool {
+	switch predIndex {
+	case 0:
+		return isNormal(p)
+
+	default:
+		panic("No predicate with index: " + fmt.Sprint(predIndex))
+	}
+}

tools/goctl/api/parser/g4/gen/api/apiparser_visitor.go

@@ -1,5 +1,3 @@
-// Code generated from tools/goctl/api/parser/g4/ApiParser.g4 by ANTLR 4.9. DO NOT EDIT.
-
 package api // ApiParser
 import "github.com/zeromicro/antlr"
 

tools/goctl/api/parser/g4/gen/api/file_splitor_test.go

@@ -0,0 +1,79 @@
+// DO NOT EDIT.
+// Tool: split apiparser_parser.go
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+package api
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestFileSplitor(t *testing.T) {
+	dir := "."
+	data, err := ioutil.ReadFile(filepath.Join(dir, "apiparser_parser.go"))
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	r := bytes.NewReader(data)
+	reader := bufio.NewReader(r)
+	var lines, files int
+	buffer := bytes.NewBuffer(nil)
+
+	for {
+		var fn, part = "apiparser_parser0.go", "main"
+		if files > 0 {
+			fn = fmt.Sprintf("apiparser_parser%d.go", files)
+			part = fmt.Sprintf("%d", files)
+		}
+		fp := filepath.Join(dir, fn)
+		buffer.Reset()
+		if files > 0 {
+			buffer.WriteString(fmt.Sprintf(`package api
+import "github.com/zeromicro/antlr"
+
+// Part %s
+// The apiparser_parser.go file was split into multiple files because it
+// was too large and caused a possible memory overflow during goctl installation.
+`, part))
+		}
+
+		var exit bool
+		for {
+			line, _, err := reader.ReadLine()
+			buffer.Write(line)
+			buffer.WriteRune('\n')
+			if err != nil {
+				fmt.Printf("%+v\n", err)
+				exit = true
+				break
+			}
+			lines += 1
+			if string(line) == "}" && lines >= 650 {
+				break
+			}
+		}
+
+		err = ioutil.WriteFile(fp, buffer.Bytes(), os.ModePerm)
+		if err != nil {
+			fmt.Printf("%+v\n", err)
+		}
+		if exit {
+			break
+		}
+		lines = 0
+		files += 1
+	}
+
+	err = os.Rename(filepath.Join(dir, "apiparser_parser0.go"), filepath.Join(dir, "apiparser_parser.go"))
+	if err != nil {
+		log.Fatalln(err)
+	}
+}