[edk2-devel] [Patch V1 1/3] BaseTools: Add Python VfrCompiler tool
Yuwei Chen
yuwei.chen at intel.com
Mon Jan 30 06:20:50 UTC 2023
From: Yuting Yang <yuting2.yang at intel.com>
This is the python implementation of the C VfrCompiler tool.
Currently, this python tool will generate yaml/json files
for better variable related information presentation.
In future, it will cover the same usage as the C tool.
Cc: Bob Feng <bob.c.feng at intel.com>
Cc: Liming Gao <gaoliming at byosoft.com.cn>
Cc: Yuwei Chen <yuwei.chen at intel.com>
Signed-off-by: Yuting Yang <yuting2.yang at intel.com>
---
edk2basetools/VfrCompiler/CommonCtypes.py | 1394 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/README.md | 20 +
edk2basetools/VfrCompiler/VfrError.py | 162 ++++++++
edk2basetools/VfrCompiler/VfrFormPkg.py | 2738 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/VfrSyntax.g4 | 1887 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/VfrSyntaxLexer.py | 1709 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/VfrSyntaxParser.py | 20460 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/VfrSyntaxVisitor.py | 5106 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/VfrTree.py | 88 +++++
edk2basetools/VfrCompiler/VfrUtility.py | 1991 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
edk2basetools/VfrCompiler/main.py | 27 ++
11 files changed, 35582 insertions(+)
diff --git a/edk2basetools/VfrCompiler/CommonCtypes.py b/edk2basetools/VfrCompiler/CommonCtypes.py
new file mode 100644
index 0000000..2de7777
--- /dev/null
+++ b/edk2basetools/VfrCompiler/CommonCtypes.py
@@ -0,0 +1,1394 @@
+from ctypes import *
+from re import A, X
+from telnetlib import X3PAD
+from tkinter import YView
+import uuid
+from VfrCompiler.VfrError import *
+from struct import *
+
+EFI_STRING_ID_INVALID = 0x0
+EFI_HII_DEFAULT_CLASS_STANDARD = 0x0000
+EFI_HII_DEFAULT_CLASS_MANUFACTURING = 0x0001
+EFI_IFR_MAX_LENGTH = 0xFF
+EFI_VARSTORE_ID_INVALID = 0
+EFI_VARSTORE_ID_START = 0x20
+EFI_VAROFFSET_INVALID = 0xFFFF
+EFI_IMAGE_ID_INVALID = 0xFFFF
+
+EFI_NON_DEVICE_CLASS = 0x00
+EFI_DISK_DEVICE_CLASS = 0x01
+EFI_VIDEO_DEVICE_CLASS = 0x02
+EFI_NETWORK_DEVICE_CLASS = 0x04
+EFI_INPUT_DEVICE_CLASS = 0x08
+EFI_ON_BOARD_DEVICE_CLASS = 0x10
+EFI_OTHER_DEVICE_CLASS = 0x20
+
+EFI_SETUP_APPLICATION_SUBCLASS = 0x00
+EFI_GENERAL_APPLICATION_SUBCLASS = 0x01
+EFI_FRONT_PAGE_SUBCLASS = 0x02
+EFI_SINGLE_USE_SUBCLASS = 0x03
+
+# EFI_HII_PACKAGE_TYPE_x.
+
+EFI_HII_PACKAGE_TYPE_ALL = 0x00
+EFI_HII_PACKAGE_TYPE_GUID = 0x01
+EFI_HII_PACKAGE_FORM = 0x02
+EFI_HII_PACKAGE_KEYBOARD_LAYOUT = 0x03
+EFI_HII_PACKAGE_STRINGS = 0x04
+EFI_HII_PACKAGE_FONTS = 0x05
+EFI_HII_PACKAGE_IMAGES = 0x06
+EFI_HII_PACKAGE_SIMPLE_FONTS = 0x07
+EFI_HII_PACKAGE_DEVICE_PATH = 0x08
+EFI_HII_PACKAGE_END = 0xDF
+EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN = 0xE0
+EFI_HII_PACKAGE_TYPE_SYSTEM_END = 0xFF
+
+EFI_IFR_EXTEND_OP_LABEL = 0x0
+EFI_IFR_EXTEND_OP_BANNER = 0x1
+EFI_IFR_EXTEND_OP_TIMEOUT = 0x2
+EFI_IFR_EXTEND_OP_CLASS = 0x3
+EFI_IFR_EXTEND_OP_SUBCLASS = 0x4
+
+MAX_IFR_EXPRESSION_DEPTH = 0x9
+
+INVALID_ARRAY_INDEX = 0xFFFFFFFF
+
+EFI_IFR_TYPE_NUM_SIZE_8 = 0x00
+EFI_IFR_TYPE_NUM_SIZE_16 = 0x01
+EFI_IFR_TYPE_NUM_SIZE_32 = 0x02
+EFI_IFR_TYPE_NUM_SIZE_64 = 0x03
+EFI_IFR_TYPE_BOOLEAN = 0x04
+EFI_IFR_TYPE_TIME = 0x05
+EFI_IFR_TYPE_DATE = 0x06
+EFI_IFR_TYPE_STRING = 0x07
+EFI_IFR_TYPE_OTHER = 0x08
+EFI_IFR_TYPE_UNDEFINED = 0x09
+EFI_IFR_TYPE_ACTION = 0x0A
+EFI_IFR_TYPE_BUFFER = 0x0B
+EFI_IFR_TYPE_REF = 0x0C
+
+
+EFI_IFR_FLAGS_HORIZONTAL = 0x01
+
+EFI_IFR_FLAG_READ_ONLY = 0x01
+EFI_IFR_FLAG_CALLBACK = 0x04
+EFI_IFR_FLAG_RESET_REQUIRED = 0x10
+EFI_IFR_FLAG_REST_STYLE = 0x20
+EFI_IFR_FLAG_RECONNECT_REQUIRED = 0x40
+EFI_IFR_FLAG_OPTIONS_ONLY = 0x80
+
+EFI_IFR_STRING_MULTI_LINE = 0x01
+
+EDKII_IFR_DISPLAY_BIT = 0xC0
+EDKII_IFR_DISPLAY_INT_DEC_BIT = 0x00
+EDKII_IFR_DISPLAY_UINT_DEC_BIT = 0x40
+EDKII_IFR_DISPLAY_UINT_HEX_BIT = 0x80
+
+EDKII_IFR_NUMERIC_SIZE_BIT = 0x3F
+
+EFI_IFR_MAX_DEFAULT_TYPE = 0x10
+
+
+class EFI_GUID(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Data1', c_uint32),
+ ('Data2', c_uint16),
+ ('Data3', c_uint16),
+ ('Data4', c_ubyte * 8),
+ ]
+
+ def from_list(self, listformat: list) -> None:
+ self.Data1 = listformat[0]
+ self.Data2 = listformat[1]
+ self.Data3 = listformat[2]
+ for i in range(8):
+ self.Data4[i] = listformat[i + 3]
+
+ def __cmp__(self, otherguid) -> bool:
+ if not isinstance(otherguid, EFI_GUID):
+ return 'Input is not the GUID instance!'
+ rt = False
+ if self.Data1 == otherguid.Data1 and self.Data2 == otherguid.Data2 and self.Data3 == otherguid.Data3:
+ rt = True
+ for i in range(8):
+ rt = rt & (self.Data4[i] == otherguid.Data4[i])
+ return rt
+
+
+GuidArray = c_ubyte * 8
+EFI_HII_PLATFORM_SETUP_FORMSET_GUID = EFI_GUID(
+ 0x93039971, 0x8545, 0x4b04,
+ GuidArray(0xb4, 0x5e, 0x32, 0xeb, 0x83, 0x26, 0x4, 0xe))
+
+EFI_IFR_TIANO_GUID = EFI_GUID(
+ 0xf0b1735, 0x87a0, 0x4193,
+ GuidArray(0xb2, 0x66, 0x53, 0x8c, 0x38, 0xaf, 0x48, 0xce))
+
+EDKII_IFR_BIT_VARSTORE_GUID = (0x82DDD68B, 0x9163, 0x4187,
+ GuidArray(0x9B, 0x27, 0x20, 0xA8, 0xFD, 0x60,
+ 0xA7, 0x1D))
+
+EFI_IFR_FRAMEWORK_GUID = (0x31ca5d1a, 0xd511, 0x4931,
+ GuidArray(0xb7, 0x82, 0xae, 0x6b, 0x2b, 0x17, 0x8c,
+ 0xd7))
+
+class EFI_IFR_OP_HEADER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('OpCode', c_ubyte),
+ ('Length', c_ubyte, 7), #
+ ('Scope', c_ubyte, 1), #
+ ]
+
+
+class EFI_IFR_FORM_SET(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('FormSetTitle', c_uint16),
+ ('Help', c_uint16),
+ ('Flags', c_ubyte),
+ ]
+
+
+class EFI_IFR_GUID_CLASS(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('ExtendOpCode', c_ubyte),
+ ('Class', c_uint16),
+ ]
+
+
+class EFI_IFR_GUID_SUBCLASS(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('ExtendOpCode', c_ubyte),
+ ('SubClass', c_uint16),
+ ]
+
+
+class EFI_IFR_DEFAULTSTORE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DefaultName', c_uint16),
+ ('DefaultId', c_uint16),
+ ]
+
+
+class EFI_IFR_VARSTORE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('VarStoreId', c_uint16),
+ ('Size', c_uint16),
+ ('Name', c_wchar_p),
+ ]
+
+
+class EFI_IFR_VARSTORE_EFI(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('VarStoreId', c_uint16),
+ ('Attributes', c_uint32),
+ ('Size', c_uint16),
+ ('Name', c_wchar_p),
+ ]
+
+
+class EFI_IFR_GUID(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ]
+
+
+class EFI_HII_PACKAGE_HEADER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Length', c_uint32, 24),
+ ('Type', c_uint32, 8),
+ ]
+
+
+class EFI_HII_STRING_PACKAGE_HDR(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_HII_PACKAGE_HEADER),
+ ('HdrSize', c_uint32),
+ ('StringInfoOffset', c_uint32),
+ ('LanguageWindow', c_ushort * 16),
+ ('LanguageName', c_uint16),
+ ('Language', c_char * 2),
+ ]
+
+
+class EFI_IFR_VARSTORE_NAME_VALUE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('VarStoreId', c_uint16),
+ ('Guid', EFI_GUID),
+ ]
+
+
+class EFI_IFR_FORM(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('FormId', c_uint16),
+ ('FormTitle', c_uint16),
+ ]
+
+
+class EFI_IFR_GUID_BANNER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('ExtendOpCode', c_ubyte),
+ ('Title', c_uint16),
+ ('LineNumber', c_uint16),
+ ('Alignment', c_ubyte),
+ ]
+
+
+class EFI_IFR_GUID_TIMEOUT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('ExtendOpCode', c_ubyte),
+ ('TimeOut', c_uint16),
+ ]
+
+
+class EFI_IFR_GUID_LABEL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('ExtendOpCode', c_ubyte),
+ ('Number', c_uint16),
+ ]
+
+
+class EFI_IFR_RULE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('RuleId', c_ubyte),
+ ]
+
+
+class EFI_IFR_STATEMENT_HEADER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Prompt', c_uint16),
+ ('Help', c_uint16),
+ ]
+
+
+class EFI_IFR_SUBTITLE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Statement', EFI_IFR_STATEMENT_HEADER),
+ ('Flags', c_ubyte),
+ ]
+
+
+class EFI_IFR_TEXT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Statement', EFI_IFR_STATEMENT_HEADER),
+ ('TextTwo', c_uint16),
+ ]
+
+
+class EFI_IFR_IMAGE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Id', c_uint16),
+ ]
+
+
+class VarStoreInfoNode(Union):
+ _pack_ = 1
+ _fields_ = [
+ ('VarName', c_uint16),
+ ('VarOffset', c_uint16),
+ ]
+
+
+class EFI_IFR_QUESTION_HEADER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_STATEMENT_HEADER),
+ ('QuestionId', c_uint16),
+ ('VarStoreId', c_uint16),
+ ('VarStoreInfo', VarStoreInfoNode),
+ ('Flags', c_ubyte),
+ ]
+
+
+class u8Node(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('MinValue', c_ubyte),
+ ('MaxValue', c_ubyte),
+ ('Step', c_ubyte),
+ ]
+
+
+class u16Node(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('MinValue', c_uint16),
+ ('MaxValue', c_uint16),
+ ('Step', c_uint16),
+ ]
+
+
+class u32Node(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('MinValue', c_uint32),
+ ('MaxValue', c_uint32),
+ ('Step', c_uint32),
+ ]
+
+
+class u64Node(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('MinValue', c_uint64),
+ ('MaxValue', c_uint64),
+ ('Step', c_uint64),
+ ]
+
+
+class MINMAXSTEP_DATA(Union):
+ _pack_ = 1
+ _fields_ = [
+ ('u8', u8Node),
+ ('u16', u16Node),
+ ('u32', u32Node),
+ ('u64', u64Node),
+ ]
+
+
+EFI_IFR_NUMERIC_SIZE = 0x03
+EFI_IFR_NUMERIC_SIZE_1 = 0x00
+EFI_IFR_NUMERIC_SIZE_2 = 0x01
+EFI_IFR_NUMERIC_SIZE_4 = 0x02
+EFI_IFR_NUMERIC_SIZE_8 = 0x03
+
+EFI_IFR_DISPLAY = 0x30
+EFI_IFR_DISPLAY_INT_DEC = 0x00
+EFI_IFR_DISPLAY_UINT_DEC = 0x10
+EFI_IFR_DISPLAY_UINT_HEX = 0x20
+
+class EFI_IFR_ONE_OF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('Flags', c_ubyte),
+ ('data', MINMAXSTEP_DATA),
+ ]
+
+
+EFI_IFR_CHECKBOX_DEFAULT = 0x01
+EFI_IFR_CHECKBOX_DEFAULT_MFG = 0x02
+
+
+class EFI_IFR_CHECKBOX(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('Flags', c_ubyte),
+ ]
+
+
+class EFI_IFR_NUMERIC(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('Flags', c_ubyte),
+ ('Data', MINMAXSTEP_DATA),
+ ]
+
+
+class EFI_IFR_PASSWORD(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('MinSize', c_uint16),
+ ('MaxSize', c_uint16),
+ ]
+
+
+class EFI_HII_TIME(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Hour', c_ubyte),
+ ('Minute', c_ubyte),
+ ('Second', c_ubyte),
+ ]
+
+
+class EFI_HII_DATE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Year', c_uint16),
+ ('Month', c_ubyte),
+ ('Day', c_ubyte),
+ ]
+
+
+class EFI_HII_REF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('QuestionId', c_uint16),
+ ('FormId', c_uint16),
+ ('FormSetGuid', EFI_GUID),
+ ('DevicePath', c_uint16),
+ ]
+
+
+class EFI_IFR_TYPE_VALUE(Union):
+ _pack_ = 1
+ _fields_ = [
+ ('u8', c_ubyte),
+ ('u16', c_uint16),
+ ('u32', c_uint32),
+ ('u64', c_uint64),
+ ('b', c_bool),
+ ('time', EFI_HII_TIME),
+ ('date', EFI_HII_DATE),
+ ('string', c_uint16),
+ ('ref', EFI_HII_REF),
+ ]
+
+
+class EFI_IFR_ONE_OF_OPTION(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Option', c_uint16),
+ ('Flags', c_ubyte),
+ ('Type', c_ubyte),
+ ('Value', EFI_IFR_TYPE_VALUE),
+ ]
+
+def Refine_EFI_IFR_ONE_OF_OPTION(Nums):
+ class EFI_IFR_ONE_OF_OPTION(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Option', c_uint16),
+ ('Flags', c_ubyte),
+ ('Type', c_ubyte),
+ ('Value', EFI_IFR_TYPE_VALUE * Nums),
+ ]
+ return EFI_IFR_ONE_OF_OPTION
+
+
+EFI_IFR_OPTION_DEFAULT = 0x10
+EFI_IFR_OPTION_DEFAULT_MFG = 0x20
+
+
+class EFI_IFR_SUPPRESS_IF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_LOCKED(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_ACTION(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('QuestionConfig', c_uint16),
+ ]
+
+
+class EFI_IFR_REF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('FormId', c_uint16),
+ ]
+
+
+class EFI_IFR_REF2(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('FormId', c_uint16),
+ ('QuestionId', c_uint16),
+ ]
+
+
+class EFI_IFR_REF3(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('FormId', c_uint16),
+ ('QuestionId', c_uint16),
+ ('FormSetId', EFI_GUID),
+ ]
+
+
+class EFI_IFR_REF4(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('FormId', c_uint16),
+ ('QuestionId', c_uint16),
+ ('FormSetId', EFI_GUID),
+ ('DevicePath', c_uint16),
+ ]
+
+
+class EFI_IFR_REF5(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ]
+
+
+class EFI_IFR_RESET_BUTTON(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Statement', EFI_IFR_STATEMENT_HEADER),
+ ('DefaultId', c_uint16),
+ ]
+
+
+class EFI_IFR_NO_SUBMIT_IF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Error', c_uint16),
+ ]
+
+
+class EFI_IFR_INCONSISTENT_IF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Error', c_uint16),
+ ]
+
+
+class EFI_IFR_EQ_ID_VAL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('QuestionId', c_uint16),
+ ('Value', c_uint16),
+ ]
+
+
+class EFI_IFR_EQ_ID_ID(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('QuestionId1', c_uint16),
+ ('QuestionId2', c_uint16),
+ ]
+
+class EFI_IFR_EQ_ID_VAL_LIST(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('QuestionId', c_uint16),
+ ('ListLength', c_uint16),
+ ('ValueList', c_uint16), #
+ ]
+
+
+def Refine_EFI_IFR_EQ_ID_VAL_LIST(Nums):
+ class EFI_IFR_EQ_ID_VAL_LIST(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('QuestionId', c_uint16),
+ ('ListLength', c_uint16),
+ ('ValueList', c_uint16 * Nums), #
+ ]
+ return EFI_IFR_EQ_ID_VAL_LIST
+
+
+class EFI_IFR_AND(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_OR(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_NOT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_GRAY_OUT_IF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_DATE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('Flags', c_ubyte),
+ ]
+
+
+EFI_QF_DATE_YEAR_SUPPRESS = 0x01
+EFI_QF_DATE_MONTH_SUPPRESS = 0x02
+EFI_QF_DATE_DAY_SUPPRESS = 0x04
+
+EFI_QF_DATE_STORAGE = 0x30
+QF_DATE_STORAGE_NORMAL = 0x00
+QF_DATE_STORAGE_TIME = 0x10
+QF_DATE_STORAGE_WAKEUP = 0x20
+
+
+class EFI_IFR_TIME(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('Flags', c_ubyte),
+ ]
+
+
+QF_TIME_HOUR_SUPPRESS = 0x01
+QF_TIME_MINUTE_SUPPRESS = 0x02
+QF_TIME_SECOND_SUPPRESS = 0x04
+QF_TIME_STORAGE = 0x30
+QF_TIME_STORAGE_NORMAL = 0x00
+QF_TIME_STORAGE_TIME = 0x10
+QF_TIME_STORAGE_WAKEUP = 0x20
+
+
+class EFI_IFR_STRING(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('MinSize', c_ubyte),
+ ('MaxSize', c_ubyte),
+ ('Flags', c_ubyte),
+ ]
+
+
+class EFI_IFR_REFRESH(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('RefreshInterval', c_ubyte),
+ ]
+
+
+class EFI_IFR_DISABLE_IF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_TO_LOWER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_TO_UPPER(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_MAP(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_ORDERED_LIST(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Question', EFI_IFR_QUESTION_HEADER),
+ ('MaxContainers', c_ubyte),
+ ('Flags', c_ubyte),
+ ]
+
+
+EFI_IFR_UNIQUE_SET = 0x01
+EFI_IFR_NO_EMPTY_SET = 0x02
+
+
+class EFI_IFR_VARSTORE_DEVICE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DevicePath', c_uint16),
+ ]
+
+
+class EFI_IFR_VERSION(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_END(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_MATCH(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_GET(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('VarStoreId', c_uint16),
+ ('VarStoreInfo', VarStoreInfoNode), ##########
+ ('VarStoreType', c_ubyte),
+ ]
+
+
+class EFI_IFR_SET(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('VarStoreId', c_uint16),
+ ('VarStoreInfo', VarStoreInfoNode), ##########
+ ('VarStoreType', c_ubyte),
+ ]
+
+
+class EFI_IFR_READ(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_WRITE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_EQUAL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_NOT_EQUAL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_GREATER_THAN(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_GREATER_EQUAL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_LESS_EQUAL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_LESS_THAN(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_BITWISE_AND(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_BITWISE_OR(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_BITWISE_NOT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_SHIFT_LEFT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_SHIFT_RIGHT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_ADD(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_SUBTRACT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_MULTIPLY(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_DIVIDE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_MODULO(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_RULE_REF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('RuleId', c_ubyte),
+ ]
+
+
+class EFI_IFR_QUESTION_REF1(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('QuestionId', c_uint16),
+ ]
+
+
+class EFI_IFR_QUESTION_REF2(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_QUESTION_REF3(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_QUESTION_REF3_2(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DevicePath', c_uint16),
+ ]
+
+
+class EFI_IFR_QUESTION_REF3_3(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DevicePath', c_uint16),
+ ('Guid', EFI_GUID),
+ ]
+
+
+class EFI_IFR_UINT8(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Value', c_ubyte),
+ ]
+
+
+class EFI_IFR_UINT16(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Value', c_uint16),
+ ]
+
+
+class EFI_IFR_UINT32(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Value', c_uint32),
+ ]
+
+
+class EFI_IFR_UINT64(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Value', c_uint64),
+ ]
+
+
+class EFI_IFR_TRUE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_FALSE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_TO_UINT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_TO_STRING(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Format', c_ubyte),
+ ]
+
+
+class EFI_IFR_TO_BOOLEAN(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_MID(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_FIND(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Format', c_ubyte),
+ ]
+
+
+class EFI_IFR_TOKEN(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_STRING_REF1(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('StringId', c_uint16),
+ ]
+
+
+class EFI_IFR_STRING_REF2(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_CONDITIONAL(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_ZERO(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_ONE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_ONES(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_UNDEFINED(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_LENGTH(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_DUP(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_THIS(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+EFI_IFR_FLAGS_FIRST_MATCHING = 0x00
+EFI_IFR_FLAGS_FIRST_NON_MATCHING = 0x01
+
+class EFI_IFR_SPAN(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Flags', c_ubyte),
+ ]
+
+
+class EFI_IFR_VALUE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_DEFAULT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DefaultId', c_uint16),
+ ('Type', c_ubyte),
+ ('Value', EFI_IFR_TYPE_VALUE),
+ ]
+
+def Refine_EFI_IFR_DEFAULT(Nums):
+ class EFI_IFR_DEFAULT(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DefaultId', c_uint16),
+ ('Type', c_ubyte),
+ ('Value', EFI_IFR_TYPE_VALUE * Nums),
+ ]
+ return EFI_IFR_DEFAULT
+
+
+class EFI_IFR_DEFAULT_2(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('DefaultId', c_uint16),
+ ('Type', c_ubyte),
+ ]
+
+class EFI_IFR_FORM_MAP(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('FormId', c_uint16),
+ ]
+
+class EFI_IFR_FORM_MAP_METHOD(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('MethodTitle', c_uint16),
+ ('MethodIdentifier', EFI_GUID),
+ ]
+
+class EFI_IFR_CATENATE(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_SECURITY(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Permissions', EFI_GUID),
+ ]
+
+
+class EFI_IFR_MODAL_TAG(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ]
+
+
+class EFI_IFR_REFRESH_ID(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('RefreshEventGroupId', EFI_GUID),
+ ]
+
+
+class EFI_IFR_WARNING_IF(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Warning', c_uint16),
+ ('TimeOut', c_ubyte),
+ ]
+
+
+class EFI_IFR_MATCH2(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('SyntaxType', EFI_GUID),
+ ]
+
+
+EFI_IFR_FORM_OP = 0x01
+EFI_IFR_SUBTITLE_OP = 0x02
+EFI_IFR_TEXT_OP = 0x03
+EFI_IFR_IMAGE_OP = 0x04
+EFI_IFR_ONE_OF_OP = 0x05
+EFI_IFR_CHECKBOX_OP = 0x06
+EFI_IFR_NUMERIC_OP = 0x07
+EFI_IFR_PASSWORD_OP = 0x08
+EFI_IFR_ONE_OF_OPTION_OP = 0x09
+EFI_IFR_SUPPRESS_IF_OP = 0x0A
+EFI_IFR_LOCKED_OP = 0x0B
+EFI_IFR_ACTION_OP = 0x0C
+EFI_IFR_RESET_BUTTON_OP = 0x0D
+EFI_IFR_FORM_SET_OP = 0x0E
+EFI_IFR_REF_OP = 0x0F
+EFI_IFR_NO_SUBMIT_IF_OP = 0x10
+EFI_IFR_INCONSISTENT_IF_OP = 0x11
+EFI_IFR_EQ_ID_VAL_OP = 0x12
+EFI_IFR_EQ_ID_ID_OP = 0x13
+EFI_IFR_EQ_ID_VAL_LIST_OP = 0x14
+EFI_IFR_AND_OP = 0x15
+EFI_IFR_OR_OP = 0x16
+EFI_IFR_NOT_OP = 0x17
+EFI_IFR_RULE_OP = 0x18
+EFI_IFR_GRAY_OUT_IF_OP = 0x19
+EFI_IFR_DATE_OP = 0x1A
+EFI_IFR_TIME_OP = 0x1B
+EFI_IFR_STRING_OP = 0x1C
+EFI_IFR_REFRESH_OP = 0x1D
+EFI_IFR_DISABLE_IF_OP = 0x1E
+EFI_IFR_TO_LOWER_OP = 0x20
+EFI_IFR_TO_UPPER_OP = 0x21
+EFI_IFR_MAP_OP = 0x22
+EFI_IFR_ORDERED_LIST_OP = 0x23
+EFI_IFR_VARSTORE_OP = 0x24
+EFI_IFR_VARSTORE_NAME_VALUE_OP = 0x25
+EFI_IFR_VARSTORE_EFI_OP = 0x26
+EFI_IFR_VARSTORE_DEVICE_OP = 0x27
+EFI_IFR_VERSION_OP = 0x28
+EFI_IFR_END_OP = 0x29
+EFI_IFR_MATCH_OP = 0x2A
+EFI_IFR_GET_OP = 0x2B
+EFI_IFR_SET_OP = 0x2C
+EFI_IFR_READ_OP = 0x2D
+EFI_IFR_WRITE_OP = 0x2E
+EFI_IFR_EQUAL_OP = 0x2F
+EFI_IFR_NOT_EQUAL_OP = 0x30
+EFI_IFR_GREATER_THAN_OP = 0x31
+EFI_IFR_GREATER_EQUAL_OP = 0x32
+EFI_IFR_LESS_THAN_OP = 0x33
+EFI_IFR_LESS_EQUAL_OP = 0x34
+EFI_IFR_BITWISE_AND_OP = 0x35
+EFI_IFR_BITWISE_OR_OP = 0x36
+EFI_IFR_BITWISE_NOT_OP = 0x37
+EFI_IFR_SHIFT_LEFT_OP = 0x38
+EFI_IFR_SHIFT_RIGHT_OP = 0x39
+EFI_IFR_ADD_OP = 0x3A
+EFI_IFR_SUBTRACT_OP = 0x3B
+EFI_IFR_MULTIPLY_OP = 0x3C
+EFI_IFR_DIVIDE_OP = 0x3D
+EFI_IFR_MODULO_OP = 0x3E
+EFI_IFR_RULE_REF_OP = 0x3F
+EFI_IFR_QUESTION_REF1_OP = 0x40
+EFI_IFR_QUESTION_REF2_OP = 0x41
+EFI_IFR_UINT8_OP = 0x42
+EFI_IFR_UINT16_OP = 0x43
+EFI_IFR_UINT32_OP = 0x44
+EFI_IFR_UINT64_OP = 0x45
+EFI_IFR_TRUE_OP = 0x46
+EFI_IFR_FALSE_OP = 0x47
+EFI_IFR_TO_UINT_OP = 0x48
+EFI_IFR_TO_STRING_OP = 0x49
+EFI_IFR_TO_BOOLEAN_OP = 0x4A
+EFI_IFR_MID_OP = 0x4B
+EFI_IFR_FIND_OP = 0x4C
+EFI_IFR_TOKEN_OP = 0x4D
+EFI_IFR_STRING_REF1_OP = 0x4E
+EFI_IFR_STRING_REF2_OP = 0x4F
+EFI_IFR_CONDITIONAL_OP = 0x50
+EFI_IFR_QUESTION_REF3_OP = 0x51
+EFI_IFR_ZERO_OP = 0x52
+EFI_IFR_ONE_OP = 0x53
+EFI_IFR_ONES_OP = 0x54
+EFI_IFR_UNDEFINED_OP = 0x55
+EFI_IFR_LENGTH_OP = 0x56
+EFI_IFR_DUP_OP = 0x57
+EFI_IFR_THIS_OP = 0x58
+EFI_IFR_SPAN_OP = 0x59
+EFI_IFR_VALUE_OP = 0x5A
+EFI_IFR_DEFAULT_OP = 0x5B
+EFI_IFR_DEFAULTSTORE_OP = 0x5C
+EFI_IFR_FORM_MAP_OP = 0x5D
+EFI_IFR_CATENATE_OP = 0x5E
+EFI_IFR_GUID_OP = 0x5F
+EFI_IFR_SECURITY_OP = 0x60
+EFI_IFR_MODAL_TAG_OP = 0x61
+EFI_IFR_REFRESH_ID_OP = 0x62
+EFI_IFR_WARNING_IF_OP = 0x63
+EFI_IFR_MATCH2_OP = 0x64
+
+ConditionOps = [EFI_IFR_NO_SUBMIT_IF_OP, EFI_IFR_DISABLE_IF_OP, EFI_IFR_SUPPRESS_IF_OP, EFI_IFR_GRAY_OUT_IF_OP, EFI_IFR_INCONSISTENT_IF_OP]
+BasicDataTypes = ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'EFI_HII_DATE', 'EFI_HII_TIME', 'EFI_HII_REF']
+
+class EFI_IFR_GUID_OPTIONKEY(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('Header', EFI_IFR_OP_HEADER),
+ ('Guid', EFI_GUID),
+ ('ExtendOpCode', c_uint8),
+ ('QuestionId', c_uint16),
+ ('OptionValue', EFI_IFR_TYPE_VALUE),
+ ('KeyValue', c_uint16),
+ ]
+
+
+EFI_IFR_EXTEND_OP_OPTIONKEY = 0x0
+EFI_IFR_EXTEND_OP_VAREQNAME = 0x1
+
+class EFI_COMPARE_TYPE(Enum):
+ EQUAL = 0
+ LESS_EQUAL = 1
+ LESS_THAN = 2
+ GREATER_THAN = 3
+ GREATER_EQUAL = 4
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/README.md b/edk2basetools/VfrCompiler/README.md
new file mode 100644
index 0000000..39a4621
--- /dev/null
+++ b/edk2basetools/VfrCompiler/README.md
@@ -0,0 +1,20 @@
+# Python VfrCompiler Tool
+## Overview
+This python VfrCompiler tool is the implementation of the edk2 VfrCompiler tool which locates at https://github.com/tianocore/edk2/tree/master/BaseTools/Source/C/VfrCompile.
+
+### Introduction
+The core function of the original C VfrCompiler tool is to convert the vfr file into IFR binary array. However, the vfr format file syntax is relatively uncommon and has poor readability for users. What's more, the C tool does not collect and store extra information except for binary generation. When any modification is needed, developers have to read and deal with the IFR binary, which is quite inefficient. To solve this issue, this python VfrCompiler tool proposes to generate the yaml format file on the basis of the vfr format file. With the yaml file, the layout and hierarchy of all Opcodes in the vfr file will be saved. Then modification will be much eaiser. In addition, an extra json file will be generated for better variable related information presentation. So the long-term aim of this tool is to cover the same usage as the edk2 C VfrCompiler and extend the yaml/json output for better readability and variability.
+
+### Main update in this commitment
+- Update the vfr parser generator from ANTLR to ANTLR v4, which is more readable and is eaiser to add on new functions.
+- Generate a yaml file for each vfr file. The yaml file displays all the contents in the Vfr file by different Opcode types in sequence.
+- Generate a json file for each vfr file. The json file contains all the default values for different Opcode types in vfr files.
+
+### Known issues
+
+- The python VfrCompiler tool aims to cover the same usage as the edk2 C VfrCompiler. But currently, the python VfrCompiler tool does not support IFR binary generation feature, this feature will be added in future update.
+- The python VfrCompiler tool will extend new functions, which is able to compile both the vfr and yaml files. This feature will be added in future update.
+
+### Use with Build System
+- To use the VfrCompiler Python Tool with Build System, please add the ***'--vfr-yaml-enable'*** option in the build command.
+- For Example: ***build -p OvmfPkg\OvmfPkgIa32X64.dsc -a IA32 -a X64 -j build.log --vfr-yaml-enable***
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/VfrError.py b/edk2basetools/VfrCompiler/VfrError.py
new file mode 100644
index 0000000..ffe87e2
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrError.py
@@ -0,0 +1,162 @@
+import imp
+import sys
+import os
+from enum import Enum
+from Common.BuildToolError import *
+import Common.EdkLogger as EdkLogger
+
+
+class VfrReturnCode(Enum):
+ VFR_RETURN_SUCCESS = 0
+ VFR_RETURN_ERROR_SKIPED = 1
+ VFR_RETURN_FATAL_ERROR = 2
+ VFR_RETURN_MISMATCHED = 3
+ VFR_RETURN_INVALID_PARAMETER = 4
+ VFR_RETURN_OUT_FOR_RESOURCES = 5
+ VFR_RETURN_UNSUPPORTED = 6
+ VFR_RETURN_REDEFINED = 7
+ VFR_RETURN_FORMID_REDEFINED = 8
+ VFR_RETURN_QUESTIONID_REDEFINED = 9
+ VFR_RETURN_VARSTOREID_REDEFINED = 10
+ VFR_RETURN_UNDEFINED = 11
+ VFR_RETURN_VAR_NOTDEFINED_BY_QUESTION = 12
+ VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR = 13
+ VFR_RETURN_GET_EFIVARSTORE_ERROR = 14
+ VFR_RETURN_EFIVARSTORE_USE_ERROR = 15
+ VFR_RETURN_EFIVARSTORE_SIZE_ERROR = 16
+ VFR_RETURN_GET_NVVARSTORE_ERROR = 17
+ VFR_RETURN_QVAR_REUSE = 18
+ VFR_RETURN_FLAGS_UNSUPPORTED = 19
+ VFR_RETURN_ERROR_ARRARY_NUM = 20
+ VFR_RETURN_DATA_STRING_ERROR = 21
+ VFR_RETURN_DEFAULT_VALUE_REDEFINED = 22
+ VFR_RETURN_CONSTANT_ONLY = 23
+ VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR = 24
+ VFR_RETURN_BIT_WIDTH_ERROR = 25
+ VFR_RETURN_STRING_TO_UINT_OVERFLOW = 26
+ VFR_RETURN_CODEUNDEFINED = 27
+
+
+vfrErrorMessage = {
+ VfrReturnCode.VFR_RETURN_SUCCESS: '',
+ VfrReturnCode.VFR_RETURN_ERROR_SKIPED: '',
+ VfrReturnCode.VFR_RETURN_FATAL_ERROR: 'fatal error!!',
+ VfrReturnCode.VFR_RETURN_MISMATCHED: 'unexpected token',
+ VfrReturnCode.VFR_RETURN_INVALID_PARAMETER: 'invalid parameter',
+ VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES: 'system out of memory',
+ VfrReturnCode.VFR_RETURN_UNSUPPORTED: 'unsupported',
+ VfrReturnCode.VFR_RETURN_REDEFINED: 'already defined',
+ VfrReturnCode.VFR_RETURN_FORMID_REDEFINED: 'form id already defined',
+ VfrReturnCode.VFR_RETURN_QUESTIONID_REDEFINED:
+ 'question id already defined',
+ VfrReturnCode.VFR_RETURN_VARSTOREID_REDEFINED:
+ 'varstore id already defined',
+ VfrReturnCode.VFR_RETURN_UNDEFINED: 'undefined',
+ VfrReturnCode.VFR_RETURN_VAR_NOTDEFINED_BY_QUESTION:
+ 'some variable has not defined by a question',
+ VfrReturnCode.VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR:
+ 'Data Structure is defined by more than one varstores: it can\'t be referred as varstore: only varstore name could be used.',
+ VfrReturnCode.VFR_RETURN_GET_EFIVARSTORE_ERROR: 'get efi varstore error',
+ VfrReturnCode.VFR_RETURN_EFIVARSTORE_USE_ERROR:
+ 'can not use the efi varstore like this',
+ VfrReturnCode.VFR_RETURN_EFIVARSTORE_SIZE_ERROR:
+ 'unsupport efi varstore size should be <= 8 bytes',
+ VfrReturnCode.VFR_RETURN_GET_NVVARSTORE_ERROR:
+ 'get name value varstore error',
+ VfrReturnCode.VFR_RETURN_QVAR_REUSE:
+ 'variable reused by more than one question',
+ VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED: 'flags unsupported',
+ VfrReturnCode.VFR_RETURN_ERROR_ARRARY_NUM:
+ 'array number error: the valid value is in (0 ~ MAX_INDEX-1 for UEFI vfr and in (1 ~ MAX_INDEX for Framework Vfr',
+ VfrReturnCode.VFR_RETURN_DATA_STRING_ERROR:
+ 'data field string error or not support',
+ VfrReturnCode.VFR_RETURN_DEFAULT_VALUE_REDEFINED:
+ 'default value re-defined with different value',
+ VfrReturnCode.VFR_RETURN_CONSTANT_ONLY:
+ 'only constant is allowed in the expression',
+ VfrReturnCode.VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR:
+ 'Varstore name is defined by more than one varstores: it can\'t be referred as varstore: only varstore structure name could be used.',
+ VfrReturnCode.VFR_RETURN_BIT_WIDTH_ERROR:
+ 'bit width must be <= sizeof (type * 8 and the max width can not > 32',
+ VfrReturnCode.VFR_RETURN_STRING_TO_UINT_OVERFLOW:
+ 'String to UINT* Overflow',
+ VfrReturnCode.VFR_RETURN_CODEUNDEFINED: 'undefined Error Code'
+}
+
+
+class EFI_VFR_WARNING_CODE(Enum):
+ VFR_WARNING_DEFAULT_VALUE_REDEFINED = 0
+ VFR_WARNING_ACTION_WITH_TEXT_TWO = 1
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE = 2
+ VFR_WARNING_CODEUNDEFINED = 3
+
+
+vfrWarningMessage = {
+ EFI_VFR_WARNING_CODE.VFR_WARNING_DEFAULT_VALUE_REDEFINED:
+ ": default value re-defined with different value",
+ EFI_VFR_WARNING_CODE.VFR_WARNING_ACTION_WITH_TEXT_TWO:
+ ": Action opcode should not have TextTwo part",
+ EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE:
+ ": Not recommend to use obsoleted framework opcode",
+ EFI_VFR_WARNING_CODE.VFR_WARNING_CODEUNDEFINED: ": undefined Warning Code"
+}
+
+
+class CVfrErrorHandle():
+
+ def __init__(self):
+ self.__InputFileName = None
+ self.__vfrErrorMessage = vfrErrorMessage
+ self.__vfrWarningMessage = vfrWarningMessage
+ self.__WarningAsError = False
+
+ def SetWarningAsError(self, WarningAsError):
+ self.__WarningAsError = WarningAsError
+
+ def SetInputFile(self, InputFile):
+ self.__InputFileName = InputFile
+
+ def HandleWarning(self, WarningCode, LineNum, TokenValue=None):
+ if self.__vfrWarningMessage == None:
+ return 1
+ WarningMsg = ''
+ for key in self.__vfrWarningMessage.keys():
+ if WarningCode == self.__vfrWarningMessage[key]:
+ WarningMsg = self.__vfrWarningMessage[key]
+ break
+ if WarningMsg != '':
+ if self.__WarningAsError:
+ EdkLogger.error('VfrCompiler', WarningCode, WarningMsg,
+ self.__InputFileName, LineNum,
+ "warning treated as error")
+ EdkLogger.warn('VfrCompiler', WarningMsg, self.__InputFileName,
+ LineNum, TokenValue)
+
+ def PrintMsg(self,
+ LineNum,
+ MsgType='Error',
+ ErrorMsg=None,
+ TokenValue=None):
+ if MsgType == 'Warning':
+ EdkLogger.verbose(ErrorMsg)
+ else:
+ EdkLogger.error('VfrCompiler', 0x3000, ErrorMsg,
+ self.__InputFileName, LineNum, TokenValue)
+
+ def HandleError(self, ErrorCode, LineNum=None, TokenValue=None):
+ if self.__vfrErrorMessage == None:
+ return 1
+ ErrorMsg = ''
+ for key in self.__vfrErrorMessage.keys():
+ if ErrorCode == self.__vfrErrorMessage[key]:
+ ErrorMsg = self.__vfrErrorMessage[key]
+ break
+ if ErrorMsg != '':
+ EdkLogger.error('VfrCompiler', ErrorCode, ErrorMsg,
+ self.__InputFileName, LineNum, TokenValue)
+ return 1
+ else:
+ return 0
+
+
+gCVfrErrorHandle = CVfrErrorHandle()
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/VfrFormPkg.py b/edk2basetools/VfrCompiler/VfrFormPkg.py
new file mode 100644
index 0000000..96bad6f
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrFormPkg.py
@@ -0,0 +1,2738 @@
+from ast import For
+from re import L
+from sre_parse import FLAGS
+from stat import FILE_ATTRIBUTE_SPARSE_FILE
+from VfrCompiler.CommonCtypes import *
+from VfrCompiler.VfrError import VfrReturnCode
+from VfrCompiler.VfrUtility import *
+
+from ctypes import *
+
+
+class OpcodeSizesScopeNode():
+
+ def __init__(self, Size, Scope):
+ self.Size = Size
+ self.Scope = Scope
+
+
+gOpcodeSizesScopeTable = [
+ OpcodeSizesScopeNode(0, 0), # EFI_IFR_INVALID - 0x00
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FORM), 1), # EFI_IFR_FORM_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SUBTITLE),
+ 1), # EFI_IFR_SUBTITLE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TEXT), 0), # EFI_IFR_TEXT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_IMAGE), 0), # EFI_IFR_IMAGE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONE_OF),
+ 1), # EFI_IFR_ONE_OF_OP - 0x05
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_CHECKBOX),
+ 1), # EFI_IFR_CHECKBOX_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NUMERIC),
+ 1), # EFI_IFR_NUMERIC_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_PASSWORD),
+ 1), # EFI_IFR_PASSWORD_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONE_OF_OPTION),
+ 0), # EFI_IFR_ONE_OF_OPTION_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SUPPRESS_IF),
+ 1), # EFI_IFR_SUPPRESS_IF - 0x0A
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LOCKED),
+ 0), # EFI_IFR_LOCKED_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ACTION),
+ 1), # EFI_IFR_ACTION_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_RESET_BUTTON),
+ 1), # EFI_IFR_RESET_BUTTON_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FORM_SET),
+ 1), # EFI_IFR_FORM_SET_OP -0xE
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_REF), 0), # EFI_IFR_REF_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NO_SUBMIT_IF),
+ 1), # EFI_IFR_NO_SUBMIT_IF_OP -0x10
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_INCONSISTENT_IF),
+ 1), # EFI_IFR_INCONSISTENT_IF_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQ_ID_VAL),
+ 0), # EFI_IFR_EQ_ID_VAL_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQ_ID_ID),
+ 0), # EFI_IFR_EQ_ID_ID_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQ_ID_VAL_LIST),
+ 0), # EFI_IFR_EQ_ID_LIST_OP - 0x14
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_AND), 0), # EFI_IFR_AND_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_OR), 0), # EFI_IFR_OR_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NOT), 0), # EFI_IFR_NOT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_RULE), 1), # EFI_IFR_RULE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GRAY_OUT_IF),
+ 1), # EFI_IFR_GRAYOUT_IF_OP - 0x19
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DATE), 1), # EFI_IFR_DATE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TIME), 1), # EFI_IFR_TIME_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_STRING),
+ 1), # EFI_IFR_STRING_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_REFRESH),
+ 0), # EFI_IFR_REFRESH_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DISABLE_IF),
+ 1), # EFI_IFR_DISABLE_IF_OP - 0x1E
+ OpcodeSizesScopeNode(0, 0), # 0x1F
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_LOWER),
+ 0), # EFI_IFR_TO_LOWER_OP - 0x20
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_UPPER),
+ 0), # EFI_IFR_TO_UPPER_OP - 0x21
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MAP), 1), # EFI_IFR_MAP - 0x22
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ORDERED_LIST),
+ 1), # EFI_IFR_ORDERED_LIST_OP - 0x23
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE),
+ 0), # EFI_IFR_VARSTORE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE_NAME_VALUE),
+ 0), # EFI_IFR_VARSTORE_NAME_VALUE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE_EFI),
+ 0), # EFI_IFR_VARSTORE_EFI_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VARSTORE_DEVICE),
+ 1), # EFI_IFR_VARSTORE_DEVICE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VERSION),
+ 0), # EFI_IFR_VERSION_OP - 0x28
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_END), 0), # EFI_IFR_END_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MATCH),
+ 0), # EFI_IFR_MATCH_OP - 0x2A
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GET), 0), # EFI_IFR_GET - 0x2B
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SET), 0), # EFI_IFR_SET - 0x2C
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_READ),
+ 0), # EFI_IFR_READ - 0x2D
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_WRITE),
+ 0), # EFI_IFR_WRITE - 0x2E
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_EQUAL),
+ 0), # EFI_IFR_EQUAL_OP - 0x2F
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_NOT_EQUAL),
+ 0), # EFI_IFR_NOT_EQUAL_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GREATER_THAN),
+ 0), # EFI_IFR_GREATER_THAN_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GREATER_EQUAL),
+ 0), # EFI_IFR_GREATER_EQUAL_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LESS_THAN),
+ 0), # EFI_IFR_LESS_THAN_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LESS_EQUAL),
+ 0), # EFI_IFR_LESS_EQUAL_OP - 0x34
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_BITWISE_AND),
+ 0), # EFI_IFR_BITWISE_AND_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_BITWISE_OR),
+ 0), # EFI_IFR_BITWISE_OR_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_BITWISE_NOT),
+ 0), # EFI_IFR_BITWISE_NOT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SHIFT_LEFT),
+ 0), # EFI_IFR_SHIFT_LEFT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SHIFT_RIGHT),
+ 0), # EFI_IFR_SHIFT_RIGHT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ADD),
+ 0), # EFI_IFR_ADD_OP - 0x3A
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SUBTRACT),
+ 0), # EFI_IFR_SUBTRACT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MULTIPLY),
+ 0), # EFI_IFR_MULTIPLY_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DIVIDE),
+ 0), # EFI_IFR_DIVIDE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MODULO),
+ 0), # EFI_IFR_MODULO_OP - 0x3E
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_RULE_REF),
+ 0), # EFI_IFR_RULE_REF_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_QUESTION_REF1),
+ 0), # EFI_IFR_QUESTION_REF1_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_QUESTION_REF2),
+ 0), # EFI_IFR_QUESTION_REF2_OP - 0x41
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT8), 0), # EFI_IFR_UINT8
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT16), 0), # EFI_IFR_UINT16
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT32), 0), # EFI_IFR_UINT32
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UINT64), 0), # EFI_IFR_UTNT64
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TRUE),
+ 0), # EFI_IFR_TRUE_OP - 0x46
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FALSE), 0), # EFI_IFR_FALSE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_UINT),
+ 0), # EFI_IFR_TO_UINT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_STRING),
+ 0), # EFI_IFR_TO_STRING_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TO_BOOLEAN),
+ 0), # EFI_IFR_TO_BOOLEAN_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MID), 0), # EFI_IFR_MID_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FIND), 0), # EFI_IFR_FIND_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_TOKEN), 0), # EFI_IFR_TOKEN_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_STRING_REF1),
+ 0), # EFI_IFR_STRING_REF1_OP - 0x4E
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_STRING_REF2),
+ 0), # EFI_IFR_STRING_REF2_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_CONDITIONAL),
+ 0), # EFI_IFR_CONDITIONAL_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_QUESTION_REF3),
+ 0), # EFI_IFR_QUESTION_REF3_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ZERO), 0), # EFI_IFR_ZERO_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONE), 0), # EFI_IFR_ONE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_ONES), 0), # EFI_IFR_ONES_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_UNDEFINED),
+ 0), # EFI_IFR_UNDEFINED_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_LENGTH),
+ 0), # EFI_IFR_LENGTH_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DUP),
+ 0), # EFI_IFR_DUP_OP - 0x57
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_THIS), 0), # EFI_IFR_THIS_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SPAN), 0), # EFI_IFR_SPAN_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_VALUE), 1), # EFI_IFR_VALUE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DEFAULT),
+ 0), # EFI_IFR_DEFAULT_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_DEFAULTSTORE),
+ 0), # EFI_IFR_DEFAULTSTORE_OP - 0x5C
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_FORM_MAP),
+ 1), # EFI_IFR_FORM_MAP_OP - 0x5D
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_CATENATE),
+ 0), # EFI_IFR_CATENATE_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_GUID), 0), # EFI_IFR_GUID_OP
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_SECURITY),
+ 0), # EFI_IFR_SECURITY_OP - 0x60
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MODAL_TAG),
+ 0), # EFI_IFR_MODAL_TAG_OP - 0x61
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_REFRESH_ID),
+ 0), # EFI_IFR_REFRESH_ID_OP - 0x62
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_WARNING_IF),
+ 1), # EFI_IFR_WARNING_IF_OP - 0x63
+ OpcodeSizesScopeNode(ctypes.sizeof(EFI_IFR_MATCH2), 0)
+]
+
+
+class SBufferNode():
+
+ def __init__(self, Buffer='', Next=None):
+ self.Buffer = Buffer
+ self.Next = Next
+
+
+class CFormPkg():
+
+ def __init__(self, BufferSize=4096):
+
+ Node = SBufferNode()
+ self.__BufferNodeQueueHead = Node
+ self.__BufferNodeQueueTail = Node
+ self.__CurrBufferNode = Node
+ self.__ReadBufferNode = None
+ self.__ReadBufferOffset = 0
+ self.__PkgLength = 0
+ self.__PendingAssignList = None
+ self.__BufferSize = BufferSize
+
+ def GetPkgLength(self):
+ return self.__PkgLength
+
+ def __createNewNode(self):
+ Node = SBufferNode()
+ return Node
+
+ def __GetNodeBefore(self, CurrentNode):
+ FirstNode = self.__BufferNodeQueueHead
+ LastNode = self.__BufferNodeQueueHead
+ while FirstNode != None:
+ if FirstNode == CurrentNode:
+ break
+
+ LastNode = FirstNode
+ FirstNode = FirstNode.Next
+
+ if FirstNode == None:
+ LastNode = None
+
+ return LastNode
+
+ def __InsertNodeBefore(self, CurrentNode, NewNode):
+ LastNode = self.__GetNodeBefore(CurrentNode)
+ if LastNode == None:
+ return VfrReturnCode.VFR_RETURN_MISMATCHED
+
+ NewNode.Next = LastNode.Next
+ LastNode.Next = NewNode
+
+ def IfrBinBufferGet(self, Len):
+ if Len == 0 or Len > self.__BufferSize:
+ return None
+ if len(self.__CurrBufferNode.Buffer) + Len > self.__BufferSize:
+ Node = self.__createNewNode()
+ if Node == None:
+ return None
+
+ if self.__BufferNodeQueueTail == None:
+ self.__BufferNodeQueueHead = self.__BufferNodeQueueTail = Node
+ else:
+ self.__BufferNodeQueueTail.Next = Node
+ mBufferNodeQueueTail = Node
+ self.__CurrBufferNode = Node
+
+ self.__PkgLength += Len
+
+ return self.__CurrBufferNode.Buffer
+
+
+
+gCFormPkg = CFormPkg()
+gCreateOp = True
+
+gIfrObjPrintDebugTable = [
+ "EFI_IFR_INVALID",
+ "EFI_IFR_FORM",
+ "EFI_IFR_SUBTITLE",
+ "EFI_IFR_TEXT",
+ "EFI_IFR_IMAGE",
+ "EFI_IFR_ONE_OF",
+ "EFI_IFR_CHECKBOX",
+ "EFI_IFR_NUMERIC",
+ "EFI_IFR_PASSWORD",
+ "EFI_IFR_ONE_OF_OPTION",
+ "EFI_IFR_SUPPRESS_IF",
+ "EFI_IFR_LOCKED",
+ "EFI_IFR_ACTION",
+ "EFI_IFR_RESET_BUTTON",
+ "EFI_IFR_FORM_SET",
+ "EFI_IFR_REF",
+ "EFI_IFR_NO_SUBMIT_IF",
+ "EFI_IFR_INCONSISTENT_IF",
+ "EFI_IFR_EQ_ID_VAL",
+ "EFI_IFR_EQ_ID_ID",
+ "EFI_IFR_EQ_ID_LIST",
+ "EFI_IFR_AND",
+ "EFI_IFR_OR",
+ "EFI_IFR_NOT",
+ "EFI_IFR_RULE",
+ "EFI_IFR_GRAY_OUT_IF",
+ "EFI_IFR_DATE",
+ "EFI_IFR_TIME",
+ "EFI_IFR_STRING",
+ "EFI_IFR_REFRESH",
+ "EFI_IFR_DISABLE_IF",
+ "EFI_IFR_INVALID",
+ "EFI_IFR_TO_LOWER",
+ "EFI_IFR_TO_UPPER",
+ "EFI_IFR_MAP",
+ "EFI_IFR_ORDERED_LIST",
+ "EFI_IFR_VARSTORE",
+ "EFI_IFR_VARSTORE_NAME_VALUE",
+ "EFI_IFR_VARSTORE_EFI",
+ "EFI_IFR_VARSTORE_DEVICE",
+ "EFI_IFR_VERSION",
+ "EFI_IFR_END",
+ "EFI_IFR_MATCH",
+ "EFI_IFR_GET",
+ "EFI_IFR_SET",
+ "EFI_IFR_READ",
+ "EFI_IFR_WRITE",
+ "EFI_IFR_EQUAL",
+ "EFI_IFR_NOT_EQUAL",
+ "EFI_IFR_GREATER_THAN",
+ "EFI_IFR_GREATER_EQUAL",
+ "EFI_IFR_LESS_THAN",
+ "EFI_IFR_LESS_EQUAL",
+ "EFI_IFR_BITWISE_AND",
+ "EFI_IFR_BITWISE_OR",
+ "EFI_IFR_BITWISE_NOT",
+ "EFI_IFR_SHIFT_LEFT",
+ "EFI_IFR_SHIFT_RIGHT",
+ "EFI_IFR_ADD",
+ "EFI_IFR_SUBTRACT",
+ "EFI_IFR_MULTIPLY",
+ "EFI_IFR_DIVIDE",
+ "EFI_IFR_MODULO",
+ "EFI_IFR_RULE_REF",
+ "EFI_IFR_QUESTION_REF1",
+ "EFI_IFR_QUESTION_REF2",
+ "EFI_IFR_UINT8",
+ "EFI_IFR_UINT16",
+ "EFI_IFR_UINT32",
+ "EFI_IFR_UINT64",
+ "EFI_IFR_TRUE",
+ "EFI_IFR_FALSE",
+ "EFI_IFR_TO_UINT",
+ "EFI_IFR_TO_STRING",
+ "EFI_IFR_TO_BOOLEAN",
+ "EFI_IFR_MID",
+ "EFI_IFR_FIND",
+ "EFI_IFR_TOKEN",
+ "EFI_IFR_STRING_REF1",
+ "EFI_IFR_STRING_REF2",
+ "EFI_IFR_CONDITIONAL",
+ "EFI_IFR_QUESTION_REF3",
+ "EFI_IFR_ZERO",
+ "EFI_IFR_ONE",
+ "EFI_IFR_ONES",
+ "EFI_IFR_UNDEFINED",
+ "EFI_IFR_LENGTH",
+ "EFI_IFR_DUP",
+ "EFI_IFR_THIS",
+ "EFI_IFR_SPAN",
+ "EFI_IFR_VALUE",
+ "EFI_IFR_DEFAULT",
+ "EFI_IFR_DEFAULTSTORE",
+ "EFI_IFR_FORM_MAP",
+ "EFI_IFR_CATENATE",
+ "EFI_IFR_GUID",
+ "EFI_IFR_SECURITY",
+ "EFI_IFR_MODAL_TAG",
+ "EFI_IFR_REFRESH_ID",
+ "EFI_IFR_WARNING_IF",
+ "EFI_IFR_MATCH2",
+]
+
+
+class CIfrObj():
+
+ def __init__(self, Obj=None, OpCode=None, ObjBinLen=0, DelayEmit=False, LineNo=0):
+
+ self.__DelayEmit = DelayEmit
+ self.__PkgOffset = gCFormPkg.GetPkgLength()
+ self.__ObjBinLen = gOpcodeSizesScopeTable[
+ OpCode].Size if ObjBinLen == 0 else ObjBinLen
+
+ self.__ObjBinBuf = Obj
+ self.__LineNo = LineNo
+
+ # print ("======Create IFR [%s]\n", gIfrObjPrintDebugTable[OpCode])
+ return self.__ObjBinBuf
+
+ def SetObjBin(self, ObjBinLen):
+
+ self.__ObjBinLen = ObjBinLen
+ if self.__DelayEmit == False and gCreateOp == True:
+ self.__ObjBinBuf = gCFormPkg.IfrBinBufferGet(self.__ObjBinLen)
+
+ def SetLineNo(self, LineNo):
+ self.__LineNo = LineNo
+
+ def GetObjBinAddr(self, Addr):
+ self.__ObjBinBuf = Addr
+ return self.__ObjBinBuf
+
+ def GetObjBinOffset(self):
+ return self.__PkgOffset
+
+ def GetObjBinLen(self):
+ return self.__ObjBinLen
+
+ def ExpendObjBin(self, Size):
+ if (self.__DelayEmit) == True and (
+ (self.__ObjBinLen + Size) > self.__ObjBinLen):
+ self.__ObjBinLen = self.__ObjBinLen + Size
+ return True
+ else:
+ return False
+
+ def ShrinkObjBin(self, Size):
+ if (self.__DelayEmit) == True and (self.__ObjBinLen > Size):
+ self.__ObjBinLen = self.__ObjBinLen - Size
+
+ def GetObjBin(self):
+ return self.__ObjBinBuf
+
+ def EMIT_PENDING_OBJ(self):
+ if self.__DelayEmit == False or gCreateOp == False:
+ return
+
+ self.__PkgOffset = gCFormPkg.GetPkgLength()
+ # update data buffer to package data
+ self.__ObjBinBuf = gCFormPkg.IfrBinBufferGet(self.__ObjBinLen)
+
+ self.__DelayEmit = False
+
+
+gScopeCount = 0
+gIsOrderedList = False
+gIsStringOp = False
+gCurrentQuestion = None
+gCurrentMinMaxData = None
+
+
+def SetCurrentQuestion(Question):
+
+ gCurrentQuestion = Question
+ return gCurrentQuestion
+
+
+class CIfrOpHeader():
+
+ def __init__(self, OpHeader: EFI_IFR_OP_HEADER, OpCode=None, Length=0):
+ self.__OpHeader = OpHeader
+ if OpCode != None:
+ self.__OpHeader.OpCode = OpCode
+
+ self.__OpHeader.Length = gOpcodeSizesScopeTable[
+ OpCode].Size if Length == 0 else Length
+ self.__OpHeader.Scope = 1 if (
+ gOpcodeSizesScopeTable[OpCode].Scope + gScopeCount > 0) else 0
+
+ def GetLength(self):
+ return self.__OpHeader.Length
+
+ def SetScope(self, Scope):
+ self.__OpHeader.Scope = Scope
+
+ def GetScope(self):
+ return self.__OpHeader.Scope
+
+ def UpdateHeader(self, Header):
+ self.__OpHeader = Header
+
+ def IncLength(self, Size):
+ self.__OpHeader.Length += Size
+
+ def DecLength(self, Size):
+ self.__OpHeader.Length -= Size
+
+ def GetOpCode(self):
+ return self.__OpHeader.OpCode
+
+
+class CIfrStatementHeader():
+
+ def __init__(self, sHeader: EFI_IFR_STATEMENT_HEADER):
+ self.__sHeader = sHeader
+ self.__sHeader.Help = EFI_STRING_ID_INVALID
+ self.__sHeader.Prompt = EFI_STRING_ID_INVALID
+
+ def GetStatementHeader(self):
+ return self.__sHeader
+
+ def SetPrompt(self, Prompt):
+ self.__sHeader.Prompt = Prompt
+
+ def SetHelp(self, Help):
+ self.__sHeader.Help = Help
+
+
+class CIfrMinMaxStepData():
+
+ def __init__(self, MinMaxStepData, NumericOpcode=False):
+ self.__MinMaxStepData = MinMaxStepData
+ self.__MinMaxStepData.u64.MinValue = 0
+ self.__MinMaxStepData.u64.MaxValue = 0
+ self.__MinMaxStepData.u64.Step = 0
+ self.__ValueIsSet = False
+ self.__IsNumeric = NumericOpcode
+ self.__VarType = EFI_IFR_TYPE_NUM_SIZE_64
+
+ def SetMinMaxStepData(self, MinValue, MaxValue, Step, VarType):
+ self.__VarType = VarType
+
+ if self.__ValueIsSet == False:
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_64:
+ self.__MinMaxStepData.u64.MinValue = MinValue
+ self.__MinMaxStepData.u64.MaxValue = MaxValue
+ self.__MinMaxStepData.u64.Step = Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_32:
+ self.__MinMaxStepData.u32.MinValue = MinValue
+ self.__MinMaxStepData.u32.MaxValue = MaxValue
+ self.__MinMaxStepData.u32.Step = Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_16:
+ self.__MinMaxStepData.u16.MinValue = MinValue
+ self.__MinMaxStepData.u16.MaxValue = MaxValue
+ self.__MinMaxStepData.u16.Step = Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_8:
+ self.__MinMaxStepData.u8.MinValue = MinValue
+ self.__MinMaxStepData.u8.MaxValue = MaxValue
+ self.__MinMaxStepData.u8.Step = Step
+ self.__ValueIsSet = True
+ else:
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_64:
+ if MinValue < self.__MinMaxStepData.u64.MinValue:
+ self.__MinMaxStepData.u64.MinValue = MinValue
+ if MaxValue > self.__MinMaxStepData.u64.MaxValue:
+ self.__MinMaxStepData.u64.MaxValue = MaxValue
+ self.__MinMaxStepData.u64.Step = Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_32:
+ if MinValue < self.__MinMaxStepData.u32.MinValue:
+ self.__MinMaxStepData.u32.MinValue = MinValue
+ if MaxValue > self.__MinMaxStepData.u32.MaxValue:
+ self.__MinMaxStepData.u32.MaxValue = MaxValue
+ self.__MinMaxStepData.u32.Step = Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_16:
+ if MinValue < self.__MinMaxStepData.u16.MinValue:
+ self.__MinMaxStepData.u16.MinValue = MinValue
+ if MaxValue > self.__MinMaxStepData.u16.MaxValue:
+ self.__MinMaxStepData.u16.MaxValue = MaxValue
+ self.__MinMaxStepData.u16.Step = Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_8:
+ if MinValue < self.__MinMaxStepData.u8.MinValue:
+ self.__MinMaxStepData.u8.MinValue = MinValue
+ if MaxValue > self.__MinMaxStepData.u8.MaxValue:
+ self.__MinMaxStepData.u8.MaxValue = MaxValue
+ self.__MinMaxStepData.u8.Step = Step
+
+ def GetVarType(self):
+ return self.__VarType
+
+ def IsNumericOpcode(self):
+ return self.__IsNumeric
+
+ def UpdateCIfrMinMaxStepData(self, MinMaxStepData):
+ self.__MinMaxStepData = MinMaxStepData
+
+ def GetMinData(self, VarType, IsBitVar):
+
+ if IsBitVar:
+ return self.__MinMaxStepData.u32.MinValue
+
+ else:
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_64:
+ return self.__MinMaxStepData.u64.MinValue
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_32:
+ return self.__MinMaxStepData.u32.MinValue
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_16:
+ return self.__MinMaxStepData.u16.MinValue
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_8:
+ return self.__MinMaxStepData.u8.MinValue
+
+ return 0
+
+ def GetMaxData(self, VarType, IsBitVar):
+
+ if IsBitVar:
+ return self.__MinMaxStepData.u32.MaxValue
+
+ else:
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_64:
+ return self.__MinMaxStepData.u64.MaxValue
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_32:
+ return self.__MinMaxStepData.u32.MaxValue
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_16:
+ return self.__MinMaxStepData.u16.MaxValue
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_8:
+ return self.__MinMaxStepData.u8.MaxValue
+
+ return 0
+
+ def GetStepData(self, VarType, IsBitVar):
+
+ if IsBitVar:
+ return self.__MinMaxStepData.u32.Step
+
+ else:
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_64:
+ return self.__MinMaxStepData.u64.Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_32:
+ return self.__MinMaxStepData.u32.Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_16:
+ return self.__MinMaxStepData.u16.Step
+ if VarType == EFI_IFR_TYPE_NUM_SIZE_8:
+ return self.__MinMaxStepData.u8.Step
+
+ return 0
+
+
+class CIfrFormSet(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, Size):
+ self.__FormSet = EFI_IFR_FORM_SET()
+ CIfrObj.__init__(self, self.__FormSet, EFI_IFR_FORM_SET_OP)
+ CIfrOpHeader.__init__(self, self.__FormSet.Header, EFI_IFR_FORM_SET_OP,
+ Size)
+ self.__FormSet.Help = EFI_STRING_ID_INVALID
+ self.__FormSet.FormSetTitle = EFI_STRING_ID_INVALID
+ self.__FormSet.Flags = 0
+ self.__FormSet.Guid = EFI_GUID(0, 0, 0,
+ GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+ self.__ClassGuid = []
+
+ def SetGuid(self, Guid):
+ self.__FormSet.Guid = Guid
+
+ def GetGuid(self):
+ return self.__FormSet.Guid
+
+ def SetFormSetTitle(self, FormSetTitle):
+ self.__FormSet.FormSetTitle = FormSetTitle
+
+ def GetFormSetTitle(self):
+ return self.__FormSet.FormSetTitle
+
+ def SetHelp(self, Help):
+ self.__FormSet.Help = Help
+
+ def GetHelp(self):
+ return self.__FormSet.Help
+
+ def SetClassGuid(self, Guid):
+ self.__ClassGuid.append(Guid)
+ self.__FormSet.Flags += 1
+
+ def GetClassGuid(self):
+ return self.__ClassGuid
+
+ def GetFlags(self):
+ return self.__FormSet.Flags
+
+ def GetInfo(self):
+ return self.__FormSet
+
+
+class CIfrOneOfOption(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, Size):
+ self.__OneOfOption = EFI_IFR_ONE_OF_OPTION()
+ CIfrOpHeader.__init__(self, self.__OneOfOption.Header,
+ EFI_IFR_ONE_OF_OPTION_OP, Size)
+ self.__OneOfOption.Flags = 0
+ self.__OneOfOption.Option = EFI_STRING_ID_INVALID
+ self.__OneOfOption.Type = EFI_IFR_TYPE_OTHER
+ self.__OneOfOption.Value = EFI_IFR_TYPE_VALUE()
+
+ def SetOption(self, Option):
+ self.__OneOfOption.Option = Option
+
+ def SetType(self, Type):
+ self.__OneOfOption.Type = Type
+
+ def SetValue(self, Value):
+ self.__OneOfOption.Value = Value
+
+ def GetFlags(self):
+ return self.__OneOfOption.Flags
+
+ def SetFlags(self, LFlags):
+
+ self.__OneOfOption.Flags = 0
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT)
+ if Ret:
+ self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT_MFG)
+ if Ret:
+ self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT_MFG
+
+ if LFlags == EFI_IFR_TYPE_NUM_SIZE_8:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_8)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_8
+
+ elif LFlags == EFI_IFR_TYPE_NUM_SIZE_16:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_16)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_16
+
+ elif LFlags == EFI_IFR_TYPE_NUM_SIZE_32:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_32)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_32
+
+ elif LFlags == EFI_IFR_TYPE_NUM_SIZE_64:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_64)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_64
+
+ elif LFlags == EFI_IFR_TYPE_BOOLEAN:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_BOOLEAN)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_BOOLEAN
+
+ elif LFlags == EFI_IFR_TYPE_TIME:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_TIME)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_TIME
+
+ elif LFlags == EFI_IFR_TYPE_DATE:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_DATE)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_DATE
+
+ elif LFlags == EFI_IFR_TYPE_STRING:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_STRING)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_STRING
+
+ elif LFlags == EFI_IFR_TYPE_OTHER:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_OTHER)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_OTHER
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__OneOfOption
+
+
+class CIfrOneOfOption2(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, Size, Nums, ValueType, ValueList=[]):
+ self.__OneOfOption = Refine_EFI_IFR_ONE_OF_OPTION(Nums)
+ Header = EFI_IFR_OP_HEADER()
+ CIfrOpHeader.__init__(self, Header, EFI_IFR_ONE_OF_OPTION_OP, Size)
+ self.__OneOfOption.Header = Header
+ self.__OneOfOption.Flags = 0
+ self.__OneOfOption.Option = EFI_STRING_ID_INVALID
+ self.__OneOfOption.Type = EFI_IFR_TYPE_OTHER
+ self.__ValueType = ValueType
+ if ValueList != []:
+ ArrayType = EFI_IFR_TYPE_VALUE * Nums
+ ValueArray = ArrayType()
+ for i in range(0, len(ValueList)):
+ ValueArray[i] = ValueList[i]
+ self.__OneOfOption.Value = ValueArray
+
+ def SetOption(self, Option):
+ self.__OneOfOption.Option = Option
+
+ def SetType(self, Type):
+ self.__OneOfOption.Type = Type
+
+ def GetValueType(self):
+ return self.__ValueType
+
+ def SetValue(self, ValueList):
+ ArrayType = EFI_IFR_TYPE_VALUE * (len(ValueList))
+ ValueArray = ArrayType()
+ for i in range(0, len(ValueList)):
+ ValueArray[i] = ValueList[i]
+ self.__OneOfOption.Value = ValueArray
+
+ def GetFlags(self):
+ return self.__OneOfOption.Flags
+
+ def SetFlags(self, LFlags):
+
+ self.__OneOfOption.Flags = 0
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT)
+ if Ret:
+ self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_OPTION_DEFAULT_MFG)
+ if Ret:
+ self.__OneOfOption.Flags |= EFI_IFR_OPTION_DEFAULT_MFG
+
+ if LFlags == EFI_IFR_TYPE_NUM_SIZE_8:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_8)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_8
+
+ elif LFlags == EFI_IFR_TYPE_NUM_SIZE_16:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_16)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_16
+
+ elif LFlags == EFI_IFR_TYPE_NUM_SIZE_32:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_32)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_32
+
+ elif LFlags == EFI_IFR_TYPE_NUM_SIZE_64:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_NUM_SIZE_64)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_NUM_SIZE_64
+
+ elif LFlags == EFI_IFR_TYPE_BOOLEAN:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_BOOLEAN)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_BOOLEAN
+
+ elif LFlags == EFI_IFR_TYPE_TIME:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_TIME)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_TIME
+
+ elif LFlags == EFI_IFR_TYPE_DATE:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_DATE)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_DATE
+
+ elif LFlags == EFI_IFR_TYPE_STRING:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_STRING)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_STRING
+
+ elif LFlags == EFI_IFR_TYPE_OTHER:
+ LFlags = _FLAG_CLEAR(LFlags, EFI_IFR_TYPE_OTHER)
+ self.__OneOfOption.Flags |= EFI_IFR_TYPE_OTHER
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__OneOfOption
+
+
+class CIfrOptionKey(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, QuestionId, OptionValue, KeyValue):
+
+ self.__OptionKey = EFI_IFR_GUID_OPTIONKEY()
+ CIfrOpHeader.__init__(self, self.__OptionKey.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID_OPTIONKEY))
+ self.__OptionKey.ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY
+ self.__OptionKey.Guid = EFI_IFR_FRAMEWORK_GUID
+ self.__OptionKey.QuestionId = QuestionId
+ self.__OptionKey.OptionValue = OptionValue
+ self.__OptionKey.KeyValue = KeyValue
+
+ def GetInfo(self):
+ return self.__OptionKey
+
+
+class CIfrClass(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Class = EFI_IFR_GUID_CLASS() # static guid
+ CIfrOpHeader.__init__(self, self.__Class.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID_CLASS))
+ self.__Class.ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS
+ self.__Class.Guid = EFI_IFR_TIANO_GUID
+ self.__Class.Class = EFI_NON_DEVICE_CLASS
+
+ def SetClass(self, Class):
+ self.__Class.Class = Class
+
+ def GetInfo(self):
+ return self.__Class
+
+
+class CIfrSubClass(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__SubClass = EFI_IFR_GUID_SUBCLASS() # static guid
+ CIfrOpHeader.__init__(self, self.__SubClass.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID_SUBCLASS))
+ self.__SubClass.ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS
+ self.__SubClass.Guid = EFI_IFR_TIANO_GUID
+ self.__SubClass.SubClass = EFI_SETUP_APPLICATION_SUBCLASS
+
+ def SetSubClass(self, SubClass):
+ self.__SubClass.SubClass = SubClass
+
+ def GetInfo(self):
+ return self.__SubClass
+
+
+class CIfrDefaultStore(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__DefaultStore = EFI_IFR_DEFAULTSTORE()
+ CIfrOpHeader.__init__(self, self.__DefaultStore.Header,
+ EFI_IFR_DEFAULTSTORE_OP)
+ self.__DefaultStore.DefaultName = EFI_STRING_ID_INVALID
+ self.__DefaultStore.DefaultId = EFI_VARSTORE_ID_INVALID
+
+ def SetDefaultName(self, DefaultName):
+ self.__DefaultStore.DefaultName = DefaultName
+
+ def SetDefaultId(self, DefaultId):
+ self.__DefaultStore.DefaultId = DefaultId
+
+ def GetDefaultStore(self):
+ return self.__DefaultStore
+
+ def SetDefaultStore(self, DefaultStore: EFI_IFR_DEFAULTSTORE):
+ self.__DefaultStore = DefaultStore
+
+ def GetInfo(self):
+ return self.__DefaultStore
+
+
+class CIfrVarStore(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Varstore = EFI_IFR_VARSTORE()
+ CIfrOpHeader.__init__(self, self.__Varstore.Header,
+ EFI_IFR_VARSTORE_OP)
+ self.__Varstore.VarStoreId = EFI_VARSTORE_ID_INVALID
+ self.__Varstore.Size = 0
+ self.__Varstore.Name = ''
+
+ def SetGuid(self, Guid):
+ self.__Varstore.Guid = Guid
+
+ def SetSize(self, Size):
+ self.__Varstore.Size = Size
+
+ def SetVarStoreId(self, VarStoreId):
+ self.__Varstore.VarStoreId = VarStoreId
+
+ def SetName(self, Name):
+ self.__Varstore.Name = Name
+
+ def GetInfo(self):
+ return self.__Varstore
+
+
+class CIfrVarStoreEfi(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__VarStoreEfi = EFI_IFR_VARSTORE_EFI()
+ CIfrOpHeader.__init__(self, self.__VarStoreEfi.Header,
+ EFI_IFR_VARSTORE_EFI_OP)
+ self.__VarStoreEfi.VarStoreId = EFI_VAROFFSET_INVALID
+ self.__VarStoreEfi.Size = 0
+ self.__VarStoreEfi.Name = ''
+
+ def SetGuid(self, Guid):
+ self.__VarStoreEfi.Guid = Guid
+
+ def SetSize(self, Size):
+ self.__VarStoreEfi.Size = Size
+
+ def SetVarStoreId(self, VarStoreId):
+ self.__VarStoreEfi.VarStoreId = VarStoreId
+
+ def SetName(self, Name):
+ self.__VarStoreEfi.Name = Name
+
+ def SetAttributes(self, Attributes):
+ self.__VarStoreEfi.Attributes = Attributes
+
+ def GetInfo(self):
+ return self.__VarStoreEfi
+
+
+class CIfrVarStoreNameValue(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__VarStoreNameValue = EFI_IFR_VARSTORE_NAME_VALUE()
+ CIfrOpHeader.__init__(self, self.__VarStoreNameValue.Header,
+ EFI_IFR_VARSTORE_NAME_VALUE_OP)
+ self.__VarStoreNameValue.VarStoreId = EFI_VAROFFSET_INVALID
+
+ def SetGuid(self, Guid):
+ self.__VarStoreNameValue.Guid = Guid
+
+ def SetVarStoreId(self, VarStoreId):
+ self.__VarStoreNameValue.VarStoreId = VarStoreId
+
+ def GetInfo(self):
+ return self.__VarStoreNameValue
+
+
+EFI_BITS_PER_UINT32 = 1 << EFI_BITS_SHIFT_PER_UINT32
+EFI_FORM_ID_MAX = 0xFFFF
+
+EFI_FREE_FORM_ID_BITMAP_SIZE = int((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
+
+
+class CIfrFormId():
+
+ FormIdBitMap = []
+ for i in range(0, EFI_FREE_FORM_ID_BITMAP_SIZE):
+ FormIdBitMap.append(0)
+
+ @classmethod
+ def CheckFormIdFree(cls, FormId):
+
+ Index = int(FormId / EFI_BITS_PER_UINT32)
+ Offset = FormId % EFI_BITS_PER_UINT32
+
+ return (cls.FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0
+
+ @classmethod
+ def MarkFormIdUsed(cls, FormId):
+
+ Index = int(FormId / EFI_BITS_PER_UINT32)
+ Offset = FormId % EFI_BITS_PER_UINT32
+ cls.FormIdBitMap[Index] |= (0x80000000 >> Offset)
+
+
+class CIfrForm(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__Form = EFI_IFR_FORM()
+ CIfrOpHeader.__init__(self, self.__Form.Header, EFI_IFR_FORM_OP)
+ self.__Form.FormId = 0
+ self.__Form.FormTitle = EFI_STRING_ID_INVALID
+
+ def SetFormId(self, FormId):
+ # FormId can't be 0.
+ if FormId == 0:
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+ if CIfrFormId.CheckFormIdFree(FormId) == False:
+ return VfrReturnCode.VFR_RETURN_FORMID_REDEFINED
+ self.__Form.FormId = FormId
+ CIfrFormId.MarkFormIdUsed(FormId)
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def SetFormTitle(self, FormTitle):
+ self.__Form.FormTitle = FormTitle
+
+ def GetInfo(self):
+ return self.__Form
+
+
+class CIfrFormMap(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__FormMap = EFI_IFR_FORM_MAP()
+ self.__MethodMapList = [] # EFI_IFR_FORM_MAP_METHOD()
+ CIfrOpHeader.__init__(self, self.__FormMap.Header, EFI_IFR_FORM_MAP_OP)
+ self.__FormMap.FormId = 0
+
+ def SetFormId(self, FormId):
+ if FormId == 0:
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+
+ if CIfrFormId.CheckFormIdFree(FormId) == False:
+ return VfrReturnCode.VFR_RETURN_FORMID_REDEFINED
+ self.__FormMap.FormId = FormId
+ CIfrFormId.MarkFormIdUsed(FormId)
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def SetFormMapMethod(self, MethodTitle, MethodGuid: EFI_GUID):
+ MethodMap = EFI_IFR_FORM_MAP_METHOD()
+ MethodMap.MethodTitle = MethodTitle
+ MethodMap.MethodIdentifier = MethodGuid
+ self.__MethodMapList.append(MethodMap)
+
+ def GetInfo(self):
+ return self.__FormMap, self.__MethodMapList
+
+
+class CIfrEnd(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__End = EFI_IFR_END()
+ CIfrOpHeader.__init__(self, self.__End.Header, EFI_IFR_END_OP)
+
+
+class CIfrBanner(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Banner = EFI_IFR_GUID_BANNER()
+ CIfrOpHeader.__init__(self, self.__Banner.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID_BANNER))
+ self.__Banner.ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER
+ self.__Banner.Guid = EFI_IFR_TIANO_GUID
+
+ def SetTitle(self, StringId):
+ self.__Banner.Title = StringId
+
+ def SetLine(self, Line):
+ self.__Banner.LineNumber = Line
+
+ def SetAlign(self, Align):
+ self.__Banner.Alignment = Align
+
+ def GetInfo(self):
+ return self.__Banner
+
+
+class CIfrTimeout(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, Timeout=0):
+ self.__Timeout = EFI_IFR_GUID_TIMEOUT()
+ CIfrOpHeader.__init__(self, self.__Timeout.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID_TIMEOUT))
+ self.__Timeout.ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT
+ self.__Timeout.Guid = EFI_IFR_TIANO_GUID
+ self.__Timeout.TimeOut = Timeout
+
+ def SetTimeout(self, Timeout):
+ self.__Timeout.TimeOut = Timeout
+
+ def GetInfo(self):
+ return self.__Timeout
+
+
+class CIfrLabel(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Label = EFI_IFR_GUID_LABEL()
+ CIfrOpHeader.__init__(self, self.__Label.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID_LABEL))
+ self.__Label.ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL
+ self.__Label.Guid = EFI_IFR_TIANO_GUID
+
+ def SetNumber(self, Number):
+ self.__Label.Number = Number
+
+ def GetInfo(self):
+ return self.__Label
+
+
+class CIfrRule(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Rule = EFI_IFR_RULE()
+ CIfrOpHeader.__init__(self, self.__Rule.Header, EFI_IFR_RULE_OP)
+ self.__Rule.RuleId = EFI_RULE_ID_INVALID
+
+ def SetRuleId(self, RuleId):
+ self.__Rule.RuleId = RuleId
+
+ def GetInfo(self):
+ return self.__Rule
+
+
+def _FLAG_TEST_AND_CLEAR(Flags, Mask):
+
+ Ret = Flags & Mask
+ Flags &= (~Mask)
+ return Flags, Ret
+
+
+def _FLAG_CLEAR(Flags, Mask):
+
+ Flags &= (~Mask)
+ return Flags
+
+
+class CIfrSubtitle(CIfrObj, CIfrOpHeader, CIfrStatementHeader):
+
+ def __init__(self, ):
+ self.__Subtitle = EFI_IFR_SUBTITLE()
+
+ CIfrOpHeader.__init__(self, self.__Subtitle.Header,
+ EFI_IFR_SUBTITLE_OP)
+ CIfrStatementHeader.__init__(self, self.__Subtitle.Statement)
+
+ self.__Subtitle.Flags = 0
+
+ def SetFlags(self, Flags):
+ Flags, Result = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAGS_HORIZONTAL)
+ if Result:
+ self.__Subtitle.Flags |= EFI_IFR_FLAGS_HORIZONTAL
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if Flags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__Subtitle
+
+
+class CIfrImage(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Image = EFI_IFR_IMAGE()
+ CIfrOpHeader.__init__(self, self.__Image.Header, EFI_IFR_IMAGE_OP)
+ self.__Image.Id = EFI_IMAGE_ID_INVALID
+
+ def SetImageId(self, ImageId):
+ self.__Image.Id = ImageId
+
+ def GetInfo(self):
+ return self.__Image
+
+
+class CIfrLocked(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Lock = EFI_IFR_LOCKED()
+ CIfrOpHeader.__init__(self, self.__Lock.Header, EFI_IFR_LOCKED_OP)
+
+
+class CIfrModal(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, ):
+ self.__Modal = EFI_IFR_MODAL_TAG()
+ CIfrOpHeader.__init__(self, self.__Modal.Header, EFI_IFR_MODAL_TAG_OP)
+
+
+EFI_IFR_QUESTION_FLAG_DEFAULT = 0
+
+
+class CIfrQuestionHeader(CIfrStatementHeader):
+
+ def __init__(self, qHeader, Flags=EFI_IFR_QUESTION_FLAG_DEFAULT):
+
+ self.__qHeader = qHeader
+ CIfrStatementHeader.__init__(self, self.__qHeader.Header)
+ self.__qHeader.QuestionId = EFI_QUESTION_ID_INVALID
+ self.__qHeader.VarStoreId = EFI_VARSTORE_ID_INVALID
+ self.__qHeader.VarStoreInfo.VarName = EFI_STRING_ID_INVALID
+ self.__qHeader.VarStoreInfo.VarOffset = EFI_VAROFFSET_INVALID
+ self.__qHeader.Flags = Flags
+
+ def GetQuestionId(self):
+ return self.__qHeader.QuestionId
+
+ def SetQuestionId(self, QuestionId):
+
+ self.__qHeader.QuestionId = QuestionId
+
+ def GetVarStoreId(self):
+ return self.__qHeader.VarStoreId
+
+ def SetVarStoreInfo(self, BaseInfo):
+
+ self.__qHeader.VarStoreId = BaseInfo.VarStoreId
+ self.__qHeader.VarStoreInfo.VarName = BaseInfo.Info.VarName
+ self.__qHeader.VarStoreInfo.VarOffset = BaseInfo.Info.VarOffset
+
+ def GetVarStoreInfo(self, Info): # Bug
+
+ Info.VarStoreId = self.__qHeader.VarStoreId
+ Info.VarStoreInfo = self.__qHeader.VarStoreInfo
+ return Info
+
+ def GetFlags(self):
+ return self.__qHeader.Flags
+
+ def SetFlags(self, Flags):
+
+ Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_READ_ONLY)
+ if Ret:
+ self.__qHeader.Flags |= EFI_IFR_FLAG_READ_ONLY
+
+ Flags = _FLAG_CLEAR(Flags, 0x02)
+
+ Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_CALLBACK)
+ if Ret:
+ self.__qHeader.Flags |= EFI_IFR_FLAG_CALLBACK
+
+ # ignore NVAccessFlag
+ Flags = _FLAG_CLEAR(Flags, 0x08)
+
+ Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_RESET_REQUIRED)
+ if Ret:
+ self.__qHeader.Flags |= EFI_IFR_FLAG_RESET_REQUIRED
+
+ Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags,
+ EFI_IFR_FLAG_RECONNECT_REQUIRED)
+ if Ret:
+ self.__qHeader.Flags |= EFI_IFR_FLAG_RECONNECT_REQUIRED
+
+ # Set LateCheck Flag to compatible for framework flag
+ # but it uses 0x20 as its flag, if in the future UEFI may take this flag
+
+ Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, 0x20)
+ if Ret:
+ self.__qHeader.Flags |= 0x20
+
+ Flags, Ret = _FLAG_TEST_AND_CLEAR(Flags, EFI_IFR_FLAG_OPTIONS_ONLY)
+ if Ret:
+ self.__qHeader.Flags |= EFI_IFR_FLAG_OPTIONS_ONLY
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if Flags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def UpdateCIfrQuestionHeader(self, qHeader):
+ self.__qHeader = qHeader
+
+
+class CIfrRef(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self, ):
+ self.__Ref = EFI_IFR_REF()
+ CIfrOpHeader.__init__(self, self.__Ref.Header, EFI_IFR_REF_OP)
+ CIfrQuestionHeader.__init__(self, self.__Ref.Question)
+ self.__Ref.FormId = 0
+
+ def SetFormId(self, FormId):
+ self.__Ref.FormId = FormId
+
+ def GetInfo(self):
+ return self.__Ref
+
+
+class CIfrRef2(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self, ):
+ self.__Ref2 = EFI_IFR_REF2()
+ CIfrOpHeader.__init__(self, self.__Ref2.Header, EFI_IFR_REF_OP)
+ CIfrQuestionHeader.__init__(self, self.__Ref2.Question)
+ self.__Ref2.FormId = 0
+ self.__Ref2.QuestionId = EFI_QUESTION_ID_INVALID
+
+ def SetFormId(self, FormId):
+ self.__Ref2.FormId = FormId
+
+ def SetQuestionId(self, QuestionId):
+
+ self.__Ref2.QuestionId = QuestionId
+
+ def GetInfo(self):
+ return self.__Ref2
+
+
+class CIfrRef3(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self, ):
+ self.__Ref3 = EFI_IFR_REF3()
+ CIfrOpHeader.__init__(self, self.__Ref3.Header, EFI_IFR_REF_OP)
+ CIfrQuestionHeader.__init__(self, self.__Ref3.Question)
+ self.__Ref3.FormId = 0
+ self.__Ref3.QuestionId = EFI_QUESTION_ID_INVALID
+ EFI_IFR_DEFAULT_GUID = EFI_GUID(0, 0, 0,
+ GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+ self.__Ref3.FormSetId = EFI_IFR_DEFAULT_GUID
+
+ def SetFormId(self, FormId):
+ self.__Ref3.FormId = FormId
+
+ def SetQuestionId(self, QuestionId):
+
+ self.__Ref3.QuestionId = QuestionId
+
+ def SetFormSetId(self, FormSetId):
+ self.__Ref3.FormSetId = FormSetId
+
+ def GetInfo(self):
+ return self.__Ref3
+
+
+class CIfrRef4(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self, ):
+ self.__Ref4 = EFI_IFR_REF4()
+ CIfrOpHeader.__init__(self, self.__Ref4.Header, EFI_IFR_REF_OP)
+ CIfrQuestionHeader.__init__(self, self.__Ref4.Question)
+ self.__Ref4.FormId = 0
+ self.__Ref4.QuestionId = EFI_QUESTION_ID_INVALID
+ EFI_IFR_DEFAULT_GUID = EFI_GUID(0, 0, 0,
+ GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+ self.__Ref4.FormSetId = EFI_IFR_DEFAULT_GUID
+ self.__Ref4.DevicePath = EFI_STRING_ID_INVALID
+
+ def SetFormId(self, FormId):
+ self.__Ref4.FormId = FormId
+
+ def SetQuestionId(self, QuestionId):
+
+ self.__Ref4.QuestionId = QuestionId
+
+ def SetFormSetId(self, FormSetId):
+ self.__Ref4.FormSetId = FormSetId
+
+ def SetDevicePath(self, DevicePath):
+ self.__Ref4.DevicePath = DevicePath
+
+ def GetInfo(self):
+ return self.__Ref4
+
+
+class CIfrRef5(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self, ):
+ self.__Ref5 = EFI_IFR_REF5()
+ CIfrOpHeader.__init__(self, self.__Ref5.Header, EFI_IFR_REF_OP)
+ CIfrQuestionHeader.__init__(self, self.__Ref5.Question)
+
+ def GetInfo(self):
+ return self.__Ref5
+
+
+class CIfrAction(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self, ):
+ self.__Action = EFI_IFR_ACTION()
+ CIfrOpHeader.__init__(self, self.__Action.Header, EFI_IFR_ACTION_OP)
+ CIfrQuestionHeader.__init__(self, self.__Action.Question)
+ self.__Action.QuestionConfig = EFI_STRING_ID_INVALID
+
+ def SetQuestionConfig(self, QuestionConfig):
+ self.__Action.QuestionConfig = QuestionConfig
+
+ def GetInfo(self):
+ return self.__Action
+
+
+class CIfrText(CIfrObj, CIfrOpHeader, CIfrStatementHeader):
+
+ def __init__(self, ):
+ self.__Text = EFI_IFR_TEXT()
+ CIfrOpHeader.__init__(self, self.__Text.Header, EFI_IFR_TEXT_OP)
+ CIfrStatementHeader.__init__(self, self.__Text.Statement)
+ self.__Text.TextTwo = EFI_STRING_ID_INVALID
+
+ def SetTextTwo(self, StringId):
+ self.__Text.TextTwo = StringId
+
+ def GetInfo(self):
+ return self.__Text
+
+
+class CIfrGuid(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, Size, Databuff=None):
+ self.__Guid = EFI_IFR_GUID()
+ self.__Data = Databuff
+ CIfrOpHeader.__init__(self, self.__Guid.Header, EFI_IFR_GUID_OP,
+ ctypes.sizeof(EFI_IFR_GUID) + Size)
+ EFI_IFR_DEFAULT_GUID = EFI_GUID(0, 0, 0,
+ GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+ self.__Guid.Guid = EFI_IFR_DEFAULT_GUID
+
+ def SetGuid(self, Guid):
+ self.__Guid.Guid = Guid
+
+ def SetData(self, Databuff):
+ self.__Data = Databuff
+
+ def GetInfo(self):
+ return self.__Guid
+
+
+class CIfrOrderedList(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self):
+ self.__OrderedList = EFI_IFR_ORDERED_LIST()
+ CIfrOpHeader.__init__(self, self.__OrderedList.Header,
+ EFI_IFR_ORDERED_LIST_OP)
+ CIfrQuestionHeader.__init__(self, self.__OrderedList.Question)
+ self.__OrderedList.MaxContainers = 0
+ self.__OrderedList.Flags = 0
+
+ def GetQuestion(self):
+ return self
+
+ def SetQHeaderFlags(self, Flags):
+ CIfrQuestionHeader.SetFlags(self, Flags)
+
+ def SetMaxContainers(self, MaxContainers):
+ self.__OrderedList.MaxContainers = MaxContainers
+
+ def SetFlags(self, HFlags, LFlags):
+
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_UNIQUE_SET)
+ if Ret:
+ self.__OrderedList.Flags |= EFI_IFR_UNIQUE_SET
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_NO_EMPTY_SET)
+ if Ret:
+ self.__OrderedList.Flags |= EFI_IFR_NO_EMPTY_SET
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__OrderedList
+
+
+class CIfrString(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self):
+ self.__Str = EFI_IFR_STRING()
+ CIfrOpHeader.__init__(self, self.__Str.Header, EFI_IFR_STRING_OP)
+ CIfrQuestionHeader.__init__(self, self.__Str.Question)
+ self.__Str.Flags = 0
+ self.__Str.MinSize = 0
+ self.__Str.MaxSize = 0
+
+ def GetQuestion(self):
+ return self
+
+ def SetQHeaderFlags(self, Flags):
+ CIfrQuestionHeader.SetFlags(self, Flags)
+
+ def SetFlags(self, HFlags, LFlags):
+
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_STRING_MULTI_LINE)
+ if Ret:
+ self.__Str.Flags |= EFI_IFR_STRING_MULTI_LINE
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def SetMinSize(self, MinSize):
+ self.__Str.MinSize = MinSize
+
+ def SetMaxSize(self, MaxSize):
+ self.__Str.MaxSize = MaxSize
+
+ def GetInfo(self):
+ return self.__Str
+
+
+class CIfrPassword(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self):
+ self.__Password = EFI_IFR_PASSWORD()
+ CIfrOpHeader.__init__(self, self.__Password.Header,
+ EFI_IFR_PASSWORD_OP)
+ CIfrQuestionHeader.__init__(self, self.__Password.Question)
+ self.__Password.MinSize = 0
+ self.__Password.MaxSize = 0
+
+ def GetQuestion(self):
+ return self
+
+ def SetQHeaderFlags(self, Flags):
+ CIfrQuestionHeader.SetFlags(self, Flags)
+
+ def SetMinSize(self, MinSize):
+ self.__Password.MinSize = MinSize
+
+ def SetMaxSize(self, MaxSize):
+ self.__Password.MaxSize = MaxSize
+
+ def GetInfo(self):
+ return self.__Password
+
+
+class CIfrDefault(CIfrObj, CIfrOpHeader):
+
+ def __init__(self,
+ Size,
+ DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD,
+ Type=EFI_IFR_TYPE_OTHER,
+ Value=EFI_IFR_TYPE_VALUE()):
+ self.__Default = EFI_IFR_DEFAULT()
+ CIfrOpHeader.__init__(self, self.__Default.Header, EFI_IFR_DEFAULT_OP,
+ Size)
+ self.__Default.Type = Type
+ self.__Default.DefaultId = DefaultId
+ self.__Default.Value = Value
+
+ def SetDefaultId(self, DefaultId):
+ self.__Default.DefaultId = DefaultId
+
+ def SetType(self, Type):
+ self.__Default.Type = Type
+
+ def SetValue(self, Value):
+ self.__Default.Value = Value
+
+ def GetInfo(self):
+ return self.__Default
+
+
+class CIfrDefault3(CIfrObj, CIfrOpHeader):
+
+ def __init__(self,
+ Size,
+ Nums,
+ ValueType,
+ DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD,
+ Type=EFI_IFR_TYPE_OTHER,
+ ValueList=[]):
+ Header = EFI_IFR_OP_HEADER()
+ CIfrOpHeader.__init__(self, Header, EFI_IFR_DEFAULT_OP, Size)
+ self.__Default = Refine_EFI_IFR_DEFAULT(Nums)
+ self.__Default.Header = Header
+ self.__Default.Type = Type
+ self.__Default.DefaultId = DefaultId
+ self.__ValueType = ValueType
+
+ if ValueList != []:
+ ArrayType = EFI_IFR_TYPE_VALUE * Nums
+ ValueArray = ArrayType()
+ for i in range(0, len(ValueList)):
+ ValueArray[i] = ValueList[i]
+ self.__Default.Value = ValueArray
+
+ def SetDefaultId(self, DefaultId):
+ self.__Default.DefaultId = DefaultId
+
+ def GetValueType(self):
+ return self.__ValueType
+
+ def SetType(self, Type):
+ self.__Default.Type = Type
+
+ def SetValue(self, ValueList):
+ ArrayType = EFI_IFR_TYPE_VALUE * (len(ValueList))
+ ValueArray = ArrayType()
+ for i in range(0, len(ValueList)):
+ ValueArray[i] = ValueList[i]
+ self.__Default.Value = ValueArray
+
+ def GetInfo(self):
+ return self.__Default
+
+
+class CIfrDefault2(CIfrObj, CIfrOpHeader):
+
+ def __init__(self,
+ DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD,
+ Type=EFI_IFR_TYPE_OTHER):
+ self.__Default = EFI_IFR_DEFAULT_2()
+ CIfrOpHeader.__init__(self, self.__Default.Header, EFI_IFR_DEFAULT_OP)
+ self.__Default.Type = Type
+ self.__Default.DefaultId = DefaultId
+
+ def SetDefaultId(self, DefaultId):
+ self.__Default.DefaultId = DefaultId
+
+ def SetType(self, Type):
+ self.__Default.Type = Type
+
+ def GetInfo(self):
+ return self.__Default
+
+
+class CIfrInconsistentIf(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__InconsistentIf = EFI_IFR_INCONSISTENT_IF()
+ CIfrOpHeader.__init__(self, self.__InconsistentIf.Header,
+ EFI_IFR_INCONSISTENT_IF_OP)
+ self.__InconsistentIf.Error = EFI_STRING_ID_INVALID
+
+ def SetError(self, Error):
+ self.__InconsistentIf.Error = Error
+
+
+class CIfrNoSubmitIf(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__NoSubmitIf = EFI_IFR_NO_SUBMIT_IF()
+ CIfrOpHeader.__init__(self, self.__NoSubmitIf.Header,
+ EFI_IFR_NO_SUBMIT_IF_OP)
+ self.__NoSubmitIf.Error = EFI_STRING_ID_INVALID
+
+ def SetError(self, Error):
+ self.__NoSubmitIf.Error = Error
+
+
+class CIfrDisableIf(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__DisableIf = EFI_IFR_DISABLE_IF()
+ CIfrOpHeader.__init__(self, self.__DisableIf.Header,
+ EFI_IFR_DISABLE_IF_OP)
+
+
+class CIfrSuppressIf(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__SuppressIf = EFI_IFR_SUPPRESS_IF()
+ CIfrOpHeader.__init__(self, self.__SuppressIf.Header,
+ EFI_IFR_SUPPRESS_IF_OP)
+
+
+class CIfrGrayOutIf(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__GrayOutIf = EFI_IFR_GRAY_OUT_IF()
+ CIfrOpHeader.__init__(self, self.__GrayOutIf.Header,
+ EFI_IFR_GRAY_OUT_IF_OP)
+
+
+class CIfrValue(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__Value = EFI_IFR_VALUE()
+ CIfrOpHeader.__init__(self, self.__Value.Header, EFI_IFR_VALUE_OP)
+
+
+class CIfrRead(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__Read = EFI_IFR_READ()
+ CIfrOpHeader.__init__(self, self.__Read.Header, EFI_IFR_READ_OP)
+
+
+class CIfrWrite(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__Write = EFI_IFR_WRITE()
+ CIfrOpHeader.__init__(self, self.__Write.Header, EFI_IFR_WRITE_OP)
+
+
+class CIfrWarningIf(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__WarningIf = EFI_IFR_WARNING_IF()
+ CIfrOpHeader.__init__(self, self.__WarningIf.Header,
+ EFI_IFR_WARNING_IF_OP)
+ self.__WarningIf.Warning = EFI_STRING_ID_INVALID
+ self.__WarningIf.TimeOut = 0
+
+ def SetWarning(self, Warning):
+ self.__WarningIf.Warning = Warning
+
+ def SetTimeOut(self, TimeOut):
+ self.__WarningIf.TimeOut = TimeOut
+
+ def GetInfo(self):
+ return self.__WarningIf
+
+
+class CIfrRefresh(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__Refresh = EFI_IFR_REFRESH()
+ CIfrOpHeader.__init__(self, self.__Refresh.Header, EFI_IFR_REFRESH_OP)
+ self.__Refresh.RefreshInterval = 0
+
+ def SetRefreshInterval(self, RefreshInterval):
+ self.__Refresh.RefreshInterval = RefreshInterval
+
+ def GetInfo(self):
+ return self.__Refresh
+
+
+class CIfrRefreshId(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__RefreshId = EFI_IFR_REFRESH_ID()
+ CIfrOpHeader.__init__(self, self.__RefreshId.Header,
+ EFI_IFR_REFRESH_ID_OP)
+ self.__RefreshId.RefreshEventGroupId = EFI_GUID(
+ 0, 0, 0, GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+
+ def SetRefreshEventGroutId(self, RefreshEventGroupId):
+ self.__RefreshId.RefreshEventGroupId = RefreshEventGroupId
+
+ def GetInfo(self):
+ return self.__RefreshId
+
+
+class CIfrVarStoreDevice(CIfrObj, CIfrOpHeader):
+
+ def __init__(self):
+ self.__VarStoreDevice = EFI_IFR_VARSTORE_DEVICE()
+ CIfrOpHeader.__init__(self, self.__VarStoreDevice.Header,
+ EFI_IFR_VARSTORE_DEVICE_OP)
+ self.__VarStoreDevice.DevicePath = EFI_STRING_ID_INVALID
+
+ def SetDevicePath(self, DevicePath):
+ self.__VarStoreDevice.DevicePath = DevicePath
+
+ def GetInfo(self):
+ return self.__VarStoreDevice
+
+
+class CIfrDate(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self):
+ self.__Date = EFI_IFR_DATE()
+ CIfrOpHeader.__init__(self, self.__Date.Header, EFI_IFR_DATE_OP)
+ CIfrQuestionHeader.__init__(self, self.__Date.Question)
+ self.__Date.Flags = 0
+
+ def SetFlags(self, HFlags, LFlags):
+
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_QF_DATE_YEAR_SUPPRESS)
+ if Ret:
+ self.__Date.Flags |= EFI_QF_DATE_YEAR_SUPPRESS
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_QF_DATE_MONTH_SUPPRESS)
+ if Ret:
+ self.__Date.Flags |= EFI_QF_DATE_MONTH_SUPPRESS
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_QF_DATE_DAY_SUPPRESS)
+ if Ret:
+ self.__Date.Flags |= EFI_QF_DATE_DAY_SUPPRESS
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_DATE_STORAGE_NORMAL)
+ if Ret:
+ self.__Date.Flags |= QF_DATE_STORAGE_NORMAL
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_DATE_STORAGE_TIME)
+ if Ret:
+ self.__Date.Flags |= QF_DATE_STORAGE_TIME
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_DATE_STORAGE_WAKEUP)
+ if Ret:
+ self.__Date.Flags |= QF_DATE_STORAGE_WAKEUP
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__Date
+
+
+class CIfrTime(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self):
+ self.__Time = EFI_IFR_TIME()
+ CIfrOpHeader.__init__(self, self.__Time.Header, EFI_IFR_TIME_OP)
+ CIfrQuestionHeader.__init__(self, self.__Time.Question)
+ self.__Time.Flags = 0
+
+ def SetFlags(self, HFlags, LFlags):
+
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_HOUR_SUPPRESS)
+ if Ret:
+ self.__Time.Flags |= QF_TIME_HOUR_SUPPRESS
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_MINUTE_SUPPRESS)
+ if Ret:
+ self.__Time.Flags |= QF_TIME_MINUTE_SUPPRESS
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_SECOND_SUPPRESS)
+ if Ret:
+ self.__Time.Flags |= QF_TIME_SECOND_SUPPRESS
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_STORAGE_NORMAL)
+ if Ret:
+ self.__Time.Flags |= QF_TIME_STORAGE_NORMAL
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_STORAGE_TIME)
+ if Ret:
+ self.__Time.Flags |= QF_TIME_STORAGE_TIME
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, QF_TIME_STORAGE_WAKEUP)
+ if Ret:
+ self.__Time.Flags |= QF_TIME_STORAGE_WAKEUP
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__Time
+
+
+class CIfrNumeric(CIfrObj, CIfrOpHeader, CIfrQuestionHeader,
+ CIfrMinMaxStepData):
+
+ def __init__(self):
+ self.__Numeric = EFI_IFR_NUMERIC() # data
+ CIfrOpHeader.__init__(self, self.__Numeric.Header, EFI_IFR_NUMERIC_OP)
+ CIfrQuestionHeader.__init__(self, self.__Numeric.Question)
+ CIfrMinMaxStepData.__init__(self, self.__Numeric.Data, True)
+ self.__Numeric.Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC
+
+ def GetQuestion(self):
+ return self
+
+ def GetMinMaxData(self):
+ return self
+
+ def SetQHeaderFlags(self, Flags):
+ CIfrQuestionHeader.SetFlags(self, Flags)
+
+ def SetFlags(self, HFlags, LFlags, DisplaySettingsSpecified=False):
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+ if DisplaySettingsSpecified == False:
+ self.__Numeric.Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC
+ else:
+ self.__Numeric.Flags = LFlags
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def SetFlagsForBitField(self,
+ HFlags,
+ LFlags,
+ DisplaySettingsSpecified=False):
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+ if DisplaySettingsSpecified == False:
+ self.__Numeric.Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT
+ else:
+ self.__Numeric.Flags = LFlags
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetNumericFlags(self):
+ return self.__Numeric.Flags
+
+ def ShrinkBinSize(self, Size):
+ self.ShrinkBinSize(Size)
+ self.DecLength(Size)
+ # _EMIT_PENDING_OBJ();
+ Numeric = EFI_IFR_NUMERIC()
+ self.UpdateHeader(Numeric.Header)
+
+ def GetInfo(self):
+ return self.__Numeric
+
+
+class CIfrOneOf(
+ CIfrQuestionHeader,
+ CIfrObj,
+ CIfrOpHeader,
+):
+
+ def __init__(self):
+ self.__OneOf = EFI_IFR_ONE_OF()
+ CIfrOpHeader.__init__(self, self.__OneOf.Header, EFI_IFR_ONE_OF_OP)
+ CIfrQuestionHeader.__init__(self, self.__OneOf.Question)
+ self.__OneOf.Flags = 0
+
+ def GetQuestion(self):
+ return self
+
+ def GetMinMaxData(self):
+ return self
+
+ def SetQHeaderFlags(self, Flags):
+ CIfrQuestionHeader.SetFlags(self, Flags)
+
+ def SetFlags(self, HFlags, LFlags):
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+ if LFlags & EFI_IFR_DISPLAY:
+ self.__OneOf.Flags = LFlags
+ else:
+ self.__OneOf.Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def SetFlagsForBitField(self, HFlags, LFlags):
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+ if LFlags & EDKII_IFR_DISPLAY_BIT:
+ self.__OneOf.Flags = LFlags
+ else:
+ self.__OneOf.Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetInfo(self):
+ return self.__OneOf
+
+
+class CIfrCheckBox(CIfrObj, CIfrOpHeader, CIfrQuestionHeader):
+
+ def __init__(self):
+ self.__CheckBox = EFI_IFR_CHECKBOX()
+ CIfrOpHeader.__init__(self, self.__CheckBox.Header,
+ EFI_IFR_CHECKBOX_OP)
+ CIfrQuestionHeader.__init__(self, self.__CheckBox.Question)
+ self.__CheckBox.Flags = 0
+
+ def GetQuestion(self):
+ return self
+
+ def SetQHeaderFlags(self, Flags):
+ CIfrQuestionHeader.SetFlags(self, Flags)
+
+ def GetFlags(self):
+ return self.__CheckBox.Flags
+
+ def SetFlags(self, HFlags, LFlags):
+
+ ReturnCode = CIfrQuestionHeader.SetFlags(self, HFlags)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags, EFI_IFR_CHECKBOX_DEFAULT)
+ if Ret:
+ self.__CheckBox.Flags |= EFI_IFR_CHECKBOX_DEFAULT
+
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(LFlags,
+ EFI_IFR_CHECKBOX_DEFAULT_MFG)
+
+ if Ret:
+ self.__CheckBox.Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+ def GetInfo(self):
+ return self.__CheckBox
+
+
+class CIfrResetButton(CIfrObj, CIfrOpHeader, CIfrStatementHeader):
+
+ def __init__(self):
+ self.__ResetButton = EFI_IFR_RESET_BUTTON()
+ CIfrOpHeader.__init__(self, self.__ResetButton.Header,
+ EFI_IFR_RESET_BUTTON_OP)
+ CIfrStatementHeader.__init__(self, self.__ResetButton.Statement)
+ self.__ResetButton.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD
+
+ def SetDefaultId(self, DefaultId):
+ self.__ResetButton.DefaultId = DefaultId
+
+ def GetInfo(self):
+ return self.__ResetButton
+
+
+class CIfrOr(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Or = EFI_IFR_OR()
+ CIfrOpHeader.__init__(self, self.__Or.Header, EFI_IFR_OR_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrAnd(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__And = EFI_IFR_AND()
+ CIfrOpHeader.__init__(self, self.__And.Header, EFI_IFR_AND_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrBitWiseOr(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__BitWiseOr = EFI_IFR_BITWISE_OR()
+ CIfrOpHeader.__init__(self, self.__BitWiseOr.Header,
+ EFI_IFR_BITWISE_OR_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrCatenate(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Catenate = EFI_IFR_CATENATE()
+ CIfrOpHeader.__init__(self, self.__Catenate.Header,
+ EFI_IFR_CATENATE_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrDivide(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Divide = EFI_IFR_DIVIDE()
+ CIfrOpHeader.__init__(self, self.__Divide.Header, EFI_IFR_DIVIDE_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrEqual(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Equal = EFI_IFR_EQUAL()
+ CIfrOpHeader.__init__(self, self.__Equal.Header, EFI_IFR_EQUAL_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrGreaterEqual(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__GreaterEqual = EFI_IFR_GREATER_EQUAL()
+ CIfrOpHeader.__init__(self, self.__GreaterEqual.Header,
+ EFI_IFR_GREATER_EQUAL_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrGreaterThan(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__GreaterThan = EFI_IFR_GREATER_THAN()
+ CIfrOpHeader.__init__(self, self.__GreaterThan.Header,
+ EFI_IFR_GREATER_THAN_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrLessEqual(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__LessEqual = EFI_IFR_LESS_EQUAL()
+ CIfrOpHeader.__init__(self, self.__LessEqual.Header,
+ EFI_IFR_LESS_EQUAL_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrLessThan(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__LessThan = EFI_IFR_LESS_THAN()
+ CIfrOpHeader.__init__(self, self.__LessThan.Header,
+ EFI_IFR_LESS_THAN_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrMap(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Map = EFI_IFR_MAP()
+ CIfrOpHeader.__init__(self, self.__Map.Header, EFI_IFR_MAP_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrMatch(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Match = EFI_IFR_MATCH()
+ CIfrOpHeader.__init__(self, self.__Match.Header, EFI_IFR_MATCH_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrMatch2(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo, Guid):
+ self.__Match2 = EFI_IFR_MATCH2()
+ CIfrOpHeader.__init__(self, self.__Match2.Header, EFI_IFR_MATCH2_OP)
+ self.SetLineNo(LineNo)
+ self.__Match2.SyntaxType = Guid
+
+
+class CIfrMultiply(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Multiply = EFI_IFR_MULTIPLY()
+ CIfrOpHeader.__init__(self, self.__Multiply.Header,
+ EFI_IFR_MULTIPLY_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrModulo(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Modulo = EFI_IFR_MODULO()
+ CIfrOpHeader.__init__(self, self.__Modulo.Header, EFI_IFR_MODULO_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrNotEqual(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__NotEqual = EFI_IFR_NOT_EQUAL()
+ CIfrOpHeader.__init__(self, self.__NotEqual.Header,
+ EFI_IFR_NOT_EQUAL_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrShiftLeft(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__ShiftLeft = EFI_IFR_SHIFT_LEFT()
+ CIfrOpHeader.__init__(self, self.__ShiftLeft.Header,
+ EFI_IFR_SHIFT_LEFT_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrShiftRight(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__ShiftRight = EFI_IFR_SHIFT_RIGHT()
+ CIfrOpHeader.__init__(self, self.__ShiftRight.Header,
+ EFI_IFR_SHIFT_RIGHT_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrSubtract(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Subtract = EFI_IFR_SUBTRACT()
+ CIfrOpHeader.__init__(self, self.__Subtract.Header,
+ EFI_IFR_SUBTRACT_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrConditional(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Conditional = EFI_IFR_CONDITIONAL()
+ CIfrOpHeader.__init__(self, self.__Conditional.Header,
+ EFI_IFR_CONDITIONAL_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrFind(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Find = EFI_IFR_FIND()
+ CIfrOpHeader.__init__(self, self.__Find.Header, EFI_IFR_FIND_OP)
+ self.SetLineNo(LineNo)
+
+ def SetFormat(self, Format):
+ self.__Find.Format = Format
+
+
+class CIfrMid(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Mid = EFI_IFR_MID()
+ CIfrOpHeader.__init__(self, self.__Mid.Header, EFI_IFR_MID_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrToken(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Token = EFI_IFR_TOKEN()
+ CIfrOpHeader.__init__(self, self.__Token.Header, EFI_IFR_TOKEN_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrSpan(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Span = EFI_IFR_SPAN()
+ CIfrOpHeader.__init__(self, self.__Span.Header, EFI_IFR_SPAN_OP)
+ self.SetLineNo(LineNo)
+ self.__Span.Flags = EFI_IFR_FLAGS_FIRST_MATCHING
+
+ def SetFlags(self, LFlags):
+ if LFlags == EFI_IFR_FLAGS_FIRST_MATCHING:
+ self.__Span.Flags |= EFI_IFR_FLAGS_FIRST_MATCHING
+ else:
+ LFlags, Ret = _FLAG_TEST_AND_CLEAR(
+ LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING)
+ if Ret:
+ self.__Span.Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS if LFlags == 0 else VfrReturnCode.VFR_RETURN_FLAGS_UNSUPPORTED
+
+
+class CIfrBitWiseAnd(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__BitWiseAnd = EFI_IFR_BITWISE_AND()
+ CIfrOpHeader.__init__(self, self.__BitWiseAnd.Header,
+ EFI_IFR_BITWISE_AND_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrBitWiseOr(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__BitWiseOr = EFI_IFR_BITWISE_OR()
+ CIfrOpHeader.__init__(self, self.__BitWiseOr.Header,
+ EFI_IFR_BITWISE_OR_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrAdd(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Add = EFI_IFR_ADD()
+ CIfrOpHeader.__init__(self, self.__Add.Header, EFI_IFR_ADD_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrToString(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__ToString = EFI_IFR_TO_STRING()
+ CIfrOpHeader.__init__(self, self.__ToString.Header,
+ EFI_IFR_TO_STRING_OP)
+ self.SetLineNo(LineNo)
+
+ def SetFormat(self, Format):
+ self.__ToString.Format = Format
+
+
+class CIfrToUpper(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__ToUppper = EFI_IFR_TO_UPPER()
+ CIfrOpHeader.__init__(self, self.__ToUppper.Header,
+ EFI_IFR_TO_UPPER_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrToUint(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__ToUint = EFI_IFR_TO_UINT()
+ CIfrOpHeader.__init__(self, self.__ToUint.Header, EFI_IFR_TO_UINT_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrToLower(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__ToLower = EFI_IFR_TO_LOWER()
+ CIfrOpHeader.__init__(self, self.__ToLower.Header, EFI_IFR_TO_LOWER_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrToBoolean(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Boolean = EFI_IFR_TO_BOOLEAN()
+ CIfrOpHeader.__init__(self, self.__Boolean.Header,
+ EFI_IFR_TO_BOOLEAN_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrNot(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Not = EFI_IFR_NOT()
+ CIfrOpHeader.__init__(self, self.__Not.Header, EFI_IFR_NOT_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrDup(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Dup = EFI_IFR_DUP()
+ CIfrOpHeader.__init__(self, self.__Dup.Header, EFI_IFR_DUP_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__Dup.Header
+
+
+class CIfrEqIdId(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__EqIdId = EFI_IFR_EQ_ID_ID()
+ CIfrOpHeader.__init__(self, self.__EqIdId.Header, EFI_IFR_EQ_ID_ID_OP)
+ self.SetLineNo(LineNo)
+ self.__EqIdId.QuestionId1 = EFI_QUESTION_ID_INVALID
+ self.__EqIdId.QuestionId2 = EFI_QUESTION_ID_INVALID
+
+ def GetHeader(self):
+ return self.__EqIdId.Header
+
+ def SetQuestionId1(self, QuestionId, VarIdStr, LineNo):
+ if QuestionId != EFI_QUESTION_ID_INVALID:
+ self.__EqIdId.QuestionId1 = QuestionId
+ else:
+ pass
+
+ def SetQuestionId2(self, QuestionId, VarIdStr, LineNo):
+ if QuestionId != EFI_QUESTION_ID_INVALID:
+ self.__EqIdId.QuestionId2 = QuestionId
+ else:
+ pass
+
+
+class CIfrEqIdVal(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__EqIdVal = EFI_IFR_EQ_ID_VAL()
+ CIfrOpHeader.__init__(self, self.__EqIdVal.Header,
+ EFI_IFR_EQ_ID_VAL_OP)
+ self.SetLineNo(LineNo)
+ self.__EqIdVal.QuestionId = EFI_QUESTION_ID_INVALID
+
+ def SetQuestionId(self, QuestionId, VarIdStr, LineNo):
+ if QuestionId != EFI_QUESTION_ID_INVALID:
+ self.__EqIdVal.QuestionId = QuestionId
+ else:
+ pass
+
+ def SetValue(self, Value):
+ self.__EqIdVal.Value = Value
+
+ def GetHeader(self):
+ return self.__EqIdVal.Header
+
+
+class CIfrEqIdList(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo, Nums, ValueList=[]):
+ self.__EqIdVList = Refine_EFI_IFR_EQ_ID_VAL_LIST(Nums)
+ Header = EFI_IFR_OP_HEADER()
+ CIfrOpHeader.__init__(self, Header, EFI_IFR_EQ_ID_VAL_OP)
+ self.SetLineNo(LineNo)
+ self.__EqIdVList.Header = Header
+ self.__EqIdVList.QuestionId = EFI_QUESTION_ID_INVALID
+ self.__EqIdVList.ListLength = 0
+ if ValueList != []:
+ ArrayType = c_uint16 * Nums
+ ValueArray = ArrayType()
+ for i in range(0, len(ValueList)):
+ ValueArray[i] = ValueList[i]
+ self.__EqIdVList.ValueList = ValueArray
+
+ def SetQuestionId(self, QuestionId, VarIdStr, LineNo):
+ if QuestionId != EFI_QUESTION_ID_INVALID:
+ self.__EqIdVList.QuestionId = QuestionId
+ else:
+ pass
+
+ def SetListLength(self, ListLength):
+ self.__EqIdVList.ListLength = ListLength
+
+ def SetValueList(self, ValueList):
+ if ValueList != []:
+ ArrayType = c_uint16 * len(ValueList)
+ ValueArray = ArrayType()
+ for i in range(0, len(ValueList)):
+ ValueArray[i] = ValueList[i]
+ self.__EqIdVList.ValueList = ValueArray
+
+ def GetHeader(self):
+ return self.__EqIdVList.Header
+
+
+class CIfrUint8(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Uint8 = EFI_IFR_UINT8()
+ CIfrOpHeader.__init__(self, self.__Uint8.Header, EFI_IFR_UINT8_OP)
+ self.SetLineNo(LineNo)
+
+ def SetValue(self, Value):
+ self.__Uint8.Value = Value
+
+ def GetHeader(self):
+ return self.__Uint8.Header
+
+
+class CIfrUint16(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Uint16 = EFI_IFR_UINT16()
+ CIfrOpHeader.__init__(self, self.__Uint16.Header, EFI_IFR_UINT16_OP)
+ self.SetLineNo(LineNo)
+
+ def SetValue(self, Value):
+ self.__Uint16.Value = Value
+
+ def GetHeader(self):
+ return self.__Uint16.Header
+
+
+class CIfrUint32(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Uint32 = EFI_IFR_UINT32()
+ CIfrOpHeader.__init__(self, self.__Uint32.Header, EFI_IFR_UINT32_OP)
+ self.SetLineNo(LineNo)
+
+ def SetValue(self, Value):
+ self.__Uint32.Value = Value
+
+ def GetHeader(self):
+ return self.__Uint32.Header
+
+
+class CIfrUint64(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Uint64 = EFI_IFR_UINT64()
+ CIfrOpHeader.__init__(self, self.__Uint64.Header, EFI_IFR_UINT64_OP)
+ self.SetLineNo(LineNo)
+
+ def SetValue(self, Value):
+ self.__Uint64.Value = Value
+
+ def GetHeader(self):
+ return self.__Uint64.Header
+
+
+class CIfrQuestionRef1(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__QuestionRef1 = EFI_IFR_QUESTION_REF1()
+ CIfrOpHeader.__init__(self, self.__QuestionRef1.Header,
+ EFI_IFR_QUESTION_REF1_OP)
+ self.SetLineNo(LineNo)
+ self.__QuestionRef1.QuestionId = EFI_QUESTION_ID_INVALID
+
+ def GetHeader(self):
+ return self.__QuestionRef1.Header
+
+ def SetQuestionId(self, QuestionId, VarIdStr, LineNo):
+ if QuestionId != EFI_QUESTION_ID_INVALID:
+ self.__QuestionRef1.QuestionId = QuestionId
+ else:
+ pass
+
+
+class CIfrQuestionRef2(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__QuestionRef2 = EFI_IFR_QUESTION_REF2()
+ CIfrOpHeader.__init__(self, self.__QuestionRef2.Header,
+ EFI_IFR_QUESTION_REF2_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__QuestionRef2.Header
+
+
+class CIfrQuestionRef3(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__QuestionRef3 = EFI_IFR_QUESTION_REF3()
+ CIfrOpHeader.__init__(self, self.__QuestionRef3.Header,
+ EFI_IFR_QUESTION_REF3_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__QuestionRef3.Header
+
+
+class CIfrQuestionRef3_2(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__QuestionRef3_2 = EFI_IFR_QUESTION_REF3_2()
+ CIfrOpHeader.__init__(self, self.__QuestionRef3_2.Header,
+ EFI_IFR_QUESTION_REF3_OP)
+ self.SetLineNo(LineNo)
+ self.__QuestionRef3_2.DevicePath = EFI_STRING_ID_INVALID
+
+ def SetDevicePath(self, DevicePath):
+ self.__QuestionRef3_2.DevicePath = DevicePath
+
+ def GetHeader(self):
+ return self.__QuestionRef3_2.Header
+
+
+class CIfrQuestionRef3_3(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__QuestionRef3_3 = EFI_IFR_QUESTION_REF3_3()
+ CIfrOpHeader.__init__(self, self.__QuestionRef3_3.Header,
+ EFI_IFR_QUESTION_REF3_OP)
+ self.SetLineNo(LineNo)
+ self.__QuestionRef3_3.DevicePath = EFI_STRING_ID_INVALID
+ self.__QuestionRef3_3.Guid = EFI_GUID(
+ 0, 0, 0, GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+
+ def SetDevicePath(self, DevicePath):
+ self.__QuestionRef3_3.DevicePath = DevicePath
+
+ def SetGuid(self, Guid):
+ self.__QuestionRef3_3.Guid = Guid
+
+ def GetHeader(self):
+ return self.__QuestionRef3_3.Header
+
+
+class CIfrRuleRef(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__RuleRef = EFI_IFR_RULE_REF()
+ CIfrOpHeader.__init__(self, self.__RuleRef.Header, EFI_IFR_RULE_REF_OP)
+ self.SetLineNo(LineNo)
+ self.__RuleRef.RuleId = EFI_RULE_ID_INVALID
+
+ def SetRuleId(self, RuleId):
+ self.__RuleRef.RuleId = RuleId
+
+ def GetHeader(self):
+ return self.__RuleRef.Header
+
+
+class CIfrStringRef1(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__StringRef1 = EFI_IFR_STRING_REF1()
+ CIfrOpHeader.__init__(self, self.__StringRef1.Header,
+ EFI_IFR_STRING_REF1_OP)
+ self.SetLineNo(LineNo)
+ self.__StringRef1.StringId = EFI_STRING_ID_INVALID
+
+ def SetStringId(self, StringId):
+ self.__StringRef1.StringId = StringId
+
+ def GetHeader(self):
+ return self.__StringRef1.Header
+
+
+class CIfrStringRef2(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__StringRef2 = EFI_IFR_STRING_REF2()
+ CIfrOpHeader.__init__(self, self.__StringRef2.Header,
+ EFI_IFR_STRING_REF2_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__StringRef2.Header
+
+
+class CIfrThis(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__This = EFI_IFR_THIS()
+ CIfrOpHeader.__init__(self, self.__This.Header, EFI_IFR_THIS_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__This.Header
+
+
+class CIfrSecurity(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Security = EFI_IFR_SECURITY()
+ CIfrOpHeader.__init__(self, self.__Security.Header,
+ EFI_IFR_SECURITY_OP)
+ self.SetLineNo(LineNo)
+ self.__Security.Permissions = EFI_GUID(
+ 0, 0, 0, GuidArray(0, 0, 0, 0, 0, 0, 0, 0))
+
+ def SetPermissions(self, Permissions):
+ self.__Security.Permissions = Permissions
+
+ def GetHeader(self):
+ return self.__Security.Header
+
+
+class CIfrGet(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Get = EFI_IFR_GET()
+ CIfrOpHeader.__init__(self, self.__Get.Header, EFI_IFR_GET_OP)
+ self.SetLineNo(LineNo)
+
+ def SetVarInfo(self, BaseInfo: EFI_VARSTORE_INFO):
+ self.__Get.VarStoreId = BaseInfo.VarStoreId
+ self.__Get.VarStoreInfo.VarName = BaseInfo.Info.VarName
+ self.__Get.VarStoreInfo.VarOffset = BaseInfo.Info.VarOffset
+ self.__Get.VarStoreType = BaseInfo.VarType
+
+ def GetHeader(self):
+ return self.__Get.Header
+
+
+class CIfrSet(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Set = EFI_IFR_SET()
+ CIfrOpHeader.__init__(self, self.__Set.Header, EFI_IFR_SET_OP)
+ self.SetLineNo(LineNo)
+
+ def SetVarInfo(self, BaseInfo: EFI_VARSTORE_INFO):
+ self.__Set.VarStoreId = BaseInfo.VarStoreId
+ self.__Set.VarStoreInfo.VarName = BaseInfo.Info.VarName
+ self.__Set.VarStoreInfo.VarOffset = BaseInfo.Info.VarOffset
+ self.__Set.VarStoreType = BaseInfo.VarType
+
+ def GetHeader(self):
+ return self.__Set.Header
+
+
+class CIfrTrue(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__True = EFI_IFR_TRUE()
+ CIfrOpHeader.__init__(self, self.__True.Header, EFI_IFR_TRUE_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__True.Header
+
+
+class CIfrFalse(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__False = EFI_IFR_TRUE()
+ CIfrOpHeader.__init__(self, self.__False.Header, EFI_IFR_FALSE_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__False.Header
+
+
+class CIfrOne(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__One = EFI_IFR_ONE()
+ CIfrOpHeader.__init__(self, self.__One.Header, EFI_IFR_ONE_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__One.Header
+
+
+class CIfrOnes(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Ones = EFI_IFR_ONE()
+ CIfrOpHeader.__init__(self, self.__Ones.Header, EFI_IFR_ONES_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__Ones.Header
+
+
+class CIfrZero(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Zero = EFI_IFR_ZERO()
+ CIfrOpHeader.__init__(self, self.__Zero.Header, EFI_IFR_ZERO_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__Zero.Header
+
+
+class CIfrUndefined(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Undefined = EFI_IFR_ZERO()
+ CIfrOpHeader.__init__(self, self.__Undefined.Header,
+ EFI_IFR_UNDEFINED_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__Undefined.Header
+
+
+class CIfrVersion(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Version = EFI_IFR_VERSION()
+ CIfrOpHeader.__init__(self, self.__Version.Header, EFI_IFR_VERSION_OP)
+ self.SetLineNo(LineNo)
+
+ def GetHeader(self):
+ return self.__Version.Header
+
+
+class CIfrLength(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__Length = EFI_IFR_LENGTH()
+ CIfrOpHeader.__init__(self, self.__Length.Header, EFI_IFR_LENGTH_OP)
+ self.SetLineNo(LineNo)
+
+
+class CIfrBitWiseNot(CIfrObj, CIfrOpHeader):
+
+ def __init__(self, LineNo):
+ self.__BitWiseNot = EFI_IFR_BITWISE_NOT()
+ CIfrOpHeader.__init__(self, self.__BitWiseNot.Header,
+ EFI_IFR_BITWISE_NOT_OP)
+ self.SetLineNo(LineNo)
+
+
+class ExpressionInfo():
+
+ def __init__(self):
+ self.RootLevel = 0
+ self.ExpOpCount = 0
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/VfrSyntax.g4 b/edk2basetools/VfrCompiler/VfrSyntax.g4
new file mode 100644
index 0000000..8d5d6d4
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrSyntax.g4
@@ -0,0 +1,1887 @@
+grammar VfrSyntax;
+options {
+ language=Python;
+}
+ at header{
+
+from VfrCompiler.CommonCtypes import *
+from VfrCompiler.VfrFormPkg import *
+from VfrCompiler.VfrUtility import *
+from VfrCompiler.VfrTree import *
+}
+
+vfrProgram
+ : (vfrPragmaPackDefinition | vfrDataStructDefinition | vfrDataUnionDefinition)* vfrFormSetDefinition
+ ;
+
+pragmaPackShowDef
+ : 'show'
+ ;
+
+pragmaPackStackDef
+ : ('push' | 'pop') (',' StringIdentifier)? (',' Number)?
+ ;
+
+pragmaPackNumber
+ : Number?
+ ;
+
+vfrPragmaPackDefinition
+ : '#pragma' 'pack' '('
+ ( pragmaPackShowDef
+ | pragmaPackStackDef
+ | pragmaPackNumber
+ )?
+ ')'
+ ;
+
+vfrDataStructDefinition
+ : (TypeDef)? Struct NonNvDataMap? N1=StringIdentifier? '{' vfrDataStructFields[False] '}' N2=StringIdentifier? ';'
+ ;
+
+vfrDataUnionDefinition
+ : (TypeDef)? Union NonNvDataMap? N1=StringIdentifier? '{' vfrDataStructFields[True]'}' N2=StringIdentifier? ';'
+ ;
+
+vfrDataStructFields[FieldInUnion]
+ :
+ ( dataStructField64[FieldInUnion]
+ | dataStructField32[FieldInUnion]
+ | dataStructField16[FieldInUnion]
+ | dataStructField8[FieldInUnion]
+ | dataStructFieldBool[FieldInUnion]
+ | dataStructFieldString[FieldInUnion]
+ | dataStructFieldDate[FieldInUnion]
+ | dataStructFieldTime[FieldInUnion]
+ | dataStructFieldRef[FieldInUnion]
+ | dataStructFieldUser[FieldInUnion]
+ | dataStructBitField64[FieldInUnion]
+ | dataStructBitField32[FieldInUnion]
+ | dataStructBitField16[FieldInUnion]
+ | dataStructBitField8[FieldInUnion]
+ )*
+ ;
+
+dataStructField64[FieldInUnion]
+ : 'UINT64' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructField32[FieldInUnion]
+ : 'UINT32' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructField16[FieldInUnion]
+ : 'UINT16' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructField8[FieldInUnion]
+ : 'UINT8' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructFieldBool[FieldInUnion]
+ : 'BOOLEAN' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructFieldString[FieldInUnion]
+ : 'EFI_STRING_ID' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructFieldDate[FieldInUnion]
+ : 'EFI_HII_DATE' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructFieldTime[FieldInUnion]
+ : 'EFI_HII_TIME' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructFieldRef[FieldInUnion]
+ : 'EFI_HII_REF' N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructFieldUser[FieldInUnion]
+ : T=StringIdentifier N=StringIdentifier ('[' Number ']')? ';'
+ ;
+
+dataStructBitField64[FieldInUnion]
+ : D='UINT64' N=StringIdentifier? ':' Number ';'
+ ;
+dataStructBitField32[FieldInUnion]
+ : D='UINT32' N=StringIdentifier? ':' Number ';'
+ ;
+dataStructBitField16[FieldInUnion]
+ : D='UINT16' N=StringIdentifier? ':' Number ';'
+ ;
+dataStructBitField8[FieldInUnion]
+ : D='UINT8' N=StringIdentifier? ':' Number ';'
+ ;
+
+// 2.4 VFR FormSet Definition
+vfrFormSetDefinition
+locals[Node=VfrTreeNode(EFI_IFR_FORM_SET_OP)]
+ : 'formset'
+ 'guid' '=' guidDefinition ','
+ 'title' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ('classguid' '=' classguidDefinition[localctx.Node] ',')?
+ ('class' '=' classDefinition ',')?
+ ('subclass' '=' subclassDefinition ',')?
+ vfrFormSetList[localctx.Node]
+ 'endformset' ';'
+ ;
+
+classguidDefinition[Node]
+locals[GuidList=[]]
+ : guidDefinition ('|' guidDefinition)? ('|' guidDefinition)?('|' guidDefinition)?
+ ;
+
+classDefinition
+locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)]
+ : validClassNames ('|' validClassNames)*
+ ;
+
+validClassNames
+locals[ClassName=0]
+ : ClassNonDevice
+ | ClassDiskDevice
+ | ClassVideoDevice
+ | ClassNetworkDevice
+ | ClassInputDevice
+ | ClassOnBoardDevice
+ | ClassOtherDevice
+ | Number
+ ;
+
+subclassDefinition
+locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)]
+ : SubclassSetupApplication
+ | SubclassGeneralApplication
+ | SubclassFrontPage
+ | SubclassSingleUse
+ | Number
+ ;
+
+
+vfrFormSetList[Node]
+ : (vfrFormSet)*
+ ;
+
+//2.5 VFR FormSet List Definition
+vfrFormSet
+locals[Node=None]
+ :
+ ( vfrFormDefinition
+ | vfrFormMapDefinition
+ | vfrStatementImage
+ | vfrStatementVarStoreLinear
+ | vfrStatementVarStoreEfi
+ | vfrStatementVarStoreNameValue
+ | vfrStatementDefaultStore
+ | vfrStatementDisableIfFormSet
+ | vfrStatementSuppressIfFormSet
+ | vfrStatementExtension
+ )
+ ;
+
+
+//2.6 VFR Default Stores Definition
+vfrStatementDefaultStore
+locals[Node=VfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)]
+ : 'defaultstore' N=StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' S=Number ')'
+ (',' 'attribute' '=' A=Number)? ';'
+ ;
+
+//2.7 VFR Variable Store Definition
+vfrStatementVarStoreLinear
+locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_OP)]
+ : 'varstore'
+ ( TN=StringIdentifier ','
+ | 'UINT8' ','
+ | 'UINT16' ','
+ | 'UINT32' ','
+ | 'UINT64' ','
+ | 'EFI_HII_DATE' ','
+ | 'EFI_HII_TIME' ','
+ | 'EFI_HII_REF' ','
+ )
+ ('varid' '=' ID=Number ',')?
+ 'name' '=' SN=StringIdentifier ','
+ 'guid' '=' guidDefinition ';'
+ ;
+
+vfrStatementVarStoreEfi
+locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)]
+ : 'efivarstore'
+ ( TN=StringIdentifier ','
+ | 'UINT8' ','
+ | 'UINT16' ','
+ | 'UINT32' ','
+ | 'UINT64' ','
+ | 'EFI_HII_DATE' ','
+ | 'EFI_HII_TIME' ','
+ | 'EFI_HII_REF' ','
+ )
+ ('varid' '=' ID=Number ',')?
+ 'attribute' '=' vfrVarStoreEfiAttr ('|' vfrVarStoreEfiAttr)* ','
+ ( 'name' '=' SN=StringIdentifier ','
+ | 'name' '=' 'STRING_TOKEN' '(' VN=Number ')' ',' 'varsize' '=' N=Number ','
+ )
+ 'guid' '=' guidDefinition ';'
+ ;
+
+vfrVarStoreEfiAttr
+locals[Attr=0]
+ : Number;
+
+vfrStatementVarStoreNameValue
+locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)]
+ : 'namevaluevarstore' SN=StringIdentifier ','
+ ('varid' '=' ID=Number ',')?
+ ('name' '=' 'STRING_TOKEN' '(' Number ')' ',')+
+ 'guid' '=' guidDefinition ';'
+ ;
+
+vfrStatementDisableIfFormSet
+locals[Node=VfrTreeNode(EFI_IFR_DISABLE_IF_OP)]
+ : 'disableif' vfrStatementExpression ';'
+ vfrFormSetList[localctx.Node]
+ 'endif' ';'
+ ;
+
+vfrStatementSuppressIfFormSet
+locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
+ : 'suppressif' vfrStatementExpression ';'
+ vfrFormSetList[localctx.Node]
+ 'endif' ';'
+ ;
+
+guidSubDefinition[Guid]
+ : Number ',' Number ',' Number ',' Number ','
+ Number ',' Number ',' Number ',' Number
+ ;
+
+guidDefinition
+locals[Node=VfrTreeNode(), Guid=EFI_GUID()]
+ : '{'
+ Number ',' Number ',' Number ','
+ ( '{' guidSubDefinition[localctx.Guid] '}'
+ | guidSubDefinition[localctx.Guid]
+ )
+ '}'
+ ;
+
+getStringId
+locals[StringId='']
+ : 'STRING_TOKEN' '(' Number ')'
+ ;
+
+vfrQuestionHeader[OpObj, QType]
+ : vfrQuestionBaseInfo[OpObj, QType]
+ vfrStatementHeader[OpObj]
+ ;
+
+vfrQuestionBaseInfo[OpObj, QType]
+locals[BaseInfo=EFI_VARSTORE_INFO(), QId=EFI_QUESTION_ID_INVALID, CheckFlag=True]
+ : ('name' '=' QN=StringIdentifier ',')?
+ ('varid' '=' vfrStorageVarId[localctx.BaseInfo, localctx.CheckFlag] ',')?
+ ('questionid' '=' ID=Number ',')?
+ ;
+
+vfrStatementHeader[OpObj]
+ : 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')'
+ ;
+
+questionheaderFlagsField
+locals[QHFlag=0]
+ : ReadOnlyFlag
+ | InteractiveFlag
+ | ResetRequiredFlag
+ | RestStyleFlag
+ | ReconnectRequiredFlag
+ | O=OptionOnlyFlag
+ | N=NVAccessFlag
+ | L=LateCheckFlag
+ ;
+//2.10.5
+vfrStorageVarId[BaseInfo, CheckFlag]
+locals[VarIdStr='']
+ : (SN1=StringIdentifier '[' I=Number ']') # vfrStorageVarIdRule1
+ | (SN2=StringIdentifier ('.' arrayName)* ) # vfrStorageVarIdRule2
+ ;
+
+vfrConstantValueField
+locals[Value=EFI_IFR_TYPE_VALUE(), ValueList=[], ListType=False]
+ : ('-')? Number
+ | 'TRUE'
+ | 'FALSE'
+ | 'ONE'
+ | 'ONES'
+ | 'ZERO'
+ | Number ':' Number ':' Number
+ | Number '/' Number '/' Number
+ | Number ';' Number ';' guidDefinition ';' 'STRING_TOKEN' '(' Number ')'
+ | 'STRING_TOKEN' '(' Number ')'
+ | '{' Number (',' Number)* '}'
+ ;
+
+vfrImageTag
+locals[Node=VfrTreeNode(EFI_IFR_IMAGE_OP)]
+ : 'image' '=' 'IMAGE_TOKEN' '(' Number ')'
+ ;
+
+vfrLockedTag
+locals[Node=VfrTreeNode(EFI_IFR_LOCKED_OP)]
+ : 'locked'
+ ;
+
+vfrStatementStatTag
+locals[Node]
+ : vfrImageTag | vfrLockedTag
+ ;
+
+vfrStatementStatTagList[Node]
+ : vfrStatementStatTag (',' vfrStatementStatTag)*
+ ;
+
+vfrFormDefinition
+locals[Node=VfrTreeNode(EFI_IFR_FORM_OP)]
+ : 'form' 'formid' '=' Number ','
+ 'title' '=' 'STRING_TOKEN' '(' Number ')' ';'
+ (vfrForm)*
+ 'endform' ';'
+ ;
+
+vfrForm
+locals[Node]
+ :
+ ( vfrStatementImage
+ | vfrStatementLocked
+ | vfrStatementRules
+ | vfrStatementDefault
+ | vfrStatementStat
+ | vfrStatementQuestions
+ | vfrStatementConditional
+ | vfrStatementLabel
+ | vfrStatementBanner
+ | vfrStatementInvalid
+ | vfrStatementExtension
+ | vfrStatementModal
+ | vfrStatementRefreshEvent ';'
+ )
+ ;
+
+vfrFormMapDefinition
+locals[Node=VfrTreeNode(EFI_IFR_FORM_MAP_OP)]
+ : 'formmap' 'formid' '=' S1=Number ','
+ ( 'maptitle' '=' 'STRING_TOKEN' '(' Number ')' ';'
+ 'mapguid' '=' guidDefinition ';'
+ )*
+ (vfrForm)*
+ 'endform' ';'
+ ;
+
+vfrStatementImage
+locals[Node]
+ : vfrImageTag ';'
+ ;
+
+vfrStatementLocked
+locals[Node]
+ : vfrLockedTag ';'
+ ;
+
+vfrStatementRules
+locals[Node=VfrTreeNode(EFI_IFR_RULE_OP)]
+ : 'rule' StringIdentifier ','
+ vfrStatementExpression
+ 'endrule' ';'
+ ;
+
+vfrStatementStat
+locals[Node]
+ : vfrStatementSubTitle
+ | vfrStatementStaticText
+ | vfrStatementCrossReference
+ ;
+
+vfrStatementSubTitle
+locals[Node=VfrTreeNode(EFI_IFR_SUBTITLE_OP), OpObj=CIfrSubtitle()]
+ : 'subtitle'
+
+ 'text' '=' 'STRING_TOKEN' '(' Number ')'
+ (',' 'flags' '=' vfrSubtitleFlags)?
+ ( (',' vfrStatementStatTagList[localctx.Node])? ';'
+ |
+ (',' vfrStatementStatTagList[localctx.Node])?
+ (',' (vfrStatementSubTitleComponent)* )?
+ 'endsubtitle' ';'
+ )
+ ;
+
+vfrStatementSubTitleComponent
+locals[Node]
+ : vfrStatementStat | vfrStatementQuestions
+ ;
+
+vfrSubtitleFlags
+locals[SubFlags=0]
+ : subtitleFlagsField ('|' subtitleFlagsField)*
+ ;
+subtitleFlagsField
+locals[Flag=0]
+ : Number | 'HORIZONTAL'
+ ;
+
+vfrStatementStaticText
+locals[Node=VfrTreeNode(EFI_IFR_TEXT_OP)]
+ : 'text'
+ 'help' '=' 'STRING_TOKEN' '(' S1=Number ')' ','
+ 'text' '=' 'STRING_TOKEN' '(' S2=Number ')'
+ (',' 'text' '=' 'STRING_TOKEN' '(' S3=Number ')')?
+ (',' F='flags' '=' staticTextFlagsField ('|' staticTextFlagsField)* ',' 'key' '=' S4=Number)?
+ (',' vfrStatementStatTagList[localctx.Node])? ';'
+ ;
+
+staticTextFlagsField
+locals[Flag=0]
+ : N=Number | questionheaderFlagsField
+ ;
+
+vfrStatementCrossReference
+locals[Node]
+ : vfrStatementGoto | vfrStatementResetButton
+ ;
+
+vfrStatementGoto
+locals[Node=VfrTreeNode(EFI_IFR_REF_OP), OpObj=None, OHObj=None, QType=EFI_QUESION_TYPE.QUESTION_REF]
+ : 'goto'
+ ( ( DevicePath '=' 'STRING_TOKEN' '(' Number ')' ','
+ FormSetGuid '=' guidDefinition ','
+ FormId '=' Number ','
+ Question '=' Number ','
+ )
+ |
+ ( FormSetGuid '=' guidDefinition ','
+ FormId '=' Number ','
+ Question '=' Number ','
+ )
+ |
+ ( FormId '=' Number ','
+ Question '=' (QN=StringIdentifier ',' | Number ',')
+ )
+ |
+ ( Number ',' )
+ )?
+ vfrQuestionHeader[localctx.OpObj, localctx.QType]
+ (',' 'flags' '=' vfrGotoFlags[localctx.OpObj])?
+ (',' 'key' '=' Number)?
+ (',' vfrStatementQuestionOptionList[localctx.Node])? ';'
+ ;
+
+vfrGotoFlags[Obj]
+locals[GotoFlags=0]
+ : gotoFlagsField('|' gotoFlagsField)*
+ ;
+
+gotoFlagsField
+locals[Flag=0]
+ : N=Number | questionheaderFlagsField
+ ;
+
+vfrStatementResetButton
+locals[Node=VfrTreeNode(EFI_IFR_RESET_BUTTON_OP), OpObj=CIfrResetButton()]
+ : 'resetbutton'
+ 'defaultstore' '=' N=StringIdentifier ','
+ vfrStatementHeader[localctx.OpObj] ','
+ (vfrStatementStatTagList[localctx.Node] ',')?
+ 'endresetbutton' ';'
+ ;
+
+vfrStatementQuestions
+locals[Node]
+ : vfrStatementBooleanType
+ | vfrStatementDate
+ | vfrStatementNumericType
+ | vfrStatementStringType
+ | vfrStatementOrderedList
+ | vfrStatementTime
+ ;
+
+vfrStatementQuestionTag
+locals[Node]
+ : vfrStatementStatTag ','
+ | vfrStatementInconsistentIf
+ | vfrStatementNoSubmitIf
+ | vfrStatementDisableIfQuest
+ | vfrStatementRefresh
+ | vfrStatementVarstoreDevice
+ | vfrStatementExtension
+ | vfrStatementRefreshEvent
+ | vfrStatementWarningIf
+ ;
+
+vfrStatementInconsistentIf
+locals[Node=VfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)]
+ : 'inconsistentif'
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression
+ 'endif' (';')?
+ ;
+
+vfrStatementNoSubmitIf
+locals[Node=VfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)]
+ : 'nosubmitif'
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression
+ 'endif' (';')?
+ ;
+
+vfrStatementDisableIfQuest
+locals[Node=VfrTreeNode(EFI_IFR_DISABLE_IF_OP)]
+ : 'disableif' vfrStatementExpression ';'
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endif' (';')?
+ ;
+
+vfrStatementRefresh
+locals[Node=VfrTreeNode(EFI_IFR_REFRESH_OP)]
+ : 'refresh' 'interval' '=' Number
+ ;
+
+vfrStatementVarstoreDevice
+locals[Node=VfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)]
+ : 'varstoredevice' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ;
+
+vfrStatementRefreshEvent
+locals[Node=VfrTreeNode(EFI_IFR_REFRESH_ID_OP)]
+ : 'refreshguid' '=' guidDefinition ','
+ ;
+
+vfrStatementWarningIf
+locals[Node=VfrTreeNode(EFI_IFR_WARNING_IF_OP)]
+ : 'warningif'
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ('timeout' '=' Number ',')?
+ vfrStatementExpression
+ 'endif' (';')?
+ ;
+
+vfrStatementQuestionTagList[Node]
+ : (vfrStatementQuestionTag)*
+ ;
+
+vfrStatementQuestionOptionTag
+locals[Node]
+ : vfrStatementSuppressIfQuest
+ | vfrStatementGrayOutIfQuest
+ | vfrStatementValue
+ | vfrStatementDefault
+ | vfrStatementOptions
+ | vfrStatementRead
+ | vfrStatementWrite
+ ;
+
+flagsField
+ : Number
+ | InteractiveFlag
+ | ManufacturingFlag
+ | DefaultFlag
+ | ResetRequiredFlag
+ | ReconnectRequiredFlag
+ | N=NVAccessFlag
+ | L=LateCheckFlag
+ ;
+
+vfrStatementSuppressIfQuest
+locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
+ : 'suppressif' vfrStatementExpression ';'
+ ('flags' '=' flagsField ('|' flagsField )* ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endif' (';')?
+ ;
+
+vfrStatementGrayOutIfQuest
+locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
+ : 'grayoutif' vfrStatementExpression ';'
+ ('flags' '=' flagsField ('|' flagsField )* ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endif' (';')?
+ ;
+
+
+vfrStatementDefault
+locals[Node=VfrTreeNode(EFI_IFR_DEFAULT_OP)]
+ : D='default'
+ ( ( vfrStatementValue ','
+ | '=' vfrConstantValueField ','
+ )
+ ( 'defaultstore' '=' SN=StringIdentifier ','
+ )?
+ )
+ ;
+
+vfrStatementValue
+locals[Node=VfrTreeNode(EFI_IFR_VALUE_OP)]
+ : 'value' '=' vfrStatementExpression
+ ;
+
+vfrStatementOptions
+locals[Node]
+ : vfrStatementOneOfOption
+ ;
+
+vfrStatementOneOfOption
+locals[Node=VfrTreeNode(EFI_IFR_ONE_OF_OPTION_OP)]
+ : 'option'
+ 'text' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'value' '=' vfrConstantValueField ','
+ F='flags' '=' vfrOneOfOptionFlags (',' 'key' '=' KN=Number) ? (',' vfrImageTag)* ';'
+ ;
+
+vfrOneOfOptionFlags
+locals[HFlags=0, LFlags=0]
+ : oneofoptionFlagsField ('|' oneofoptionFlagsField)*;
+
+oneofoptionFlagsField
+ locals[HFlag=0, LFlag=0]
+ : Number
+ | OptionDefault
+ | OptionDefaultMfg
+ | InteractiveFlag
+ | ResetRequiredFlag
+ | RestStyleFlag
+ | ReconnectRequiredFlag
+ | ManufacturingFlag
+ | DefaultFlag
+ | A=NVAccessFlag
+ | L=LateCheckFlag
+ ;
+
+vfrStatementRead
+locals[Node=VfrTreeNode(EFI_IFR_READ_OP)]
+ : 'read' vfrStatementExpression ';'
+ ;
+
+vfrStatementWrite
+locals[Node=VfrTreeNode(EFI_IFR_WRITE_OP)]
+ : 'write' vfrStatementExpression ';'
+ ;
+
+vfrStatementQuestionOptionList[Node]
+ : (vfrStatementQuestionOption)*
+ ;
+
+
+
+vfrStatementQuestionOption
+locals[Node]
+ : vfrStatementQuestionTag | vfrStatementQuestionOptionTag
+ ;
+
+vfrStatementBooleanType
+locals[Node]
+ : vfrStatementCheckBox | vfrStatementAction
+ ;
+
+vfrStatementCheckBox
+locals[Node=VfrTreeNode(EFI_IFR_CHECKBOX_OP), OpObj=CIfrCheckBox(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : L='checkbox'
+ vfrQuestionBaseInfo[localctx.OpObj, localctx.QType]
+ vfrStatementHeader[localctx.OpObj] ','
+ (F='flags' '=' vfrCheckBoxFlags ',')?
+ ('key' '=' Number ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endcheckbox' ';'
+ ;
+
+vfrCheckBoxFlags
+locals[LFlags=0, HFlags=0]
+ : checkboxFlagsField ('|' checkboxFlagsField)*
+ ;
+
+checkboxFlagsField
+locals[LFlag=0, HFlag=0]
+ : Number
+ | D='DEFAULT'
+ | M='MANUFACTURING'
+ | 'CHECKBOX_DEFAULT'
+ | 'CHECKBOX_DEFAULT_MFG'
+ | questionheaderFlagsField
+ ;
+
+vfrStatementAction
+locals[Node=VfrTreeNode(EFI_IFR_ACTION_OP),OpObj=CIfrAction(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : 'action'
+ vfrQuestionHeader[localctx.OpObj, localctx.QType] ','
+ ('flags' '=' vfrActionFlags ',')?
+ 'config' '=' 'STRING_TOKEN' '(' Number ')' ','
+ vfrStatementQuestionTagList[localctx.Node]
+ 'endaction' ';'
+ ;
+
+vfrActionFlags
+locals[HFlags=0]
+ : actionFlagsField ('|' actionFlagsField)*
+ ;
+actionFlagsField
+locals[HFlag=0]
+ : N=Number | questionheaderFlagsField
+ ;
+
+vfrStatementNumericType
+locals[Node]
+ : vfrStatementNumeric | vfrStatementOneOf
+ ;
+
+vfrStatementNumeric
+locals[Node=VfrTreeNode(EFI_IFR_NUMERIC_OP), OpObj=CIfrNumeric(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : 'numeric'
+ vfrQuestionBaseInfo[localctx.OpObj, localctx.QType]
+ vfrStatementHeader[localctx.OpObj] ','
+ (F='flags' '=' vfrNumericFlags ',')?
+ ('key' '=' Number ',')?
+ vfrSetMinMaxStep[localctx.OpObj]
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endnumeric' ';'
+ ;
+
+vfrSetMinMaxStep[OpObj] // CIfrMinMaxStepData
+ : 'minimum' '=' (N1='-')? I=Number ','
+ 'maximum' '=' (N2='-')? A=Number ','
+ ('step' '=' S=Number ',')?
+ ;
+
+vfrNumericFlags
+locals[HFlags=0, LFlags=0,IsDisplaySpecified=False]
+ : numericFlagsField ('|' numericFlagsField)*
+ ;
+
+numericFlagsField
+locals[HFlag=0,IsSetType=False,IsDisplaySpecified=False]
+ : N=Number
+ | 'NUMERIC_SIZE_1'
+ | 'NUMERIC_SIZE_2'
+ | 'NUMERIC_SIZE_4'
+ | 'NUMERIC_SIZE_8'
+ | 'DISPLAY_INT_DEC'
+ | 'DISPLAY_UINT_DEC'
+ | 'DISPLAY_UINT_HEX'
+ | questionheaderFlagsField
+ ;
+
+vfrStatementOneOf
+locals[Node=VfrTreeNode(EFI_IFR_ONE_OF_OP), OpObj=CIfrOneOf(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : 'oneof'
+ vfrQuestionBaseInfo[localctx.OpObj, localctx.QType]
+ vfrStatementHeader[localctx.OpObj] ','
+ (F='flags' '=' vfrOneofFlagsField ',')?
+ (vfrSetMinMaxStep[localctx.OpObj])?
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endoneof' ';'
+ ;
+
+vfrOneofFlagsField
+locals[HFlags=0, LFlags=0]
+ : numericFlagsField ('|' numericFlagsField)*
+ ;
+
+vfrStatementStringType
+locals[Node]
+ : vfrStatementString | vfrStatementPassword
+ ;
+
+vfrStatementString
+locals[Node=VfrTreeNode(EFI_IFR_STRING_OP), OpObj=CIfrString(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : 'string'
+ vfrQuestionHeader[localctx.OpObj, localctx.QType] ','
+ (F='flags' '=' vfrStringFlagsField ',')?
+ ('key' '=' Number ',')?
+ Min='minsize' '=' Number ','
+ Max='maxsize' '=' Number ','
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endstring' ';'
+ ;
+
+vfrStringFlagsField
+locals[HFlags=0, LFlags=0]
+ : stringFlagsField ('|' stringFlagsField)*
+ ;
+
+stringFlagsField
+locals[HFlag=0, LFlag=0]
+ : N=Number
+ | 'MULTI_LINE'
+ | questionheaderFlagsField
+ ;
+
+vfrStatementPassword
+locals[Node=VfrTreeNode(EFI_IFR_PASSWORD_OP), OpObj=CIfrPassword(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : 'password'
+ vfrQuestionHeader[localctx.OpObj, localctx.QType]','
+ (F='flags' '=' vfrPasswordFlagsField ',')?
+ ('key' '=' Number ',')?
+ Min='minsize' '=' Number ','
+ Max='maxsize' '=' Number ','
+ ('encoding' '=' Number ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endpassword' ';'
+ ;
+
+vfrPasswordFlagsField
+locals[HFlags=0]
+ : passwordFlagsField('|' passwordFlagsField)*
+ ;
+
+passwordFlagsField
+locals[HFlag=0]
+ : Number
+ | questionheaderFlagsField
+ ;
+
+vfrStatementOrderedList
+locals[Node=VfrTreeNode(EFI_IFR_ORDERED_LIST_OP), OpObj=CIfrOrderedList(), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
+ : 'orderedlist'
+ vfrQuestionHeader[localctx.OpObj, localctx.QType] ','
+ (M='maxcontainers' '=' Number ',')?
+ (F='flags' '=' vfrOrderedListFlags ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ 'endlist' ';'
+ ;
+
+vfrOrderedListFlags
+locals[HFlags=0, LFlags=0]
+ : orderedlistFlagsField ('|' orderedlistFlagsField)*
+ ;
+
+orderedlistFlagsField
+locals[HFlag=0, LFlag=0]
+ : Number
+ | 'UNIQUE'
+ | 'NOEMPTY'
+ | questionheaderFlagsField
+ ;
+
+vfrStatementDate
+locals[Node=VfrTreeNode(EFI_IFR_DATE_OP), OpObj=CIfrDate(), QType=EFI_QUESION_TYPE.QUESTION_DATE, Val=EFI_IFR_TYPE_VALUE()]
+ : 'date'
+ ( ( vfrQuestionHeader[localctx.OpObj, localctx.QType] ','
+ (F1='flags' '=' vfrDateFlags ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ )
+ |
+ ( 'year' 'varid' '=' StringIdentifier '.' StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ minMaxDateStepDefault[localctx.Val.date, 0]
+ 'month' 'varid' '=' StringIdentifier '.' StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ minMaxDateStepDefault[localctx.Val.date, 1]
+ 'day' 'varid' '=' StringIdentifier '.' StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ minMaxDateStepDefault[localctx.Val.date, 2]
+ (F2='flags' '=' vfrDateFlags ',')?
+ (vfrStatementInconsistentIf)*
+ )
+ )
+ 'enddate' ';'
+ ;
+
+minMaxDateStepDefault[Date, KeyValue]
+ : 'minimum' '=' Number ','
+ 'maximum' '=' Number ','
+ ('step' '=' Number ',')?
+ ('default' '=' N=Number ',')?
+ ;
+
+vfrDateFlags
+locals[LFlags=0]
+ : dateFlagsField ('|' dateFlagsField)*
+ ;
+dateFlagsField
+locals[LFlag=0]
+ : Number
+ | 'YEAR_SUPPRESS'
+ | 'MONTH_SUPPRESS'
+ | 'DAY_SUPPRESS'
+ | 'STORAGE_NORMAL'
+ | 'STORAGE_TIME'
+ | 'STORAGE_WAKEUP'
+ ;
+
+vfrStatementTime
+locals[Node=VfrTreeNode(EFI_IFR_TIME_OP), OpObj=CIfrTime(), QType=EFI_QUESION_TYPE.QUESTION_TIME, Val=EFI_IFR_TYPE_VALUE()]
+ : 'time'
+ ( ( vfrQuestionHeader[localctx.OpObj, localctx.QType] ','
+ (F1='flags' '=' vfrTimeFlags ',')?
+ vfrStatementQuestionOptionList[localctx.Node]
+ )
+ |
+ (
+ 'hour' 'varid' '=' StringIdentifier '.' StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ minMaxTimeStepDefault[localctx.Val.time, 0]
+ 'minute' 'varid' '=' StringIdentifier '.' StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ minMaxTimeStepDefault[localctx.Val.time, 1]
+ 'second' 'varid' '=' StringIdentifier '.' StringIdentifier ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ minMaxTimeStepDefault[localctx.Val.time, 2]
+ (F2='flags' '=' vfrTimeFlags ',')?
+ (vfrStatementInconsistentIf)*
+ )
+ )
+ 'endtime' ';'
+ ;
+
+minMaxTimeStepDefault[Time, KeyValue]
+ : 'minimum' '=' Number ','
+ 'maximum' '=' Number ','
+ ('step' '=' Number ',')?
+ ('default' '=' N=Number ',')?
+ ;
+
+vfrTimeFlags
+locals[LFlags=0]
+ : timeFlagsField ('|' timeFlagsField)*
+ ;
+
+timeFlagsField
+locals[LFlag=0]
+ : Number
+ | 'HOUR_SUPPRESS'
+ | 'MINUTE_SUPPRESS'
+ | 'SECOND_SUPPRESS'
+ | 'STORAGE_NORMAL'
+ | 'STORAGE_TIME'
+ | 'STORAGE_WAKEUP'
+ ;
+
+vfrStatementConditional
+locals[Node]
+ : vfrStatementDisableIfStat
+ | vfrStatementSuppressIfStat //enhance to be compatible for framework endif
+ | vfrStatementGrayOutIfStat
+ | vfrStatementInconsistentIfStat //to be compatible for framework
+ ;
+
+// new seems to be the same as the old, why new?
+vfrStatementConditionalNew
+locals[Node]
+ : vfrStatementDisableIfStat
+ vfrStatementSuppressIfStatNew
+ vfrStatementGrayOutIfStatNew
+ vfrStatementInconsistentIfStat //to be compatible for framework
+ ;
+
+vfrStatementSuppressIfStat
+locals[Node]
+ : vfrStatementSuppressIfStatNew
+ ;
+
+vfrStatementGrayOutIfStat
+locals[Node]
+ : vfrStatementGrayOutIfStatNew
+ ;
+
+vfrStatementStatList
+locals[Node]
+ : vfrStatementStat
+ | vfrStatementQuestions
+ | vfrStatementConditional
+ | vfrStatementLabel
+ | vfrStatementExtension
+ | vfrStatementInvalid
+ ;
+
+vfrStatementStatListOld
+ : vfrStatementStat
+ | vfrStatementQuestions
+ | vfrStatementLabel
+ // Just for framework vfr compatibility
+ | vfrStatementInvalid
+ ;
+
+vfrStatementDisableIfStat
+locals[Node=VfrTreeNode(EFI_IFR_DISABLE_IF_OP)]
+ : 'disableif' vfrStatementExpression ';'
+ (vfrStatementStatList)*
+ 'endif' ';'
+ ;
+
+
+// Compatible for framework vfr file
+//
+vfrStatementgrayoutIfSuppressIf
+ : 'suppressif'
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression ';'
+ ;
+
+vfrStatementsuppressIfGrayOutIf
+ : 'grayoutif'
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression ';'
+ ;
+
+vfrStatementSuppressIfStatNew
+locals[Node=VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
+ : 'suppressif'
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression ';'
+ (vfrStatementStatList)*
+ 'endif' ';'
+ ;
+
+vfrStatementGrayOutIfStatNew
+locals[Node=VfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)]
+ : 'grayoutif'
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression ';'
+ (vfrStatementStatList)*
+ 'endif' ';'
+ ;
+
+vfrStatementInconsistentIfStat
+locals[Node=VfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)]
+ : 'inconsistentif'
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ('flags' '=' flagsField ('|' flagsField)* ',')?
+ vfrStatementExpression
+ 'endif' ';'
+ ;
+
+vfrStatementInvalid // for compatibility
+ : vfrStatementInvalidHidden
+ | vfrStatementInvalidInventory
+ | vfrStatementInvalidSaveRestoreDefaults
+ ;
+
+vfrStatementInvalidHidden
+ : 'hidden'
+ 'value' '=' Number ','
+ 'key' '=' Number ';'
+ ;
+
+vfrStatementInvalidInventory
+ : 'inventory'
+ 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'text' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ('text' '=' 'STRING_TOKEN' '(' Number ')')?
+ ';'
+ ;
+
+vfrStatementInvalidSaveRestoreDefaults
+ : ( 'save'
+ | 'restore'
+ )
+ 'defaults' ','
+ 'formid' '=' Number ','
+ 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
+ 'help' '=' 'STRING_TOKEN' '(' Number ')'
+ (',' 'flags' '=' flagsField ('|' flagsField)*)?
+ (',' 'key' '=' Number)?
+ ';'
+ ;
+vfrStatementLabel
+locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)]
+ : 'label' Number ';'
+ ;
+
+vfrStatementBanner // Is TimeOut needed
+locals[Node=VfrTreeNode(EFI_IFR_GUID_OP)]
+ : 'banner' (',')?
+ 'title' '=' 'STRING_TOKEN' '(' Number ')' ','
+ ( ( 'line' Number ','
+ 'align' ('left' | 'center' | 'right') ';'
+ )
+ |
+ ( 'timeout' '=' Number ';'
+ )
+ )
+ ;
+
+vfrStatementExtension
+locals[Node=VfrTreeNode(EFI_IFR_GUID_OP), DataBuff, Size=0, TypeName='', TypeSize=0, IsStruct=False, ArrayNum=0]
+ : 'guidop'
+ 'guid' '=' guidDefinition
+ ( ',' D='datatype' '='
+ ( 'UINT64' ('[' Number ']')?
+ | 'UINT32' ('[' Number ']')?
+ | 'UINT16' ('[' Number ']')?
+ | 'UINT8' ('[' Number ']')?
+ | 'BOOLEAN' ('[' Number ']')?
+ | 'EFI_STRING_ID' ('[' Number ']')?
+ | 'EFI_HII_DATE' ('[' Number ']')?
+ | 'EFI_HII_TIME' ('[' Number ']')?
+ | 'EFI_HII_REF' ('[' Number ']')?
+ | StringIdentifier ('[' Number ']')?
+ )
+ (vfrExtensionData[localctx.DataBuff])*
+ )?
+ (
+ ',' (vfrStatementExtension)*
+ 'endguidop'
+ )?
+ ';'
+ ;
+
+
+vfrExtensionData[DataBuff]
+locals[IsStruct]
+ : ',' 'data' ('[' Number ']')?
+ ( '.' arrayName)* '=' N=Number
+ ;
+
+
+vfrStatementModal
+locals[Node]
+ : vfrModalTag ';'
+ ;
+
+vfrModalTag
+locals[Node=VfrTreeNode(EFI_IFR_MODAL_TAG_OP)]
+ : 'modal'
+ ;
+
+vfrStatementExpression
+locals[ExpInfo=ExpressionInfo()]
+ : andTerm[localctx.ExpInfo] ('OR' andTerm[localctx.ExpInfo])*
+ ;
+
+vfrStatementExpressionSub
+locals[ExpInfo=ExpressionInfo()]
+ : andTerm[localctx.ExpInfo] ('OR' andTerm[localctx.ExpInfo])*
+ ;
+
+andTerm[ExpInfo]
+locals[CIfrAndList=[]]
+ : bitwiseorTerm[ExpInfo] ('AND' bitwiseorTerm[ExpInfo])*
+ ;
+
+bitwiseorTerm[ExpInfo]
+locals[CIfrBitWiseOrList=[]]
+ : bitwiseandTerm[ExpInfo] ('|' bitwiseandTerm[ExpInfo])*
+ ;
+
+
+bitwiseandTerm[ExpInfo]
+locals[CIfrBitWiseAndList=[]]
+ : equalTerm[ExpInfo] ('&' equalTerm[ExpInfo])*
+ ;
+
+
+equalTerm[ExpInfo]
+locals[CIfrEqualList=[], CIfrNotEqualList=[]]
+ : compareTerm[localctx.ExpInfo]
+ (equalTermSupplementary[localctx.CIfrEqualList, localctx.CIfrNotEqualList, ExpInfo])*
+ ;
+
+
+equalTermSupplementary[CIfrEqualList, CIfrNotEqualList, ExpInfo]
+ : ('==' compareTerm[ExpInfo]) # equalTermEqualRule
+ |
+ ('!=' compareTerm[ExpInfo]) # equalTermNotEqualRule
+ ;
+
+compareTerm[ExpInfo]
+locals[CIfrLessThanList=[], CIfrLessEqualList=[], CIfrGreaterThanList=[], CIfrGreaterEqualList=[]]
+ : shiftTerm[ExpInfo]
+ (compareTermSupplementary[localctx.CIfrLessThanList, localctx.CIfrLessEqualList, localctx.CIfrGreaterThanList, localctx.CIfrGreaterEqualList, ExpInfo])*
+ ;
+
+compareTermSupplementary[CIfrLessThanList, CIfrLessEqualList, CIfrGreaterThanList, CIfrGreaterEqualList, ExpInfo]
+ : ('<' shiftTerm[ExpInfo]) # compareTermLessRule
+ |
+ ('<=' shiftTerm[ExpInfo]) # compareTermLessEqualRule
+ |
+ ('>' shiftTerm[ExpInfo]) # compareTermGreaterRule
+ |
+ ('>=' shiftTerm[ExpInfo]) # compareTermGreaterEqualRule
+ ;
+
+shiftTerm[ExpInfo]
+locals[CIfrShiftLeftList=[], CIfrShiftRightList=[]]
+ : addMinusTerm[ExpInfo]
+ (shiftTermSupplementary[localctx.CIfrShiftLeftList, localctx.CIfrShiftRightList, ExpInfo])*
+ ;
+
+shiftTermSupplementary[CIfrShiftLeftList, CIfrShiftRightList, ExpInfo]
+ : ('<<' addMinusTerm[ExpInfo]) # shiftTermLeft
+ |
+ ('>>' addMinusTerm[ExpInfo]) # shiftTermRight
+ ;
+
+addMinusTerm[ExpInfo]
+locals[CIfrAddList=[], CIfrSubtractList=[]]
+ : multdivmodTerm[ExpInfo]
+ (addMinusTermSupplementary[localctx.CIfrAddList, localctx.CIfrSubtractList, ExpInfo])*
+ ;
+
+addMinusTermSupplementary[CIfrAddList, CIfrSubtractList, ExpInfo]
+ : ('+' multdivmodTerm[ExpInfo]) # addMinusTermpAdd
+ |
+ ('-' multdivmodTerm[ExpInfo]) # addMinusTermSubtract
+ ;
+
+multdivmodTerm[ExpInfo]
+locals[CIfrMultiplyList=[], CIfrDivideList=[], CIfrModuloList=[]]
+ : castTerm[ExpInfo]
+ (multdivmodTermSupplementary[localctx.CIfrMultiplyList, localctx.CIfrDivideList, localctx.CIfrModuloList, ExpInfo])*
+ ;
+
+multdivmodTermSupplementary[CIfrMultiplyList, CIfrDivideList, CIfrModuloList, ExpInfo]
+ : ('*' castTerm[ExpInfo]) # multdivmodTermMul
+ |
+ ('/' castTerm[ExpInfo]) # multdivmodTermDiv
+ |
+ ('%' castTerm[ExpInfo]) # multdivmodTermModulo
+ ;
+
+castTerm[ExpInfo]
+locals[TBObj=None, TUObj=None]
+ : ( '('
+ ( 'BOOLEAN'
+ | 'UINT64'
+ | 'UINT32'
+ | 'UINT16'
+ | 'UINT8'
+ )
+ ')'
+ )*
+ atomTerm[ExpInfo]
+ ;
+
+atomTerm[ExpInfo]
+ : vfrExpressionCatenate[ExpInfo]
+ | vfrExpressionMatch[ExpInfo]
+ | vfrExpressionMatch2[ExpInfo]
+ | vfrExpressionParen[ExpInfo]
+ | vfrExpressionBuildInFunction[ExpInfo]
+ | vfrExpressionConstant[ExpInfo]
+ | vfrExpressionUnaryOp[ExpInfo]
+ | vfrExpressionTernaryOp[ExpInfo]
+ | vfrExpressionMap[ExpInfo]
+ | ('NOT' atomTerm[ExpInfo])
+ | vfrExpressionMatch2[ExpInfo]
+ ;
+
+vfrExpressionCatenate[ExpInfo]
+locals[CObj=None]
+ : 'catenate'
+ '(' vfrStatementExpressionSub ',' vfrStatementExpressionSub ')'
+ ;
+
+vfrExpressionMatch[ExpInfo]
+locals[MObj=None]
+ : 'match'
+ '(' vfrStatementExpressionSub ',' vfrStatementExpressionSub ')'
+ ;
+
+vfrExpressionMatch2[ExpInfo]
+locals[M2Obj=None]
+ : 'match2'
+ '(' vfrStatementExpressionSub','
+ vfrStatementExpressionSub ','
+ guidDefinition ')'
+ ;
+
+vfrExpressionParen[ExpInfo]
+ : '(' vfrStatementExpressionSub ')'
+ ;
+
+vfrExpressionBuildInFunction[ExpInfo]
+ : dupExp[ExpInfo]
+ | vareqvalExp[ExpInfo]
+ | ideqvalExp[ExpInfo]
+ | ideqidExp[ExpInfo]
+ | ideqvallistExp[ExpInfo]
+ | questionref1Exp[ExpInfo]
+ | rulerefExp[ExpInfo]
+ | stringref1Exp[ExpInfo]
+ | pushthisExp[ExpInfo]
+ | securityExp[ExpInfo]
+ | getExp[ExpInfo]
+ ;
+
+dupExp[ExpInfo]
+locals[DObj=None]
+ : 'dup'
+ ;
+
+
+vareqvalExp[ExpInfo]
+ : 'vareqval'
+ 'var' '(' Number ')'
+ ( '==' Number
+ | '<=' Number
+ | '<' Number
+ | '>=' Number
+ | '>' Number
+ )
+ ;
+
+ideqvalExp[ExpInfo]
+ : I='ideqval' vfrQuestionDataFieldName
+ ( '==' Number
+ | '<=' Number
+ | '<' Number
+ | '>=' Number
+ | '>' Number
+ )
+ ;
+
+ideqidExp[ExpInfo]
+ : I='ideqid' vfrQuestionDataFieldName
+ ( E='==' vfrQuestionDataFieldName
+ | LE='<=' vfrQuestionDataFieldName
+ | L='<' vfrQuestionDataFieldName
+ | BE='>=' vfrQuestionDataFieldName
+ | B='>' vfrQuestionDataFieldName
+ )
+ ;
+
+ideqvallistExp[ExpInfo]
+ : 'ideqvallist' vfrQuestionDataFieldName '==' (Number)+
+ ;
+
+vfrQuestionDataFieldName
+locals[QId=EFI_QUESTION_ID_INVALID, Mask=0, VarIdStr='', Line=None]
+ : (SN1=StringIdentifier '[' I=Number ']') # vfrQuestionDataFieldNameRule1
+ | (SN2=StringIdentifier ('.' arrayName)*) # vfrQuestionDataFieldNameRule2
+ ;
+
+arrayName
+locals[SubStr='', SubStrZ='']
+ : StringIdentifier ('[' N=Number ']')?
+ ;
+
+questionref1Exp[ExpInfo]
+ : 'questionref'
+ '(' ( StringIdentifier | Number ) ')'
+ ;
+
+rulerefExp[ExpInfo]
+ : 'ruleref' '(' StringIdentifier ')'
+ ;
+
+stringref1Exp[ExpInfo]
+ : 'stringref' '('
+ (
+ 'STRING_TOKEN' '(' Number ')'
+ | Number
+ )
+
+
+ ')'
+ ;
+
+pushthisExp[ExpInfo]
+ : 'pushthis'
+ ;
+
+securityExp[ExpInfo]
+ : 'security' '(' guidDefinition ')'
+ ;
+
+numericVarStoreType
+locals[VarType]
+ : 'NUMERIC_SIZE_1'
+ | 'NUMERIC_SIZE_2'
+ | 'NUMERIC_SIZE_4'
+ | 'NUMERIC_SIZE_8'
+ ;
+
+getExp[ExpInfo]
+locals[BaseInfo=EFI_VARSTORE_INFO(), GObj=None]
+ : 'get' '(' vfrStorageVarId[localctx.BaseInfo, False]('|' 'flags' '=' numericVarStoreType)? ')'
+ ;
+
+vfrExpressionConstant[ExpInfo]
+ : 'TRUE'
+ | 'FALSE'
+ | 'ONE'
+ | 'ONES'
+ | 'ZERO'
+ | 'UNDEFINED'
+ | 'VERSION'
+ | Number
+ ;
+
+vfrExpressionUnaryOp[ExpInfo]
+ : lengthExp[ExpInfo]
+ | bitwisenotExp[ExpInfo]
+ | question23refExp[ExpInfo]
+ | stringref2Exp[ExpInfo]
+ | toboolExp[ExpInfo]
+ | tostringExp[ExpInfo]
+ | unintExp[ExpInfo]
+ | toupperExp[ExpInfo]
+ | tolwerExp[ExpInfo]
+ | setExp[ExpInfo]
+ ;
+
+lengthExp[ExpInfo]
+locals[LObj=None]
+ : 'length' '(' vfrStatementExpressionSub ')'
+ ;
+
+bitwisenotExp[ExpInfo]
+locals[BWNObj=None]
+ : '~' '(' vfrStatementExpressionSub ')'
+ ;
+
+question23refExp[ExpInfo]
+ : 'questionrefval'
+ '('
+ (DevicePath '=' 'STRING_TOKEN' '(' Number ')' ',' )?
+ (Uuid '=' guidDefinition ',' )?
+ vfrStatementExpressionSub
+ ')'
+ ;
+
+stringref2Exp[ExpInfo]
+locals[SR2Obj=None]
+ : 'stringrefval' '(' vfrStatementExpressionSub ')'
+ ;
+
+toboolExp[ExpInfo]
+locals[TBObj=None]
+ : 'boolval' '(' vfrStatementExpressionSub ')'
+ ;
+
+tostringExp[ExpInfo]
+locals[TSObj=None]
+ : 'stringval' ('format' '=' Number ',' )?
+ '(' vfrStatementExpressionSub ')'
+ ;
+
+unintExp[ExpInfo]
+locals[TUObj=None]
+ : 'unintval' '(' vfrStatementExpressionSub ')'
+ ;
+
+toupperExp[ExpInfo]
+locals[TUObj=None]
+ : 'toupper' '(' vfrStatementExpressionSub ')'
+ ;
+
+tolwerExp[ExpInfo]
+locals[TLObj=None]
+ : 'tolower' '(' vfrStatementExpressionSub ')'
+ ;
+
+setExp[ExpInfo]
+locals[BaseInfo=EFI_VARSTORE_INFO(), TSObj=None]
+ : 'set'
+ '('
+ vfrStorageVarId[localctx.BaseInfo, False]('|' 'flags' '=' numericVarStoreType)? ','
+ vfrStatementExpressionSub
+ ')'
+ ;
+
+vfrExpressionTernaryOp[ExpInfo]
+ : conditionalExp[ExpInfo]
+ | findExp[ExpInfo]
+ | midExp[ExpInfo]
+ | tokenExp[ExpInfo]
+ | spanExp[ExpInfo]
+ ;
+
+conditionalExp[ExpInfo]
+locals[CObj=None]
+ : 'cond'
+ '('
+ vfrStatementExpressionSub //
+ '?'
+ vfrStatementExpressionSub //
+ ':'
+ vfrStatementExpressionSub //
+ ')'
+ ;
+
+findExp[ExpInfo]
+locals[FObj=None]
+ : 'find'
+ '('
+ findFormat[ExpInfo] ('|' findFormat[ExpInfo])*
+ ','
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ')'
+ ;
+
+findFormat[ExpInfo]
+locals[Format=0]
+ : 'SENSITIVE' | 'INSENSITIVE'
+ ;
+
+midExp[ExpInfo]
+locals[MObj=None]
+ : 'mid'
+ '('
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ')'
+ ;
+
+tokenExp[ExpInfo]
+locals[TObj=None]
+ : 'token'
+ '('
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ')'
+ ;
+
+spanExp[ExpInfo]
+locals[SObj=None]
+ : 'span'
+ '('
+ 'flags' '=' spanFlags ('|' spanFlags)*
+ ','
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ','
+ vfrStatementExpressionSub
+ ')'
+ ;
+
+spanFlags
+locals[Flag=0]
+ : Number
+ | 'LAST_NON_MATCH'
+ | 'FIRST_NON_MATCH'
+ ;
+
+vfrExpressionMap[ExpInfo]
+locals[MObj=None]
+ : 'map'
+ '('
+ vfrStatementExpressionSub
+ ':'
+ ( vfrStatementExpression
+ ','
+ vfrStatementExpression
+ ';'
+ )*
+ ')'
+ ;
+
+
+Define :'#define';
+Include : '#include';
+FormPkgType : 'formpkgtype';
+OpenBrace : '{';
+CloseBrace : '}';
+OpenParen : '(';
+CloseParen : ')';
+OpenBracket : '[';
+CloseBracket : ']';
+Dot : '.';
+Negative : '-';
+Colon : ':';
+Slash : '/';
+Semicolon : ';';
+Comma : ',';
+Equal : '==';
+NotEqual : '!=';
+LessEqual: '<=';
+Less:'<';
+GreaterEqual:'>=';
+Greater:'>';
+BitWiseOr: '|';
+BitWiseAnd: '&';
+
+DevicePath : 'devicepath';
+FormSet : 'formset';
+FormSetId : 'formsetid';
+EndFormSet : 'endformset';
+Title : 'title';
+FormId : 'formid';
+OneOf : 'oneof';
+EndOneOf : 'endoneof';
+Prompt : 'prompt';
+OrderedList : 'orderedlist';
+MaxContainers : 'maxcontainers';
+EndList : 'endlist';
+EndForm : 'endform';
+Form : 'form';
+FormMap : 'formmap';
+MapTitle : 'maptitle';
+MapGuid : 'mapguid';
+Subtitle : 'subtitle';
+EndSubtitle : 'endsubtitle';
+Help : 'help';
+Text : 'text';
+Option : 'option';
+FLAGS : 'flags';
+Date : 'date';
+EndDate : 'enddate';
+Year : 'year';
+Month : 'month';
+Day : 'day';
+Time : 'time';
+EndTime : 'endtime';
+Hour : 'hour';
+Minute : 'minute';
+Second : 'second';
+GrayOutIf : 'grayoutif';
+Label : 'label';
+Timeout : 'timeout';
+Inventory : 'inventory';
+NonNvDataMap : '_NON_NV_DATA_MAP';
+Struct : 'struct';
+Union : 'union';
+Boolean : 'BOOLEAN';
+Uint64 : 'UINT64';
+Uint32 : 'UINT32';
+Uint16 : 'UINT16';
+Uint8 :'UINT8';
+EFI_STRING_ID :'EFI_STRING_ID';
+EFI_HII_DATE : 'EFI_HII_DATE';
+EFI_HII_TIME : 'EFI_HII_TIME';
+EFI_HII_REF : 'EFI_HII_REF';
+Uuid : 'guid';
+CheckBox : 'checkbox';
+EndCheckBox : 'endcheckbox';
+Numeric : 'numeric';
+EndNumeric : 'endnumeric';
+Minimum : 'minimum';
+Maximum : 'maximum';
+Step : 'step';
+Default : 'default';
+Password : 'password';
+EndPassword : 'endpassword';
+String : 'string';
+EndString : 'endstring';
+MinSize : 'minsize';
+MaxSize : 'maxsize';
+Encoding : 'encoding';
+SuppressIf : 'suppressif';
+DisableIf : 'disableif';
+Hidden : 'hidden';
+Goto : 'goto';
+FormSetGuid : 'formsetguid';
+InconsistentIf : 'inconsistentif';
+WarningIf : 'warningif';
+NoSubmitIf : 'nosubmitif';
+EndIf : 'endif';
+Key : 'key';
+DefaultFlag : 'DEFAULT';
+ManufacturingFlag : 'MANUFACTURING';
+CheckBoxDefaultFlag : 'CHECKBOX_DEFAULT';
+CheckBoxDefaultMfgFlag : 'CHECKBOX_DEFAULT_MFG';
+InteractiveFlag : 'INTERACTIVE';
+NVAccessFlag : 'NV_ACCESS';
+ResetRequiredFlag : 'RESET_REQUIRED';
+ReconnectRequiredFlag : 'RECONNECT_REQUIRED';
+LateCheckFlag : 'LATE_CHECK';
+ReadOnlyFlag : 'READ_ONLY';
+OptionOnlyFlag : 'OPTIONS_ONLY';
+RestStyleFlag : 'REST_STYLE';
+Class : 'class';
+Subclass : 'subclass';
+ClassGuid : 'classguid';
+TypeDef : 'typedef';
+Restore : 'restore';
+Save : 'save';
+Defaults : 'defaults';
+Banner : 'banner';
+Align : 'align';
+Left : 'left';
+Right : 'right';
+Center : 'center';
+Line : 'line';
+Name : 'name';
+
+VarId: 'varid';
+Question: 'question';
+QuestionId: 'questionid';
+Image: 'image';
+Locked: 'locked';
+Rule: 'rule';
+EndRule: 'endrule';
+Value: 'value';
+Read: 'read';
+Write: 'write';
+ResetButton: 'resetbutton';
+EndResetButton: 'endresetbutton';
+DefaultStore: 'defaultstore';
+Attribute: 'attribute';
+Varstore: 'varstore';
+Efivarstore: 'efivarstore';
+VarSize: 'varsize';
+NameValueVarStore: 'namevaluevarstore';
+Action: 'action';
+Config: 'config';
+EndAction: 'endaction';
+Refresh: 'refresh';
+Interval: 'interval';
+VarstoreDevice: 'varstoredevice';
+GuidOp: 'guidop';
+EndGuidOp: 'endguidop';
+DataType: 'datatype';
+Data: 'data';
+Modal: 'modal';
+
+//
+// Define the class and subclass tokens
+//
+//
+ClassNonDevice: 'NON_DEVICE';
+ClassDiskDevice: 'DISK_DEVICE';
+ClassVideoDevice: 'VIDEO_DEVICE';
+ClassNetworkDevice: 'NETWORK_DEVICE';
+ClassInputDevice: 'INPUT_DEVICE';
+ClassOnBoardDevice: 'ONBOARD_DEVICE';
+ClassOtherDevice: 'OTHER_DEVICE';
+
+SubclassSetupApplication: 'SETUP_APPLICATION';
+SubclassGeneralApplication: 'GENERAL_APPLICATION';
+SubclassFrontPage: 'FRONT_PAGE';
+SubclassSingleUse: 'SINGLE_USE';
+
+YearSupppressFlag: 'YEAR_SUPPRESS';
+MonthSuppressFlag: 'MONTH_SUPPRESS';
+DaySuppressFlag: 'DAY_SUPPRESS';
+HourSupppressFlag: 'HOUR_SUPPRESS';
+MinuteSuppressFlag: 'MINUTE_SUPPRESS';
+SecondSuppressFlag: 'SECOND_SUPPRESS';
+StorageNormalFlag: 'STORAGE_NORMAL';
+StorageTimeFlag: 'STORAGE_TIME';
+StorageWakeUpFlag: 'STORAGE_WAKEUP';
+
+UniQueFlag: 'UNIQUE';
+NoEmptyFlag: 'NOEMPTY';
+
+Cond: 'cond';
+Find: 'find';
+Mid: 'mid';
+Tok: 'token';
+Span: 'span';
+
+// The syntax of expression
+
+Dup: 'dup';
+VarEqVal: 'vareqval';
+Var: 'var';
+IdEqVal: 'ideqval';
+IdEqId: 'ideqid';
+IdEqValList: 'ideqvallist';
+QuestionRef: 'questionref';
+RuleRef: 'ruleref';
+StringRef: 'stringref';
+PushThis: 'pushthis';
+Security: 'security';
+Get: 'get';
+TrueSymbol: 'TRUE';
+FalseSymbol: 'FALSE';
+One: 'ONE';
+Ones: 'ONES';
+Zero: 'ZERO';
+Undefined: 'UNDEFINED';
+Version: 'VERSION';
+Length: 'length';
+AND: 'AND';
+OR: 'OR';
+NOT: 'NOT';
+Set: 'set';
+BitWiseNot: '~';
+BoolVal: 'boolval';
+StringVal: 'stringval';
+UnIntVal: 'unintval';
+ToUpper: 'toupper';
+ToLower: 'tolower';
+Match: 'match';
+Match2: 'match2';
+Catenate: 'catenate';
+QuestionRefVal: 'questionrefval';
+StringRefVal: 'stringrefval';
+Map: 'map';
+RefreshGuid: 'refreshguid';
+StringToken: 'STRING_TOKEN';
+
+OptionDefault: 'OPTION_DEFAULT';
+OptionDefaultMfg: 'OPTION_DEFAULT_MFG';
+
+NumericSizeOne: 'NUMERIC_SIZE_1';
+NumericSizeTwo: 'NUMERIC_SIZE_2';
+NumericSizeFour: 'NUMERIC_SIZE_4';
+NumericSizeEight: 'NUMERIC_SIZE_8';
+DisPlayIntDec: 'DISPLAY_INT_DEC';
+DisPlayUIntDec: 'DISPLAY_UINT_DEC';
+DisPlayUIntHex: 'DISPLAY_UINT_HEX';
+
+Insensitive: 'INSENSITIVE';
+Sensitive: 'SENSITIVE';
+
+LastNonMatch: 'LAST_NON_MATCH';
+FirstNonMatch: 'FIRST_NON_MATCH';
+
+
+
+Number
+ : ('0x'[0-9A-Fa-f]+) | [0-9]+
+ ;
+
+StringIdentifier
+ : [A-Za-z_][A-Za-z_0-9]*
+ ;
+
+ComplexDefine
+ : '#' Whitespace? 'define' ~[#\r\n]*
+ -> skip
+ ;
+
+
+LineDefinition
+ : '#' Whitespace? 'line' ~[#\r\n]*
+ -> skip
+ ;
+
+IncludeDefinition
+ : '#' Whitespace? 'include' ~[#\r\n]*
+ -> skip
+ ;
+
+Whitespace
+ : [ \t]+
+ -> skip
+ ;
+
+Newline
+ : ( '\r' '\n'?
+ | '\n'
+ )
+ -> skip
+ ;
+
+LineComment
+ : '//' ~[\r\n]*
+ -> skip
+ ;
+
+// Skip over 'extern' in any included .H file
+Extern
+ : 'extern' ~[#\r\n]*
+ -> skip
+ ;
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/VfrSyntaxLexer.py b/edk2basetools/VfrCompiler/VfrSyntaxLexer.py
new file mode 100644
index 0000000..6978c3b
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrSyntaxLexer.py
@@ -0,0 +1,1709 @@
+# Generated from VfrSyntax.g4 by ANTLR 4.7.2
+from antlr4 import *
+from io import StringIO
+from typing import TextIO
+import sys
+
+
+
+from VfrCompiler.CommonCtypes import *
+from VfrCompiler.VfrFormPkg import *
+from VfrCompiler.VfrUtility import *
+from VfrCompiler.VfrTree import *
+
+
+
+def serializedATN():
+ with StringIO() as buf:
+ buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0102")
+ buf.write("\u0ab7\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+ buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
+ buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
+ buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
+ buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
+ buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
+ buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
+ buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
+ buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
+ buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
+ buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\t")
+ buf.write("L\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\t")
+ buf.write("U\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4")
+ buf.write("^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4")
+ buf.write("g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4")
+ buf.write("p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4")
+ buf.write("y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080")
+ buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083")
+ buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087")
+ buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a")
+ buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e")
+ buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091")
+ buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095")
+ buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098")
+ buf.write("\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c")
+ buf.write("\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f")
+ buf.write("\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3")
+ buf.write("\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6")
+ buf.write("\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa")
+ buf.write("\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad")
+ buf.write("\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1")
+ buf.write("\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4")
+ buf.write("\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8")
+ buf.write("\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb")
+ buf.write("\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf")
+ buf.write("\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2")
+ buf.write("\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6")
+ buf.write("\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9")
+ buf.write("\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd")
+ buf.write("\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0")
+ buf.write("\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4")
+ buf.write("\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7")
+ buf.write("\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db")
+ buf.write("\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de")
+ buf.write("\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2")
+ buf.write("\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5")
+ buf.write("\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9")
+ buf.write("\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec")
+ buf.write("\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0")
+ buf.write("\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3")
+ buf.write("\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7")
+ buf.write("\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa")
+ buf.write("\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe")
+ buf.write("\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101")
+ buf.write("\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3")
+ buf.write("\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6")
+ buf.write("\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
+ buf.write("\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n")
+ buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3")
+ buf.write("\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20")
+ buf.write("\3\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\3\22")
+ buf.write("\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
+ buf.write("\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
+ buf.write("\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30\3\31")
+ buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36")
+ buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3")
+ buf.write("%\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3")
+ buf.write(")\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3")
+ buf.write("+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3")
+ buf.write("-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60")
+ buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61")
+ buf.write("\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
+ buf.write("\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63")
+ buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64")
+ buf.write("\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
+ buf.write("\3\65\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67")
+ buf.write("\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\39\39\39\3")
+ buf.write("9\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\3")
+ buf.write(";\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3")
+ buf.write(">\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3")
+ buf.write("A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3")
+ buf.write("C\3D\3D\3D\3D\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3")
+ buf.write("G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3")
+ buf.write("I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3L\3")
+ buf.write("L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3")
+ buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3")
+ buf.write("O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3")
+ buf.write("Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3")
+ buf.write("T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3")
+ buf.write("V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3")
+ buf.write("W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3")
+ buf.write("Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3")
+ buf.write("[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
+ buf.write("\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3")
+ buf.write("^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3")
+ buf.write("`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3")
+ buf.write("c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3")
+ buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3")
+ buf.write("g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3")
+ buf.write("i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3k\3k\3")
+ buf.write("k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3")
+ buf.write("m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3")
+ buf.write("o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3")
+ buf.write("p\3p\3p\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3")
+ buf.write("r\3r\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3u\3u\3u\3u\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3")
+ buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3")
+ buf.write("w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3")
+ buf.write("x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3z\3z\3")
+ buf.write("z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3")
+ buf.write("{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3")
+ buf.write("|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3")
+ buf.write("~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3")
+ buf.write("\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080")
+ buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081")
+ buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081")
+ buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082")
+ buf.write("\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083")
+ buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084")
+ buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085")
+ buf.write("\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086")
+ buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087")
+ buf.write("\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088")
+ buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089")
+ buf.write("\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
+ buf.write("\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
+ buf.write("\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d")
+ buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e")
+ buf.write("\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f")
+ buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090")
+ buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090")
+ buf.write("\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091")
+ buf.write("\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092")
+ buf.write("\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094")
+ buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094")
+ buf.write("\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096")
+ buf.write("\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097")
+ buf.write("\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098")
+ buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098")
+ buf.write("\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
+ buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
+ buf.write("\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
+ buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
+ buf.write("\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b")
+ buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c")
+ buf.write("\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d")
+ buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d")
+ buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e")
+ buf.write("\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0")
+ buf.write("\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1")
+ buf.write("\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2")
+ buf.write("\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3")
+ buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a4")
+ buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
+ buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
+ buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
+ buf.write("\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
+ buf.write("\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
+ buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8")
+ buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
+ buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa")
+ buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab")
+ buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
+ buf.write("\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
+ buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad")
+ buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad")
+ buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae")
+ buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
+ buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af")
+ buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af")
+ buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0")
+ buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
+ buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1")
+ buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1")
+ buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
+ buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
+ buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
+ buf.write("\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4")
+ buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5")
+ buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5")
+ buf.write("\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
+ buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
+ buf.write("\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
+ buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
+ buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
+ buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
+ buf.write("\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
+ buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
+ buf.write("\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
+ buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
+ buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc")
+ buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
+ buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
+ buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd")
+ buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be")
+ buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
+ buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
+ buf.write("\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf")
+ buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0")
+ buf.write("\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2")
+ buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3")
+ buf.write("\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
+ buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6")
+ buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
+ buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8")
+ buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
+ buf.write("\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca")
+ buf.write("\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
+ buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
+ buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc")
+ buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd")
+ buf.write("\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce")
+ buf.write("\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce")
+ buf.write("\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf")
+ buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0")
+ buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1")
+ buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2")
+ buf.write("\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3")
+ buf.write("\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5")
+ buf.write("\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6")
+ buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7")
+ buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8")
+ buf.write("\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9")
+ buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da")
+ buf.write("\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc")
+ buf.write("\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de")
+ buf.write("\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df")
+ buf.write("\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0")
+ buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1")
+ buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2")
+ buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2")
+ buf.write("\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3")
+ buf.write("\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4")
+ buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5")
+ buf.write("\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6")
+ buf.write("\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
+ buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
+ buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
+ buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
+ buf.write("\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea")
+ buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea")
+ buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb")
+ buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb")
+ buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
+ buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
+ buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed")
+ buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
+ buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
+ buf.write("\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
+ buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
+ buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
+ buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
+ buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0")
+ buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0")
+ buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1")
+ buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1")
+ buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2")
+ buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
+ buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
+ buf.write("\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
+ buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
+ buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4")
+ buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
+ buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
+ buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5")
+ buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6")
+ buf.write("\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6")
+ buf.write("\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
+ buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
+ buf.write("\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
+ buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
+ buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9")
+ buf.write("\3\u00f9\6\u00f9\u0a44\n\u00f9\r\u00f9\16\u00f9\u0a45")
+ buf.write("\3\u00f9\6\u00f9\u0a49\n\u00f9\r\u00f9\16\u00f9\u0a4a")
+ buf.write("\5\u00f9\u0a4d\n\u00f9\3\u00fa\3\u00fa\7\u00fa\u0a51\n")
+ buf.write("\u00fa\f\u00fa\16\u00fa\u0a54\13\u00fa\3\u00fb\3\u00fb")
+ buf.write("\5\u00fb\u0a58\n\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fb")
+ buf.write("\3\u00fb\3\u00fb\3\u00fb\3\u00fb\7\u00fb\u0a62\n\u00fb")
+ buf.write("\f\u00fb\16\u00fb\u0a65\13\u00fb\3\u00fb\3\u00fb\3\u00fc")
+ buf.write("\3\u00fc\5\u00fc\u0a6b\n\u00fc\3\u00fc\3\u00fc\3\u00fc")
+ buf.write("\3\u00fc\3\u00fc\3\u00fc\7\u00fc\u0a73\n\u00fc\f\u00fc")
+ buf.write("\16\u00fc\u0a76\13\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd")
+ buf.write("\5\u00fd\u0a7c\n\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd")
+ buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\7\u00fd\u0a87")
+ buf.write("\n\u00fd\f\u00fd\16\u00fd\u0a8a\13\u00fd\3\u00fd\3\u00fd")
+ buf.write("\3\u00fe\6\u00fe\u0a8f\n\u00fe\r\u00fe\16\u00fe\u0a90")
+ buf.write("\3\u00fe\3\u00fe\3\u00ff\3\u00ff\5\u00ff\u0a97\n\u00ff")
+ buf.write("\3\u00ff\5\u00ff\u0a9a\n\u00ff\3\u00ff\3\u00ff\3\u0100")
+ buf.write("\3\u0100\3\u0100\3\u0100\7\u0100\u0aa2\n\u0100\f\u0100")
+ buf.write("\16\u0100\u0aa5\13\u0100\3\u0100\3\u0100\3\u0101\3\u0101")
+ buf.write("\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\7\u0101")
+ buf.write("\u0ab1\n\u0101\f\u0101\16\u0101\u0ab4\13\u0101\3\u0101")
+ buf.write("\3\u0101\2\2\u0102\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n")
+ buf.write("\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'")
+ buf.write("\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ")
+ buf.write("?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g")
+ buf.write("\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085")
+ buf.write("D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095")
+ buf.write("L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5")
+ buf.write("T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5")
+ buf.write("\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5")
+ buf.write("d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5")
+ buf.write("l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5")
+ buf.write("t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1z\u00f3{\u00f5")
+ buf.write("|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff\u0081\u0101")
+ buf.write("\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086")
+ buf.write("\u010b\u0087\u010d\u0088\u010f\u0089\u0111\u008a\u0113")
+ buf.write("\u008b\u0115\u008c\u0117\u008d\u0119\u008e\u011b\u008f")
+ buf.write("\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125")
+ buf.write("\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098")
+ buf.write("\u012f\u0099\u0131\u009a\u0133\u009b\u0135\u009c\u0137")
+ buf.write("\u009d\u0139\u009e\u013b\u009f\u013d\u00a0\u013f\u00a1")
+ buf.write("\u0141\u00a2\u0143\u00a3\u0145\u00a4\u0147\u00a5\u0149")
+ buf.write("\u00a6\u014b\u00a7\u014d\u00a8\u014f\u00a9\u0151\u00aa")
+ buf.write("\u0153\u00ab\u0155\u00ac\u0157\u00ad\u0159\u00ae\u015b")
+ buf.write("\u00af\u015d\u00b0\u015f\u00b1\u0161\u00b2\u0163\u00b3")
+ buf.write("\u0165\u00b4\u0167\u00b5\u0169\u00b6\u016b\u00b7\u016d")
+ buf.write("\u00b8\u016f\u00b9\u0171\u00ba\u0173\u00bb\u0175\u00bc")
+ buf.write("\u0177\u00bd\u0179\u00be\u017b\u00bf\u017d\u00c0\u017f")
+ buf.write("\u00c1\u0181\u00c2\u0183\u00c3\u0185\u00c4\u0187\u00c5")
+ buf.write("\u0189\u00c6\u018b\u00c7\u018d\u00c8\u018f\u00c9\u0191")
+ buf.write("\u00ca\u0193\u00cb\u0195\u00cc\u0197\u00cd\u0199\u00ce")
+ buf.write("\u019b\u00cf\u019d\u00d0\u019f\u00d1\u01a1\u00d2\u01a3")
+ buf.write("\u00d3\u01a5\u00d4\u01a7\u00d5\u01a9\u00d6\u01ab\u00d7")
+ buf.write("\u01ad\u00d8\u01af\u00d9\u01b1\u00da\u01b3\u00db\u01b5")
+ buf.write("\u00dc\u01b7\u00dd\u01b9\u00de\u01bb\u00df\u01bd\u00e0")
+ buf.write("\u01bf\u00e1\u01c1\u00e2\u01c3\u00e3\u01c5\u00e4\u01c7")
+ buf.write("\u00e5\u01c9\u00e6\u01cb\u00e7\u01cd\u00e8\u01cf\u00e9")
+ buf.write("\u01d1\u00ea\u01d3\u00eb\u01d5\u00ec\u01d7\u00ed\u01d9")
+ buf.write("\u00ee\u01db\u00ef\u01dd\u00f0\u01df\u00f1\u01e1\u00f2")
+ buf.write("\u01e3\u00f3\u01e5\u00f4\u01e7\u00f5\u01e9\u00f6\u01eb")
+ buf.write("\u00f7\u01ed\u00f8\u01ef\u00f9\u01f1\u00fa\u01f3\u00fb")
+ buf.write("\u01f5\u00fc\u01f7\u00fd\u01f9\u00fe\u01fb\u00ff\u01fd")
+ buf.write("\u0100\u01ff\u0101\u0201\u0102\3\2\t\5\2\62;CHch\3\2\62")
+ buf.write(";\5\2C\\aac|\6\2\62;C\\aac|\5\2\f\f\17\17%%\4\2\13\13")
+ buf.write("\"\"\4\2\f\f\17\17\2\u0ac5\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
+ buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
+ buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
+ buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
+ buf.write("\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2")
+ buf.write("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
+ buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
+ buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2")
+ buf.write("\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3")
+ buf.write("\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y")
+ buf.write("\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2")
+ buf.write("c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2")
+ buf.write("\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2")
+ buf.write("\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3")
+ buf.write("\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2")
+ buf.write("\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d")
+ buf.write("\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2")
+ buf.write("\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b")
+ buf.write("\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2")
+ buf.write("\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9")
+ buf.write("\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2")
+ buf.write("\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7")
+ buf.write("\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2")
+ buf.write("\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5")
+ buf.write("\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2")
+ buf.write("\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3")
+ buf.write("\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2")
+ buf.write("\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1")
+ buf.write("\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2")
+ buf.write("\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef")
+ buf.write("\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2")
+ buf.write("\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd")
+ buf.write("\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2")
+ buf.write("\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b")
+ buf.write("\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2")
+ buf.write("\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119")
+ buf.write("\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2")
+ buf.write("\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u0127")
+ buf.write("\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2")
+ buf.write("\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\2\u0135")
+ buf.write("\3\2\2\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2")
+ buf.write("\2\2\u013d\3\2\2\2\2\u013f\3\2\2\2\2\u0141\3\2\2\2\2\u0143")
+ buf.write("\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2")
+ buf.write("\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151")
+ buf.write("\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2")
+ buf.write("\2\2\u0159\3\2\2\2\2\u015b\3\2\2\2\2\u015d\3\2\2\2\2\u015f")
+ buf.write("\3\2\2\2\2\u0161\3\2\2\2\2\u0163\3\2\2\2\2\u0165\3\2\2")
+ buf.write("\2\2\u0167\3\2\2\2\2\u0169\3\2\2\2\2\u016b\3\2\2\2\2\u016d")
+ buf.write("\3\2\2\2\2\u016f\3\2\2\2\2\u0171\3\2\2\2\2\u0173\3\2\2")
+ buf.write("\2\2\u0175\3\2\2\2\2\u0177\3\2\2\2\2\u0179\3\2\2\2\2\u017b")
+ buf.write("\3\2\2\2\2\u017d\3\2\2\2\2\u017f\3\2\2\2\2\u0181\3\2\2")
+ buf.write("\2\2\u0183\3\2\2\2\2\u0185\3\2\2\2\2\u0187\3\2\2\2\2\u0189")
+ buf.write("\3\2\2\2\2\u018b\3\2\2\2\2\u018d\3\2\2\2\2\u018f\3\2\2")
+ buf.write("\2\2\u0191\3\2\2\2\2\u0193\3\2\2\2\2\u0195\3\2\2\2\2\u0197")
+ buf.write("\3\2\2\2\2\u0199\3\2\2\2\2\u019b\3\2\2\2\2\u019d\3\2\2")
+ buf.write("\2\2\u019f\3\2\2\2\2\u01a1\3\2\2\2\2\u01a3\3\2\2\2\2\u01a5")
+ buf.write("\3\2\2\2\2\u01a7\3\2\2\2\2\u01a9\3\2\2\2\2\u01ab\3\2\2")
+ buf.write("\2\2\u01ad\3\2\2\2\2\u01af\3\2\2\2\2\u01b1\3\2\2\2\2\u01b3")
+ buf.write("\3\2\2\2\2\u01b5\3\2\2\2\2\u01b7\3\2\2\2\2\u01b9\3\2\2")
+ buf.write("\2\2\u01bb\3\2\2\2\2\u01bd\3\2\2\2\2\u01bf\3\2\2\2\2\u01c1")
+ buf.write("\3\2\2\2\2\u01c3\3\2\2\2\2\u01c5\3\2\2\2\2\u01c7\3\2\2")
+ buf.write("\2\2\u01c9\3\2\2\2\2\u01cb\3\2\2\2\2\u01cd\3\2\2\2\2\u01cf")
+ buf.write("\3\2\2\2\2\u01d1\3\2\2\2\2\u01d3\3\2\2\2\2\u01d5\3\2\2")
+ buf.write("\2\2\u01d7\3\2\2\2\2\u01d9\3\2\2\2\2\u01db\3\2\2\2\2\u01dd")
+ buf.write("\3\2\2\2\2\u01df\3\2\2\2\2\u01e1\3\2\2\2\2\u01e3\3\2\2")
+ buf.write("\2\2\u01e5\3\2\2\2\2\u01e7\3\2\2\2\2\u01e9\3\2\2\2\2\u01eb")
+ buf.write("\3\2\2\2\2\u01ed\3\2\2\2\2\u01ef\3\2\2\2\2\u01f1\3\2\2")
+ buf.write("\2\2\u01f3\3\2\2\2\2\u01f5\3\2\2\2\2\u01f7\3\2\2\2\2\u01f9")
+ buf.write("\3\2\2\2\2\u01fb\3\2\2\2\2\u01fd\3\2\2\2\2\u01ff\3\2\2")
+ buf.write("\2\2\u0201\3\2\2\2\3\u0203\3\2\2\2\5\u0208\3\2\2\2\7\u020d")
+ buf.write("\3\2\2\2\t\u0211\3\2\2\2\13\u0219\3\2\2\2\r\u021e\3\2")
+ buf.write("\2\2\17\u0220\3\2\2\2\21\u022c\3\2\2\2\23\u0237\3\2\2")
+ buf.write("\2\25\u0242\3\2\2\2\27\u0245\3\2\2\2\31\u0248\3\2\2\2")
+ buf.write("\33\u024a\3\2\2\2\35\u024c\3\2\2\2\37\u024e\3\2\2\2!\u0255")
+ buf.write("\3\2\2\2#\u0257\3\2\2\2%\u025f\3\2\2\2\'\u0268\3\2\2\2")
+ buf.write(")\u0274\3\2\2\2+\u0276\3\2\2\2-\u0278\3\2\2\2/\u027a\3")
+ buf.write("\2\2\2\61\u027c\3\2\2\2\63\u027e\3\2\2\2\65\u0280\3\2")
+ buf.write("\2\2\67\u0282\3\2\2\29\u0284\3\2\2\2;\u0286\3\2\2\2=\u0288")
+ buf.write("\3\2\2\2?\u028a\3\2\2\2A\u028c\3\2\2\2C\u028f\3\2\2\2")
+ buf.write("E\u0292\3\2\2\2G\u0295\3\2\2\2I\u0297\3\2\2\2K\u029a\3")
+ buf.write("\2\2\2M\u029c\3\2\2\2O\u029e\3\2\2\2Q\u02a0\3\2\2\2S\u02ab")
+ buf.write("\3\2\2\2U\u02b3\3\2\2\2W\u02bd\3\2\2\2Y\u02c8\3\2\2\2")
+ buf.write("[\u02ce\3\2\2\2]\u02d5\3\2\2\2_\u02db\3\2\2\2a\u02e4\3")
+ buf.write("\2\2\2c\u02eb\3\2\2\2e\u02f7\3\2\2\2g\u0305\3\2\2\2i\u030d")
+ buf.write("\3\2\2\2k\u0315\3\2\2\2m\u031a\3\2\2\2o\u0322\3\2\2\2")
+ buf.write("q\u032b\3\2\2\2s\u0333\3\2\2\2u\u033c\3\2\2\2w\u0348\3")
+ buf.write("\2\2\2y\u034d\3\2\2\2{\u0352\3\2\2\2}\u0359\3\2\2\2\177")
+ buf.write("\u035f\3\2\2\2\u0081\u0364\3\2\2\2\u0083\u036c\3\2\2\2")
+ buf.write("\u0085\u0371\3\2\2\2\u0087\u0377\3\2\2\2\u0089\u037b\3")
+ buf.write("\2\2\2\u008b\u0380\3\2\2\2\u008d\u0388\3\2\2\2\u008f\u038d")
+ buf.write("\3\2\2\2\u0091\u0394\3\2\2\2\u0093\u039b\3\2\2\2\u0095")
+ buf.write("\u03a5\3\2\2\2\u0097\u03ab\3\2\2\2\u0099\u03b3\3\2\2\2")
+ buf.write("\u009b\u03bd\3\2\2\2\u009d\u03ce\3\2\2\2\u009f\u03d5\3")
+ buf.write("\2\2\2\u00a1\u03db\3\2\2\2\u00a3\u03e3\3\2\2\2\u00a5\u03ea")
+ buf.write("\3\2\2\2\u00a7\u03f1\3\2\2\2\u00a9\u03f8\3\2\2\2\u00ab")
+ buf.write("\u03fe\3\2\2\2\u00ad\u040c\3\2\2\2\u00af\u0419\3\2\2\2")
+ buf.write("\u00b1\u0426\3\2\2\2\u00b3\u0432\3\2\2\2\u00b5\u0437\3")
+ buf.write("\2\2\2\u00b7\u0440\3\2\2\2\u00b9\u044c\3\2\2\2\u00bb\u0454")
+ buf.write("\3\2\2\2\u00bd\u045f\3\2\2\2\u00bf\u0467\3\2\2\2\u00c1")
+ buf.write("\u046f\3\2\2\2\u00c3\u0474\3\2\2\2\u00c5\u047c\3\2\2\2")
+ buf.write("\u00c7\u0485\3\2\2\2\u00c9\u0491\3\2\2\2\u00cb\u0498\3")
+ buf.write("\2\2\2\u00cd\u04a2\3\2\2\2\u00cf\u04aa\3\2\2\2\u00d1\u04b2")
+ buf.write("\3\2\2\2\u00d3\u04bb\3\2\2\2\u00d5\u04c6\3\2\2\2\u00d7")
+ buf.write("\u04d0\3\2\2\2\u00d9\u04d7\3\2\2\2\u00db\u04dc\3\2\2\2")
+ buf.write("\u00dd\u04e8\3\2\2\2\u00df\u04f7\3\2\2\2\u00e1\u0501\3")
+ buf.write("\2\2\2\u00e3\u050c\3\2\2\2\u00e5\u0512\3\2\2\2\u00e7\u0516")
+ buf.write("\3\2\2\2\u00e9\u051e\3\2\2\2\u00eb\u052c\3\2\2\2\u00ed")
+ buf.write("\u053d\3\2\2\2\u00ef\u0552\3\2\2\2\u00f1\u055e\3\2\2\2")
+ buf.write("\u00f3\u0568\3\2\2\2\u00f5\u0577\3\2\2\2\u00f7\u058a\3")
+ buf.write("\2\2\2\u00f9\u0595\3\2\2\2\u00fb\u059f\3\2\2\2\u00fd\u05ac")
+ buf.write("\3\2\2\2\u00ff\u05b7\3\2\2\2\u0101\u05bd\3\2\2\2\u0103")
+ buf.write("\u05c6\3\2\2\2\u0105\u05d0\3\2\2\2\u0107\u05d8\3\2\2\2")
+ buf.write("\u0109\u05e0\3\2\2\2\u010b\u05e5\3\2\2\2\u010d\u05ee\3")
+ buf.write("\2\2\2\u010f\u05f5\3\2\2\2\u0111\u05fb\3\2\2\2\u0113\u0600")
+ buf.write("\3\2\2\2\u0115\u0606\3\2\2\2\u0117\u060d\3\2\2\2\u0119")
+ buf.write("\u0612\3\2\2\2\u011b\u0617\3\2\2\2\u011d\u061d\3\2\2\2")
+ buf.write("\u011f\u0626\3\2\2\2\u0121\u0631\3\2\2\2\u0123\u0637\3")
+ buf.write("\2\2\2\u0125\u063e\3\2\2\2\u0127\u0643\3\2\2\2\u0129\u064b")
+ buf.write("\3\2\2\2\u012b\u0651\3\2\2\2\u012d\u0656\3\2\2\2\u012f")
+ buf.write("\u065c\3\2\2\2\u0131\u0668\3\2\2\2\u0133\u0677\3\2\2\2")
+ buf.write("\u0135\u0684\3\2\2\2\u0137\u068e\3\2\2\2\u0139\u0697\3")
+ buf.write("\2\2\2\u013b\u06a3\3\2\2\2\u013d\u06ab\3\2\2\2\u013f\u06bd")
+ buf.write("\3\2\2\2\u0141\u06c4\3\2\2\2\u0143\u06cb\3\2\2\2\u0145")
+ buf.write("\u06d5\3\2\2\2\u0147\u06dd\3\2\2\2\u0149\u06e6\3\2\2\2")
+ buf.write("\u014b\u06f5\3\2\2\2\u014d\u06fc\3\2\2\2\u014f\u0706\3")
+ buf.write("\2\2\2\u0151\u070f\3\2\2\2\u0153\u0714\3\2\2\2\u0155\u071a")
+ buf.write("\3\2\2\2\u0157\u0725\3\2\2\2\u0159\u0731\3\2\2\2\u015b")
+ buf.write("\u073e\3\2\2\2\u015d\u074d\3\2\2\2\u015f\u075a\3\2\2\2")
+ buf.write("\u0161\u0769\3\2\2\2\u0163\u0776\3\2\2\2\u0165\u0788\3")
+ buf.write("\2\2\2\u0167\u079c\3\2\2\2\u0169\u07a7\3\2\2\2\u016b\u07b2")
+ buf.write("\3\2\2\2\u016d\u07c0\3\2\2\2\u016f\u07cf\3\2\2\2\u0171")
+ buf.write("\u07dc\3\2\2\2\u0173\u07ea\3\2\2\2\u0175\u07fa\3\2\2\2")
+ buf.write("\u0177\u080a\3\2\2\2\u0179\u0819\3\2\2\2\u017b\u0826\3")
+ buf.write("\2\2\2\u017d\u0835\3\2\2\2\u017f\u083c\3\2\2\2\u0181\u0844")
+ buf.write("\3\2\2\2\u0183\u0849\3\2\2\2\u0185\u084e\3\2\2\2\u0187")
+ buf.write("\u0852\3\2\2\2\u0189\u0858\3\2\2\2\u018b\u085d\3\2\2\2")
+ buf.write("\u018d\u0861\3\2\2\2\u018f\u086a\3\2\2\2\u0191\u086e\3")
+ buf.write("\2\2\2\u0193\u0876\3\2\2\2\u0195\u087d\3\2\2\2\u0197\u0889")
+ buf.write("\3\2\2\2\u0199\u0895\3\2\2\2\u019b\u089d\3\2\2\2\u019d")
+ buf.write("\u08a7\3\2\2\2\u019f\u08b0\3\2\2\2\u01a1\u08b9\3\2\2\2")
+ buf.write("\u01a3\u08bd\3\2\2\2\u01a5\u08c2\3\2\2\2\u01a7\u08c8\3")
+ buf.write("\2\2\2\u01a9\u08cc\3\2\2\2\u01ab\u08d1\3\2\2\2\u01ad\u08d6")
+ buf.write("\3\2\2\2\u01af\u08e0\3\2\2\2\u01b1\u08e8\3\2\2\2\u01b3")
+ buf.write("\u08ef\3\2\2\2\u01b5\u08f3\3\2\2\2\u01b7\u08f6\3\2\2\2")
+ buf.write("\u01b9\u08fa\3\2\2\2\u01bb\u08fe\3\2\2\2\u01bd\u0900\3")
+ buf.write("\2\2\2\u01bf\u0908\3\2\2\2\u01c1\u0912\3\2\2\2\u01c3\u091b")
+ buf.write("\3\2\2\2\u01c5\u0923\3\2\2\2\u01c7\u092b\3\2\2\2\u01c9")
+ buf.write("\u0931\3\2\2\2\u01cb\u0938\3\2\2\2\u01cd\u0941\3\2\2\2")
+ buf.write("\u01cf\u0950\3\2\2\2\u01d1\u095d\3\2\2\2\u01d3\u0961\3")
+ buf.write("\2\2\2\u01d5\u096d\3\2\2\2\u01d7\u097a\3\2\2\2\u01d9\u0989")
+ buf.write("\3\2\2\2\u01db\u099c\3\2\2\2\u01dd\u09ab\3\2\2\2\u01df")
+ buf.write("\u09ba\3\2\2\2\u01e1\u09c9\3\2\2\2\u01e3\u09d8\3\2\2\2")
+ buf.write("\u01e5\u09e8\3\2\2\2\u01e7\u09f9\3\2\2\2\u01e9\u0a0a\3")
+ buf.write("\2\2\2\u01eb\u0a16\3\2\2\2\u01ed\u0a20\3\2\2\2\u01ef\u0a2f")
+ buf.write("\3\2\2\2\u01f1\u0a4c\3\2\2\2\u01f3\u0a4e\3\2\2\2\u01f5")
+ buf.write("\u0a55\3\2\2\2\u01f7\u0a68\3\2\2\2\u01f9\u0a79\3\2\2\2")
+ buf.write("\u01fb\u0a8e\3\2\2\2\u01fd\u0a99\3\2\2\2\u01ff\u0a9d\3")
+ buf.write("\2\2\2\u0201\u0aa8\3\2\2\2\u0203\u0204\7u\2\2\u0204\u0205")
+ buf.write("\7j\2\2\u0205\u0206\7q\2\2\u0206\u0207\7y\2\2\u0207\4")
+ buf.write("\3\2\2\2\u0208\u0209\7r\2\2\u0209\u020a\7w\2\2\u020a\u020b")
+ buf.write("\7u\2\2\u020b\u020c\7j\2\2\u020c\6\3\2\2\2\u020d\u020e")
+ buf.write("\7r\2\2\u020e\u020f\7q\2\2\u020f\u0210\7r\2\2\u0210\b")
+ buf.write("\3\2\2\2\u0211\u0212\7%\2\2\u0212\u0213\7r\2\2\u0213\u0214")
+ buf.write("\7t\2\2\u0214\u0215\7c\2\2\u0215\u0216\7i\2\2\u0216\u0217")
+ buf.write("\7o\2\2\u0217\u0218\7c\2\2\u0218\n\3\2\2\2\u0219\u021a")
+ buf.write("\7r\2\2\u021a\u021b\7c\2\2\u021b\u021c\7e\2\2\u021c\u021d")
+ buf.write("\7m\2\2\u021d\f\3\2\2\2\u021e\u021f\7?\2\2\u021f\16\3")
+ buf.write("\2\2\2\u0220\u0221\7K\2\2\u0221\u0222\7O\2\2\u0222\u0223")
+ buf.write("\7C\2\2\u0223\u0224\7I\2\2\u0224\u0225\7G\2\2\u0225\u0226")
+ buf.write("\7a\2\2\u0226\u0227\7V\2\2\u0227\u0228\7Q\2\2\u0228\u0229")
+ buf.write("\7M\2\2\u0229\u022a\7G\2\2\u022a\u022b\7P\2\2\u022b\20")
+ buf.write("\3\2\2\2\u022c\u022d\7J\2\2\u022d\u022e\7Q\2\2\u022e\u022f")
+ buf.write("\7T\2\2\u022f\u0230\7K\2\2\u0230\u0231\7\\\2\2\u0231\u0232")
+ buf.write("\7Q\2\2\u0232\u0233\7P\2\2\u0233\u0234\7V\2\2\u0234\u0235")
+ buf.write("\7C\2\2\u0235\u0236\7N\2\2\u0236\22\3\2\2\2\u0237\u0238")
+ buf.write("\7O\2\2\u0238\u0239\7W\2\2\u0239\u023a\7N\2\2\u023a\u023b")
+ buf.write("\7V\2\2\u023b\u023c\7K\2\2\u023c\u023d\7a\2\2\u023d\u023e")
+ buf.write("\7N\2\2\u023e\u023f\7K\2\2\u023f\u0240\7P\2\2\u0240\u0241")
+ buf.write("\7G\2\2\u0241\24\3\2\2\2\u0242\u0243\7>\2\2\u0243\u0244")
+ buf.write("\7>\2\2\u0244\26\3\2\2\2\u0245\u0246\7@\2\2\u0246\u0247")
+ buf.write("\7@\2\2\u0247\30\3\2\2\2\u0248\u0249\7-\2\2\u0249\32\3")
+ buf.write("\2\2\2\u024a\u024b\7,\2\2\u024b\34\3\2\2\2\u024c\u024d")
+ buf.write("\7\'\2\2\u024d\36\3\2\2\2\u024e\u024f\7h\2\2\u024f\u0250")
+ buf.write("\7q\2\2\u0250\u0251\7t\2\2\u0251\u0252\7o\2\2\u0252\u0253")
+ buf.write("\7c\2\2\u0253\u0254\7v\2\2\u0254 \3\2\2\2\u0255\u0256")
+ buf.write("\7A\2\2\u0256\"\3\2\2\2\u0257\u0258\7%\2\2\u0258\u0259")
+ buf.write("\7f\2\2\u0259\u025a\7g\2\2\u025a\u025b\7h\2\2\u025b\u025c")
+ buf.write("\7k\2\2\u025c\u025d\7p\2\2\u025d\u025e\7g\2\2\u025e$\3")
+ buf.write("\2\2\2\u025f\u0260\7%\2\2\u0260\u0261\7k\2\2\u0261\u0262")
+ buf.write("\7p\2\2\u0262\u0263\7e\2\2\u0263\u0264\7n\2\2\u0264\u0265")
+ buf.write("\7w\2\2\u0265\u0266\7f\2\2\u0266\u0267\7g\2\2\u0267&\3")
+ buf.write("\2\2\2\u0268\u0269\7h\2\2\u0269\u026a\7q\2\2\u026a\u026b")
+ buf.write("\7t\2\2\u026b\u026c\7o\2\2\u026c\u026d\7r\2\2\u026d\u026e")
+ buf.write("\7m\2\2\u026e\u026f\7i\2\2\u026f\u0270\7v\2\2\u0270\u0271")
+ buf.write("\7{\2\2\u0271\u0272\7r\2\2\u0272\u0273\7g\2\2\u0273(\3")
+ buf.write("\2\2\2\u0274\u0275\7}\2\2\u0275*\3\2\2\2\u0276\u0277\7")
+ buf.write("\177\2\2\u0277,\3\2\2\2\u0278\u0279\7*\2\2\u0279.\3\2")
+ buf.write("\2\2\u027a\u027b\7+\2\2\u027b\60\3\2\2\2\u027c\u027d\7")
+ buf.write("]\2\2\u027d\62\3\2\2\2\u027e\u027f\7_\2\2\u027f\64\3\2")
+ buf.write("\2\2\u0280\u0281\7\60\2\2\u0281\66\3\2\2\2\u0282\u0283")
+ buf.write("\7/\2\2\u02838\3\2\2\2\u0284\u0285\7<\2\2\u0285:\3\2\2")
+ buf.write("\2\u0286\u0287\7\61\2\2\u0287<\3\2\2\2\u0288\u0289\7=")
+ buf.write("\2\2\u0289>\3\2\2\2\u028a\u028b\7.\2\2\u028b@\3\2\2\2")
+ buf.write("\u028c\u028d\7?\2\2\u028d\u028e\7?\2\2\u028eB\3\2\2\2")
+ buf.write("\u028f\u0290\7#\2\2\u0290\u0291\7?\2\2\u0291D\3\2\2\2")
+ buf.write("\u0292\u0293\7>\2\2\u0293\u0294\7?\2\2\u0294F\3\2\2\2")
+ buf.write("\u0295\u0296\7>\2\2\u0296H\3\2\2\2\u0297\u0298\7@\2\2")
+ buf.write("\u0298\u0299\7?\2\2\u0299J\3\2\2\2\u029a\u029b\7@\2\2")
+ buf.write("\u029bL\3\2\2\2\u029c\u029d\7~\2\2\u029dN\3\2\2\2\u029e")
+ buf.write("\u029f\7(\2\2\u029fP\3\2\2\2\u02a0\u02a1\7f\2\2\u02a1")
+ buf.write("\u02a2\7g\2\2\u02a2\u02a3\7x\2\2\u02a3\u02a4\7k\2\2\u02a4")
+ buf.write("\u02a5\7e\2\2\u02a5\u02a6\7g\2\2\u02a6\u02a7\7r\2\2\u02a7")
+ buf.write("\u02a8\7c\2\2\u02a8\u02a9\7v\2\2\u02a9\u02aa\7j\2\2\u02aa")
+ buf.write("R\3\2\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7q\2\2\u02ad")
+ buf.write("\u02ae\7t\2\2\u02ae\u02af\7o\2\2\u02af\u02b0\7u\2\2\u02b0")
+ buf.write("\u02b1\7g\2\2\u02b1\u02b2\7v\2\2\u02b2T\3\2\2\2\u02b3")
+ buf.write("\u02b4\7h\2\2\u02b4\u02b5\7q\2\2\u02b5\u02b6\7t\2\2\u02b6")
+ buf.write("\u02b7\7o\2\2\u02b7\u02b8\7u\2\2\u02b8\u02b9\7g\2\2\u02b9")
+ buf.write("\u02ba\7v\2\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7f\2\2\u02bc")
+ buf.write("V\3\2\2\2\u02bd\u02be\7g\2\2\u02be\u02bf\7p\2\2\u02bf")
+ buf.write("\u02c0\7f\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2\7q\2\2\u02c2")
+ buf.write("\u02c3\7t\2\2\u02c3\u02c4\7o\2\2\u02c4\u02c5\7u\2\2\u02c5")
+ buf.write("\u02c6\7g\2\2\u02c6\u02c7\7v\2\2\u02c7X\3\2\2\2\u02c8")
+ buf.write("\u02c9\7v\2\2\u02c9\u02ca\7k\2\2\u02ca\u02cb\7v\2\2\u02cb")
+ buf.write("\u02cc\7n\2\2\u02cc\u02cd\7g\2\2\u02cdZ\3\2\2\2\u02ce")
+ buf.write("\u02cf\7h\2\2\u02cf\u02d0\7q\2\2\u02d0\u02d1\7t\2\2\u02d1")
+ buf.write("\u02d2\7o\2\2\u02d2\u02d3\7k\2\2\u02d3\u02d4\7f\2\2\u02d4")
+ buf.write("\\\3\2\2\2\u02d5\u02d6\7q\2\2\u02d6\u02d7\7p\2\2\u02d7")
+ buf.write("\u02d8\7g\2\2\u02d8\u02d9\7q\2\2\u02d9\u02da\7h\2\2\u02da")
+ buf.write("^\3\2\2\2\u02db\u02dc\7g\2\2\u02dc\u02dd\7p\2\2\u02dd")
+ buf.write("\u02de\7f\2\2\u02de\u02df\7q\2\2\u02df\u02e0\7p\2\2\u02e0")
+ buf.write("\u02e1\7g\2\2\u02e1\u02e2\7q\2\2\u02e2\u02e3\7h\2\2\u02e3")
+ buf.write("`\3\2\2\2\u02e4\u02e5\7r\2\2\u02e5\u02e6\7t\2\2\u02e6")
+ buf.write("\u02e7\7q\2\2\u02e7\u02e8\7o\2\2\u02e8\u02e9\7r\2\2\u02e9")
+ buf.write("\u02ea\7v\2\2\u02eab\3\2\2\2\u02eb\u02ec\7q\2\2\u02ec")
+ buf.write("\u02ed\7t\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef\7g\2\2\u02ef")
+ buf.write("\u02f0\7t\2\2\u02f0\u02f1\7g\2\2\u02f1\u02f2\7f\2\2\u02f2")
+ buf.write("\u02f3\7n\2\2\u02f3\u02f4\7k\2\2\u02f4\u02f5\7u\2\2\u02f5")
+ buf.write("\u02f6\7v\2\2\u02f6d\3\2\2\2\u02f7\u02f8\7o\2\2\u02f8")
+ buf.write("\u02f9\7c\2\2\u02f9\u02fa\7z\2\2\u02fa\u02fb\7e\2\2\u02fb")
+ buf.write("\u02fc\7q\2\2\u02fc\u02fd\7p\2\2\u02fd\u02fe\7v\2\2\u02fe")
+ buf.write("\u02ff\7c\2\2\u02ff\u0300\7k\2\2\u0300\u0301\7p\2\2\u0301")
+ buf.write("\u0302\7g\2\2\u0302\u0303\7t\2\2\u0303\u0304\7u\2\2\u0304")
+ buf.write("f\3\2\2\2\u0305\u0306\7g\2\2\u0306\u0307\7p\2\2\u0307")
+ buf.write("\u0308\7f\2\2\u0308\u0309\7n\2\2\u0309\u030a\7k\2\2\u030a")
+ buf.write("\u030b\7u\2\2\u030b\u030c\7v\2\2\u030ch\3\2\2\2\u030d")
+ buf.write("\u030e\7g\2\2\u030e\u030f\7p\2\2\u030f\u0310\7f\2\2\u0310")
+ buf.write("\u0311\7h\2\2\u0311\u0312\7q\2\2\u0312\u0313\7t\2\2\u0313")
+ buf.write("\u0314\7o\2\2\u0314j\3\2\2\2\u0315\u0316\7h\2\2\u0316")
+ buf.write("\u0317\7q\2\2\u0317\u0318\7t\2\2\u0318\u0319\7o\2\2\u0319")
+ buf.write("l\3\2\2\2\u031a\u031b\7h\2\2\u031b\u031c\7q\2\2\u031c")
+ buf.write("\u031d\7t\2\2\u031d\u031e\7o\2\2\u031e\u031f\7o\2\2\u031f")
+ buf.write("\u0320\7c\2\2\u0320\u0321\7r\2\2\u0321n\3\2\2\2\u0322")
+ buf.write("\u0323\7o\2\2\u0323\u0324\7c\2\2\u0324\u0325\7r\2\2\u0325")
+ buf.write("\u0326\7v\2\2\u0326\u0327\7k\2\2\u0327\u0328\7v\2\2\u0328")
+ buf.write("\u0329\7n\2\2\u0329\u032a\7g\2\2\u032ap\3\2\2\2\u032b")
+ buf.write("\u032c\7o\2\2\u032c\u032d\7c\2\2\u032d\u032e\7r\2\2\u032e")
+ buf.write("\u032f\7i\2\2\u032f\u0330\7w\2\2\u0330\u0331\7k\2\2\u0331")
+ buf.write("\u0332\7f\2\2\u0332r\3\2\2\2\u0333\u0334\7u\2\2\u0334")
+ buf.write("\u0335\7w\2\2\u0335\u0336\7d\2\2\u0336\u0337\7v\2\2\u0337")
+ buf.write("\u0338\7k\2\2\u0338\u0339\7v\2\2\u0339\u033a\7n\2\2\u033a")
+ buf.write("\u033b\7g\2\2\u033bt\3\2\2\2\u033c\u033d\7g\2\2\u033d")
+ buf.write("\u033e\7p\2\2\u033e\u033f\7f\2\2\u033f\u0340\7u\2\2\u0340")
+ buf.write("\u0341\7w\2\2\u0341\u0342\7d\2\2\u0342\u0343\7v\2\2\u0343")
+ buf.write("\u0344\7k\2\2\u0344\u0345\7v\2\2\u0345\u0346\7n\2\2\u0346")
+ buf.write("\u0347\7g\2\2\u0347v\3\2\2\2\u0348\u0349\7j\2\2\u0349")
+ buf.write("\u034a\7g\2\2\u034a\u034b\7n\2\2\u034b\u034c\7r\2\2\u034c")
+ buf.write("x\3\2\2\2\u034d\u034e\7v\2\2\u034e\u034f\7g\2\2\u034f")
+ buf.write("\u0350\7z\2\2\u0350\u0351\7v\2\2\u0351z\3\2\2\2\u0352")
+ buf.write("\u0353\7q\2\2\u0353\u0354\7r\2\2\u0354\u0355\7v\2\2\u0355")
+ buf.write("\u0356\7k\2\2\u0356\u0357\7q\2\2\u0357\u0358\7p\2\2\u0358")
+ buf.write("|\3\2\2\2\u0359\u035a\7h\2\2\u035a\u035b\7n\2\2\u035b")
+ buf.write("\u035c\7c\2\2\u035c\u035d\7i\2\2\u035d\u035e\7u\2\2\u035e")
+ buf.write("~\3\2\2\2\u035f\u0360\7f\2\2\u0360\u0361\7c\2\2\u0361")
+ buf.write("\u0362\7v\2\2\u0362\u0363\7g\2\2\u0363\u0080\3\2\2\2\u0364")
+ buf.write("\u0365\7g\2\2\u0365\u0366\7p\2\2\u0366\u0367\7f\2\2\u0367")
+ buf.write("\u0368\7f\2\2\u0368\u0369\7c\2\2\u0369\u036a\7v\2\2\u036a")
+ buf.write("\u036b\7g\2\2\u036b\u0082\3\2\2\2\u036c\u036d\7{\2\2\u036d")
+ buf.write("\u036e\7g\2\2\u036e\u036f\7c\2\2\u036f\u0370\7t\2\2\u0370")
+ buf.write("\u0084\3\2\2\2\u0371\u0372\7o\2\2\u0372\u0373\7q\2\2\u0373")
+ buf.write("\u0374\7p\2\2\u0374\u0375\7v\2\2\u0375\u0376\7j\2\2\u0376")
+ buf.write("\u0086\3\2\2\2\u0377\u0378\7f\2\2\u0378\u0379\7c\2\2\u0379")
+ buf.write("\u037a\7{\2\2\u037a\u0088\3\2\2\2\u037b\u037c\7v\2\2\u037c")
+ buf.write("\u037d\7k\2\2\u037d\u037e\7o\2\2\u037e\u037f\7g\2\2\u037f")
+ buf.write("\u008a\3\2\2\2\u0380\u0381\7g\2\2\u0381\u0382\7p\2\2\u0382")
+ buf.write("\u0383\7f\2\2\u0383\u0384\7v\2\2\u0384\u0385\7k\2\2\u0385")
+ buf.write("\u0386\7o\2\2\u0386\u0387\7g\2\2\u0387\u008c\3\2\2\2\u0388")
+ buf.write("\u0389\7j\2\2\u0389\u038a\7q\2\2\u038a\u038b\7w\2\2\u038b")
+ buf.write("\u038c\7t\2\2\u038c\u008e\3\2\2\2\u038d\u038e\7o\2\2\u038e")
+ buf.write("\u038f\7k\2\2\u038f\u0390\7p\2\2\u0390\u0391\7w\2\2\u0391")
+ buf.write("\u0392\7v\2\2\u0392\u0393\7g\2\2\u0393\u0090\3\2\2\2\u0394")
+ buf.write("\u0395\7u\2\2\u0395\u0396\7g\2\2\u0396\u0397\7e\2\2\u0397")
+ buf.write("\u0398\7q\2\2\u0398\u0399\7p\2\2\u0399\u039a\7f\2\2\u039a")
+ buf.write("\u0092\3\2\2\2\u039b\u039c\7i\2\2\u039c\u039d\7t\2\2\u039d")
+ buf.write("\u039e\7c\2\2\u039e\u039f\7{\2\2\u039f\u03a0\7q\2\2\u03a0")
+ buf.write("\u03a1\7w\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7k\2\2\u03a3")
+ buf.write("\u03a4\7h\2\2\u03a4\u0094\3\2\2\2\u03a5\u03a6\7n\2\2\u03a6")
+ buf.write("\u03a7\7c\2\2\u03a7\u03a8\7d\2\2\u03a8\u03a9\7g\2\2\u03a9")
+ buf.write("\u03aa\7n\2\2\u03aa\u0096\3\2\2\2\u03ab\u03ac\7v\2\2\u03ac")
+ buf.write("\u03ad\7k\2\2\u03ad\u03ae\7o\2\2\u03ae\u03af\7g\2\2\u03af")
+ buf.write("\u03b0\7q\2\2\u03b0\u03b1\7w\2\2\u03b1\u03b2\7v\2\2\u03b2")
+ buf.write("\u0098\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7p\2\2\u03b5")
+ buf.write("\u03b6\7x\2\2\u03b6\u03b7\7g\2\2\u03b7\u03b8\7p\2\2\u03b8")
+ buf.write("\u03b9\7v\2\2\u03b9\u03ba\7q\2\2\u03ba\u03bb\7t\2\2\u03bb")
+ buf.write("\u03bc\7{\2\2\u03bc\u009a\3\2\2\2\u03bd\u03be\7a\2\2\u03be")
+ buf.write("\u03bf\7P\2\2\u03bf\u03c0\7Q\2\2\u03c0\u03c1\7P\2\2\u03c1")
+ buf.write("\u03c2\7a\2\2\u03c2\u03c3\7P\2\2\u03c3\u03c4\7X\2\2\u03c4")
+ buf.write("\u03c5\7a\2\2\u03c5\u03c6\7F\2\2\u03c6\u03c7\7C\2\2\u03c7")
+ buf.write("\u03c8\7V\2\2\u03c8\u03c9\7C\2\2\u03c9\u03ca\7a\2\2\u03ca")
+ buf.write("\u03cb\7O\2\2\u03cb\u03cc\7C\2\2\u03cc\u03cd\7R\2\2\u03cd")
+ buf.write("\u009c\3\2\2\2\u03ce\u03cf\7u\2\2\u03cf\u03d0\7v\2\2\u03d0")
+ buf.write("\u03d1\7t\2\2\u03d1\u03d2\7w\2\2\u03d2\u03d3\7e\2\2\u03d3")
+ buf.write("\u03d4\7v\2\2\u03d4\u009e\3\2\2\2\u03d5\u03d6\7w\2\2\u03d6")
+ buf.write("\u03d7\7p\2\2\u03d7\u03d8\7k\2\2\u03d8\u03d9\7q\2\2\u03d9")
+ buf.write("\u03da\7p\2\2\u03da\u00a0\3\2\2\2\u03db\u03dc\7D\2\2\u03dc")
+ buf.write("\u03dd\7Q\2\2\u03dd\u03de\7Q\2\2\u03de\u03df\7N\2\2\u03df")
+ buf.write("\u03e0\7G\2\2\u03e0\u03e1\7C\2\2\u03e1\u03e2\7P\2\2\u03e2")
+ buf.write("\u00a2\3\2\2\2\u03e3\u03e4\7W\2\2\u03e4\u03e5\7K\2\2\u03e5")
+ buf.write("\u03e6\7P\2\2\u03e6\u03e7\7V\2\2\u03e7\u03e8\78\2\2\u03e8")
+ buf.write("\u03e9\7\66\2\2\u03e9\u00a4\3\2\2\2\u03ea\u03eb\7W\2\2")
+ buf.write("\u03eb\u03ec\7K\2\2\u03ec\u03ed\7P\2\2\u03ed\u03ee\7V")
+ buf.write("\2\2\u03ee\u03ef\7\65\2\2\u03ef\u03f0\7\64\2\2\u03f0\u00a6")
+ buf.write("\3\2\2\2\u03f1\u03f2\7W\2\2\u03f2\u03f3\7K\2\2\u03f3\u03f4")
+ buf.write("\7P\2\2\u03f4\u03f5\7V\2\2\u03f5\u03f6\7\63\2\2\u03f6")
+ buf.write("\u03f7\78\2\2\u03f7\u00a8\3\2\2\2\u03f8\u03f9\7W\2\2\u03f9")
+ buf.write("\u03fa\7K\2\2\u03fa\u03fb\7P\2\2\u03fb\u03fc\7V\2\2\u03fc")
+ buf.write("\u03fd\7:\2\2\u03fd\u00aa\3\2\2\2\u03fe\u03ff\7G\2\2\u03ff")
+ buf.write("\u0400\7H\2\2\u0400\u0401\7K\2\2\u0401\u0402\7a\2\2\u0402")
+ buf.write("\u0403\7U\2\2\u0403\u0404\7V\2\2\u0404\u0405\7T\2\2\u0405")
+ buf.write("\u0406\7K\2\2\u0406\u0407\7P\2\2\u0407\u0408\7I\2\2\u0408")
+ buf.write("\u0409\7a\2\2\u0409\u040a\7K\2\2\u040a\u040b\7F\2\2\u040b")
+ buf.write("\u00ac\3\2\2\2\u040c\u040d\7G\2\2\u040d\u040e\7H\2\2\u040e")
+ buf.write("\u040f\7K\2\2\u040f\u0410\7a\2\2\u0410\u0411\7J\2\2\u0411")
+ buf.write("\u0412\7K\2\2\u0412\u0413\7K\2\2\u0413\u0414\7a\2\2\u0414")
+ buf.write("\u0415\7F\2\2\u0415\u0416\7C\2\2\u0416\u0417\7V\2\2\u0417")
+ buf.write("\u0418\7G\2\2\u0418\u00ae\3\2\2\2\u0419\u041a\7G\2\2\u041a")
+ buf.write("\u041b\7H\2\2\u041b\u041c\7K\2\2\u041c\u041d\7a\2\2\u041d")
+ buf.write("\u041e\7J\2\2\u041e\u041f\7K\2\2\u041f\u0420\7K\2\2\u0420")
+ buf.write("\u0421\7a\2\2\u0421\u0422\7V\2\2\u0422\u0423\7K\2\2\u0423")
+ buf.write("\u0424\7O\2\2\u0424\u0425\7G\2\2\u0425\u00b0\3\2\2\2\u0426")
+ buf.write("\u0427\7G\2\2\u0427\u0428\7H\2\2\u0428\u0429\7K\2\2\u0429")
+ buf.write("\u042a\7a\2\2\u042a\u042b\7J\2\2\u042b\u042c\7K\2\2\u042c")
+ buf.write("\u042d\7K\2\2\u042d\u042e\7a\2\2\u042e\u042f\7T\2\2\u042f")
+ buf.write("\u0430\7G\2\2\u0430\u0431\7H\2\2\u0431\u00b2\3\2\2\2\u0432")
+ buf.write("\u0433\7i\2\2\u0433\u0434\7w\2\2\u0434\u0435\7k\2\2\u0435")
+ buf.write("\u0436\7f\2\2\u0436\u00b4\3\2\2\2\u0437\u0438\7e\2\2\u0438")
+ buf.write("\u0439\7j\2\2\u0439\u043a\7g\2\2\u043a\u043b\7e\2\2\u043b")
+ buf.write("\u043c\7m\2\2\u043c\u043d\7d\2\2\u043d\u043e\7q\2\2\u043e")
+ buf.write("\u043f\7z\2\2\u043f\u00b6\3\2\2\2\u0440\u0441\7g\2\2\u0441")
+ buf.write("\u0442\7p\2\2\u0442\u0443\7f\2\2\u0443\u0444\7e\2\2\u0444")
+ buf.write("\u0445\7j\2\2\u0445\u0446\7g\2\2\u0446\u0447\7e\2\2\u0447")
+ buf.write("\u0448\7m\2\2\u0448\u0449\7d\2\2\u0449\u044a\7q\2\2\u044a")
+ buf.write("\u044b\7z\2\2\u044b\u00b8\3\2\2\2\u044c\u044d\7p\2\2\u044d")
+ buf.write("\u044e\7w\2\2\u044e\u044f\7o\2\2\u044f\u0450\7g\2\2\u0450")
+ buf.write("\u0451\7t\2\2\u0451\u0452\7k\2\2\u0452\u0453\7e\2\2\u0453")
+ buf.write("\u00ba\3\2\2\2\u0454\u0455\7g\2\2\u0455\u0456\7p\2\2\u0456")
+ buf.write("\u0457\7f\2\2\u0457\u0458\7p\2\2\u0458\u0459\7w\2\2\u0459")
+ buf.write("\u045a\7o\2\2\u045a\u045b\7g\2\2\u045b\u045c\7t\2\2\u045c")
+ buf.write("\u045d\7k\2\2\u045d\u045e\7e\2\2\u045e\u00bc\3\2\2\2\u045f")
+ buf.write("\u0460\7o\2\2\u0460\u0461\7k\2\2\u0461\u0462\7p\2\2\u0462")
+ buf.write("\u0463\7k\2\2\u0463\u0464\7o\2\2\u0464\u0465\7w\2\2\u0465")
+ buf.write("\u0466\7o\2\2\u0466\u00be\3\2\2\2\u0467\u0468\7o\2\2\u0468")
+ buf.write("\u0469\7c\2\2\u0469\u046a\7z\2\2\u046a\u046b\7k\2\2\u046b")
+ buf.write("\u046c\7o\2\2\u046c\u046d\7w\2\2\u046d\u046e\7o\2\2\u046e")
+ buf.write("\u00c0\3\2\2\2\u046f\u0470\7u\2\2\u0470\u0471\7v\2\2\u0471")
+ buf.write("\u0472\7g\2\2\u0472\u0473\7r\2\2\u0473\u00c2\3\2\2\2\u0474")
+ buf.write("\u0475\7f\2\2\u0475\u0476\7g\2\2\u0476\u0477\7h\2\2\u0477")
+ buf.write("\u0478\7c\2\2\u0478\u0479\7w\2\2\u0479\u047a\7n\2\2\u047a")
+ buf.write("\u047b\7v\2\2\u047b\u00c4\3\2\2\2\u047c\u047d\7r\2\2\u047d")
+ buf.write("\u047e\7c\2\2\u047e\u047f\7u\2\2\u047f\u0480\7u\2\2\u0480")
+ buf.write("\u0481\7y\2\2\u0481\u0482\7q\2\2\u0482\u0483\7t\2\2\u0483")
+ buf.write("\u0484\7f\2\2\u0484\u00c6\3\2\2\2\u0485\u0486\7g\2\2\u0486")
+ buf.write("\u0487\7p\2\2\u0487\u0488\7f\2\2\u0488\u0489\7r\2\2\u0489")
+ buf.write("\u048a\7c\2\2\u048a\u048b\7u\2\2\u048b\u048c\7u\2\2\u048c")
+ buf.write("\u048d\7y\2\2\u048d\u048e\7q\2\2\u048e\u048f\7t\2\2\u048f")
+ buf.write("\u0490\7f\2\2\u0490\u00c8\3\2\2\2\u0491\u0492\7u\2\2\u0492")
+ buf.write("\u0493\7v\2\2\u0493\u0494\7t\2\2\u0494\u0495\7k\2\2\u0495")
+ buf.write("\u0496\7p\2\2\u0496\u0497\7i\2\2\u0497\u00ca\3\2\2\2\u0498")
+ buf.write("\u0499\7g\2\2\u0499\u049a\7p\2\2\u049a\u049b\7f\2\2\u049b")
+ buf.write("\u049c\7u\2\2\u049c\u049d\7v\2\2\u049d\u049e\7t\2\2\u049e")
+ buf.write("\u049f\7k\2\2\u049f\u04a0\7p\2\2\u04a0\u04a1\7i\2\2\u04a1")
+ buf.write("\u00cc\3\2\2\2\u04a2\u04a3\7o\2\2\u04a3\u04a4\7k\2\2\u04a4")
+ buf.write("\u04a5\7p\2\2\u04a5\u04a6\7u\2\2\u04a6\u04a7\7k\2\2\u04a7")
+ buf.write("\u04a8\7|\2\2\u04a8\u04a9\7g\2\2\u04a9\u00ce\3\2\2\2\u04aa")
+ buf.write("\u04ab\7o\2\2\u04ab\u04ac\7c\2\2\u04ac\u04ad\7z\2\2\u04ad")
+ buf.write("\u04ae\7u\2\2\u04ae\u04af\7k\2\2\u04af\u04b0\7|\2\2\u04b0")
+ buf.write("\u04b1\7g\2\2\u04b1\u00d0\3\2\2\2\u04b2\u04b3\7g\2\2\u04b3")
+ buf.write("\u04b4\7p\2\2\u04b4\u04b5\7e\2\2\u04b5\u04b6\7q\2\2\u04b6")
+ buf.write("\u04b7\7f\2\2\u04b7\u04b8\7k\2\2\u04b8\u04b9\7p\2\2\u04b9")
+ buf.write("\u04ba\7i\2\2\u04ba\u00d2\3\2\2\2\u04bb\u04bc\7u\2\2\u04bc")
+ buf.write("\u04bd\7w\2\2\u04bd\u04be\7r\2\2\u04be\u04bf\7r\2\2\u04bf")
+ buf.write("\u04c0\7t\2\2\u04c0\u04c1\7g\2\2\u04c1\u04c2\7u\2\2\u04c2")
+ buf.write("\u04c3\7u\2\2\u04c3\u04c4\7k\2\2\u04c4\u04c5\7h\2\2\u04c5")
+ buf.write("\u00d4\3\2\2\2\u04c6\u04c7\7f\2\2\u04c7\u04c8\7k\2\2\u04c8")
+ buf.write("\u04c9\7u\2\2\u04c9\u04ca\7c\2\2\u04ca\u04cb\7d\2\2\u04cb")
+ buf.write("\u04cc\7n\2\2\u04cc\u04cd\7g\2\2\u04cd\u04ce\7k\2\2\u04ce")
+ buf.write("\u04cf\7h\2\2\u04cf\u00d6\3\2\2\2\u04d0\u04d1\7j\2\2\u04d1")
+ buf.write("\u04d2\7k\2\2\u04d2\u04d3\7f\2\2\u04d3\u04d4\7f\2\2\u04d4")
+ buf.write("\u04d5\7g\2\2\u04d5\u04d6\7p\2\2\u04d6\u00d8\3\2\2\2\u04d7")
+ buf.write("\u04d8\7i\2\2\u04d8\u04d9\7q\2\2\u04d9\u04da\7v\2\2\u04da")
+ buf.write("\u04db\7q\2\2\u04db\u00da\3\2\2\2\u04dc\u04dd\7h\2\2\u04dd")
+ buf.write("\u04de\7q\2\2\u04de\u04df\7t\2\2\u04df\u04e0\7o\2\2\u04e0")
+ buf.write("\u04e1\7u\2\2\u04e1\u04e2\7g\2\2\u04e2\u04e3\7v\2\2\u04e3")
+ buf.write("\u04e4\7i\2\2\u04e4\u04e5\7w\2\2\u04e5\u04e6\7k\2\2\u04e6")
+ buf.write("\u04e7\7f\2\2\u04e7\u00dc\3\2\2\2\u04e8\u04e9\7k\2\2\u04e9")
+ buf.write("\u04ea\7p\2\2\u04ea\u04eb\7e\2\2\u04eb\u04ec\7q\2\2\u04ec")
+ buf.write("\u04ed\7p\2\2\u04ed\u04ee\7u\2\2\u04ee\u04ef\7k\2\2\u04ef")
+ buf.write("\u04f0\7u\2\2\u04f0\u04f1\7v\2\2\u04f1\u04f2\7g\2\2\u04f2")
+ buf.write("\u04f3\7p\2\2\u04f3\u04f4\7v\2\2\u04f4\u04f5\7k\2\2\u04f5")
+ buf.write("\u04f6\7h\2\2\u04f6\u00de\3\2\2\2\u04f7\u04f8\7y\2\2\u04f8")
+ buf.write("\u04f9\7c\2\2\u04f9\u04fa\7t\2\2\u04fa\u04fb\7p\2\2\u04fb")
+ buf.write("\u04fc\7k\2\2\u04fc\u04fd\7p\2\2\u04fd\u04fe\7i\2\2\u04fe")
+ buf.write("\u04ff\7k\2\2\u04ff\u0500\7h\2\2\u0500\u00e0\3\2\2\2\u0501")
+ buf.write("\u0502\7p\2\2\u0502\u0503\7q\2\2\u0503\u0504\7u\2\2\u0504")
+ buf.write("\u0505\7w\2\2\u0505\u0506\7d\2\2\u0506\u0507\7o\2\2\u0507")
+ buf.write("\u0508\7k\2\2\u0508\u0509\7v\2\2\u0509\u050a\7k\2\2\u050a")
+ buf.write("\u050b\7h\2\2\u050b\u00e2\3\2\2\2\u050c\u050d\7g\2\2\u050d")
+ buf.write("\u050e\7p\2\2\u050e\u050f\7f\2\2\u050f\u0510\7k\2\2\u0510")
+ buf.write("\u0511\7h\2\2\u0511\u00e4\3\2\2\2\u0512\u0513\7m\2\2\u0513")
+ buf.write("\u0514\7g\2\2\u0514\u0515\7{\2\2\u0515\u00e6\3\2\2\2\u0516")
+ buf.write("\u0517\7F\2\2\u0517\u0518\7G\2\2\u0518\u0519\7H\2\2\u0519")
+ buf.write("\u051a\7C\2\2\u051a\u051b\7W\2\2\u051b\u051c\7N\2\2\u051c")
+ buf.write("\u051d\7V\2\2\u051d\u00e8\3\2\2\2\u051e\u051f\7O\2\2\u051f")
+ buf.write("\u0520\7C\2\2\u0520\u0521\7P\2\2\u0521\u0522\7W\2\2\u0522")
+ buf.write("\u0523\7H\2\2\u0523\u0524\7C\2\2\u0524\u0525\7E\2\2\u0525")
+ buf.write("\u0526\7V\2\2\u0526\u0527\7W\2\2\u0527\u0528\7T\2\2\u0528")
+ buf.write("\u0529\7K\2\2\u0529\u052a\7P\2\2\u052a\u052b\7I\2\2\u052b")
+ buf.write("\u00ea\3\2\2\2\u052c\u052d\7E\2\2\u052d\u052e\7J\2\2\u052e")
+ buf.write("\u052f\7G\2\2\u052f\u0530\7E\2\2\u0530\u0531\7M\2\2\u0531")
+ buf.write("\u0532\7D\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7Z\2\2\u0534")
+ buf.write("\u0535\7a\2\2\u0535\u0536\7F\2\2\u0536\u0537\7G\2\2\u0537")
+ buf.write("\u0538\7H\2\2\u0538\u0539\7C\2\2\u0539\u053a\7W\2\2\u053a")
+ buf.write("\u053b\7N\2\2\u053b\u053c\7V\2\2\u053c\u00ec\3\2\2\2\u053d")
+ buf.write("\u053e\7E\2\2\u053e\u053f\7J\2\2\u053f\u0540\7G\2\2\u0540")
+ buf.write("\u0541\7E\2\2\u0541\u0542\7M\2\2\u0542\u0543\7D\2\2\u0543")
+ buf.write("\u0544\7Q\2\2\u0544\u0545\7Z\2\2\u0545\u0546\7a\2\2\u0546")
+ buf.write("\u0547\7F\2\2\u0547\u0548\7G\2\2\u0548\u0549\7H\2\2\u0549")
+ buf.write("\u054a\7C\2\2\u054a\u054b\7W\2\2\u054b\u054c\7N\2\2\u054c")
+ buf.write("\u054d\7V\2\2\u054d\u054e\7a\2\2\u054e\u054f\7O\2\2\u054f")
+ buf.write("\u0550\7H\2\2\u0550\u0551\7I\2\2\u0551\u00ee\3\2\2\2\u0552")
+ buf.write("\u0553\7K\2\2\u0553\u0554\7P\2\2\u0554\u0555\7V\2\2\u0555")
+ buf.write("\u0556\7G\2\2\u0556\u0557\7T\2\2\u0557\u0558\7C\2\2\u0558")
+ buf.write("\u0559\7E\2\2\u0559\u055a\7V\2\2\u055a\u055b\7K\2\2\u055b")
+ buf.write("\u055c\7X\2\2\u055c\u055d\7G\2\2\u055d\u00f0\3\2\2\2\u055e")
+ buf.write("\u055f\7P\2\2\u055f\u0560\7X\2\2\u0560\u0561\7a\2\2\u0561")
+ buf.write("\u0562\7C\2\2\u0562\u0563\7E\2\2\u0563\u0564\7E\2\2\u0564")
+ buf.write("\u0565\7G\2\2\u0565\u0566\7U\2\2\u0566\u0567\7U\2\2\u0567")
+ buf.write("\u00f2\3\2\2\2\u0568\u0569\7T\2\2\u0569\u056a\7G\2\2\u056a")
+ buf.write("\u056b\7U\2\2\u056b\u056c\7G\2\2\u056c\u056d\7V\2\2\u056d")
+ buf.write("\u056e\7a\2\2\u056e\u056f\7T\2\2\u056f\u0570\7G\2\2\u0570")
+ buf.write("\u0571\7S\2\2\u0571\u0572\7W\2\2\u0572\u0573\7K\2\2\u0573")
+ buf.write("\u0574\7T\2\2\u0574\u0575\7G\2\2\u0575\u0576\7F\2\2\u0576")
+ buf.write("\u00f4\3\2\2\2\u0577\u0578\7T\2\2\u0578\u0579\7G\2\2\u0579")
+ buf.write("\u057a\7E\2\2\u057a\u057b\7Q\2\2\u057b\u057c\7P\2\2\u057c")
+ buf.write("\u057d\7P\2\2\u057d\u057e\7G\2\2\u057e\u057f\7E\2\2\u057f")
+ buf.write("\u0580\7V\2\2\u0580\u0581\7a\2\2\u0581\u0582\7T\2\2\u0582")
+ buf.write("\u0583\7G\2\2\u0583\u0584\7S\2\2\u0584\u0585\7W\2\2\u0585")
+ buf.write("\u0586\7K\2\2\u0586\u0587\7T\2\2\u0587\u0588\7G\2\2\u0588")
+ buf.write("\u0589\7F\2\2\u0589\u00f6\3\2\2\2\u058a\u058b\7N\2\2\u058b")
+ buf.write("\u058c\7C\2\2\u058c\u058d\7V\2\2\u058d\u058e\7G\2\2\u058e")
+ buf.write("\u058f\7a\2\2\u058f\u0590\7E\2\2\u0590\u0591\7J\2\2\u0591")
+ buf.write("\u0592\7G\2\2\u0592\u0593\7E\2\2\u0593\u0594\7M\2\2\u0594")
+ buf.write("\u00f8\3\2\2\2\u0595\u0596\7T\2\2\u0596\u0597\7G\2\2\u0597")
+ buf.write("\u0598\7C\2\2\u0598\u0599\7F\2\2\u0599\u059a\7a\2\2\u059a")
+ buf.write("\u059b\7Q\2\2\u059b\u059c\7P\2\2\u059c\u059d\7N\2\2\u059d")
+ buf.write("\u059e\7[\2\2\u059e\u00fa\3\2\2\2\u059f\u05a0\7Q\2\2\u05a0")
+ buf.write("\u05a1\7R\2\2\u05a1\u05a2\7V\2\2\u05a2\u05a3\7K\2\2\u05a3")
+ buf.write("\u05a4\7Q\2\2\u05a4\u05a5\7P\2\2\u05a5\u05a6\7U\2\2\u05a6")
+ buf.write("\u05a7\7a\2\2\u05a7\u05a8\7Q\2\2\u05a8\u05a9\7P\2\2\u05a9")
+ buf.write("\u05aa\7N\2\2\u05aa\u05ab\7[\2\2\u05ab\u00fc\3\2\2\2\u05ac")
+ buf.write("\u05ad\7T\2\2\u05ad\u05ae\7G\2\2\u05ae\u05af\7U\2\2\u05af")
+ buf.write("\u05b0\7V\2\2\u05b0\u05b1\7a\2\2\u05b1\u05b2\7U\2\2\u05b2")
+ buf.write("\u05b3\7V\2\2\u05b3\u05b4\7[\2\2\u05b4\u05b5\7N\2\2\u05b5")
+ buf.write("\u05b6\7G\2\2\u05b6\u00fe\3\2\2\2\u05b7\u05b8\7e\2\2\u05b8")
+ buf.write("\u05b9\7n\2\2\u05b9\u05ba\7c\2\2\u05ba\u05bb\7u\2\2\u05bb")
+ buf.write("\u05bc\7u\2\2\u05bc\u0100\3\2\2\2\u05bd\u05be\7u\2\2\u05be")
+ buf.write("\u05bf\7w\2\2\u05bf\u05c0\7d\2\2\u05c0\u05c1\7e\2\2\u05c1")
+ buf.write("\u05c2\7n\2\2\u05c2\u05c3\7c\2\2\u05c3\u05c4\7u\2\2\u05c4")
+ buf.write("\u05c5\7u\2\2\u05c5\u0102\3\2\2\2\u05c6\u05c7\7e\2\2\u05c7")
+ buf.write("\u05c8\7n\2\2\u05c8\u05c9\7c\2\2\u05c9\u05ca\7u\2\2\u05ca")
+ buf.write("\u05cb\7u\2\2\u05cb\u05cc\7i\2\2\u05cc\u05cd\7w\2\2\u05cd")
+ buf.write("\u05ce\7k\2\2\u05ce\u05cf\7f\2\2\u05cf\u0104\3\2\2\2\u05d0")
+ buf.write("\u05d1\7v\2\2\u05d1\u05d2\7{\2\2\u05d2\u05d3\7r\2\2\u05d3")
+ buf.write("\u05d4\7g\2\2\u05d4\u05d5\7f\2\2\u05d5\u05d6\7g\2\2\u05d6")
+ buf.write("\u05d7\7h\2\2\u05d7\u0106\3\2\2\2\u05d8\u05d9\7t\2\2\u05d9")
+ buf.write("\u05da\7g\2\2\u05da\u05db\7u\2\2\u05db\u05dc\7v\2\2\u05dc")
+ buf.write("\u05dd\7q\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7g\2\2\u05df")
+ buf.write("\u0108\3\2\2\2\u05e0\u05e1\7u\2\2\u05e1\u05e2\7c\2\2\u05e2")
+ buf.write("\u05e3\7x\2\2\u05e3\u05e4\7g\2\2\u05e4\u010a\3\2\2\2\u05e5")
+ buf.write("\u05e6\7f\2\2\u05e6\u05e7\7g\2\2\u05e7\u05e8\7h\2\2\u05e8")
+ buf.write("\u05e9\7c\2\2\u05e9\u05ea\7w\2\2\u05ea\u05eb\7n\2\2\u05eb")
+ buf.write("\u05ec\7v\2\2\u05ec\u05ed\7u\2\2\u05ed\u010c\3\2\2\2\u05ee")
+ buf.write("\u05ef\7d\2\2\u05ef\u05f0\7c\2\2\u05f0\u05f1\7p\2\2\u05f1")
+ buf.write("\u05f2\7p\2\2\u05f2\u05f3\7g\2\2\u05f3\u05f4\7t\2\2\u05f4")
+ buf.write("\u010e\3\2\2\2\u05f5\u05f6\7c\2\2\u05f6\u05f7\7n\2\2\u05f7")
+ buf.write("\u05f8\7k\2\2\u05f8\u05f9\7i\2\2\u05f9\u05fa\7p\2\2\u05fa")
+ buf.write("\u0110\3\2\2\2\u05fb\u05fc\7n\2\2\u05fc\u05fd\7g\2\2\u05fd")
+ buf.write("\u05fe\7h\2\2\u05fe\u05ff\7v\2\2\u05ff\u0112\3\2\2\2\u0600")
+ buf.write("\u0601\7t\2\2\u0601\u0602\7k\2\2\u0602\u0603\7i\2\2\u0603")
+ buf.write("\u0604\7j\2\2\u0604\u0605\7v\2\2\u0605\u0114\3\2\2\2\u0606")
+ buf.write("\u0607\7e\2\2\u0607\u0608\7g\2\2\u0608\u0609\7p\2\2\u0609")
+ buf.write("\u060a\7v\2\2\u060a\u060b\7g\2\2\u060b\u060c\7t\2\2\u060c")
+ buf.write("\u0116\3\2\2\2\u060d\u060e\7n\2\2\u060e\u060f\7k\2\2\u060f")
+ buf.write("\u0610\7p\2\2\u0610\u0611\7g\2\2\u0611\u0118\3\2\2\2\u0612")
+ buf.write("\u0613\7p\2\2\u0613\u0614\7c\2\2\u0614\u0615\7o\2\2\u0615")
+ buf.write("\u0616\7g\2\2\u0616\u011a\3\2\2\2\u0617\u0618\7x\2\2\u0618")
+ buf.write("\u0619\7c\2\2\u0619\u061a\7t\2\2\u061a\u061b\7k\2\2\u061b")
+ buf.write("\u061c\7f\2\2\u061c\u011c\3\2\2\2\u061d\u061e\7s\2\2\u061e")
+ buf.write("\u061f\7w\2\2\u061f\u0620\7g\2\2\u0620\u0621\7u\2\2\u0621")
+ buf.write("\u0622\7v\2\2\u0622\u0623\7k\2\2\u0623\u0624\7q\2\2\u0624")
+ buf.write("\u0625\7p\2\2\u0625\u011e\3\2\2\2\u0626\u0627\7s\2\2\u0627")
+ buf.write("\u0628\7w\2\2\u0628\u0629\7g\2\2\u0629\u062a\7u\2\2\u062a")
+ buf.write("\u062b\7v\2\2\u062b\u062c\7k\2\2\u062c\u062d\7q\2\2\u062d")
+ buf.write("\u062e\7p\2\2\u062e\u062f\7k\2\2\u062f\u0630\7f\2\2\u0630")
+ buf.write("\u0120\3\2\2\2\u0631\u0632\7k\2\2\u0632\u0633\7o\2\2\u0633")
+ buf.write("\u0634\7c\2\2\u0634\u0635\7i\2\2\u0635\u0636\7g\2\2\u0636")
+ buf.write("\u0122\3\2\2\2\u0637\u0638\7n\2\2\u0638\u0639\7q\2\2\u0639")
+ buf.write("\u063a\7e\2\2\u063a\u063b\7m\2\2\u063b\u063c\7g\2\2\u063c")
+ buf.write("\u063d\7f\2\2\u063d\u0124\3\2\2\2\u063e\u063f\7t\2\2\u063f")
+ buf.write("\u0640\7w\2\2\u0640\u0641\7n\2\2\u0641\u0642\7g\2\2\u0642")
+ buf.write("\u0126\3\2\2\2\u0643\u0644\7g\2\2\u0644\u0645\7p\2\2\u0645")
+ buf.write("\u0646\7f\2\2\u0646\u0647\7t\2\2\u0647\u0648\7w\2\2\u0648")
+ buf.write("\u0649\7n\2\2\u0649\u064a\7g\2\2\u064a\u0128\3\2\2\2\u064b")
+ buf.write("\u064c\7x\2\2\u064c\u064d\7c\2\2\u064d\u064e\7n\2\2\u064e")
+ buf.write("\u064f\7w\2\2\u064f\u0650\7g\2\2\u0650\u012a\3\2\2\2\u0651")
+ buf.write("\u0652\7t\2\2\u0652\u0653\7g\2\2\u0653\u0654\7c\2\2\u0654")
+ buf.write("\u0655\7f\2\2\u0655\u012c\3\2\2\2\u0656\u0657\7y\2\2\u0657")
+ buf.write("\u0658\7t\2\2\u0658\u0659\7k\2\2\u0659\u065a\7v\2\2\u065a")
+ buf.write("\u065b\7g\2\2\u065b\u012e\3\2\2\2\u065c\u065d\7t\2\2\u065d")
+ buf.write("\u065e\7g\2\2\u065e\u065f\7u\2\2\u065f\u0660\7g\2\2\u0660")
+ buf.write("\u0661\7v\2\2\u0661\u0662\7d\2\2\u0662\u0663\7w\2\2\u0663")
+ buf.write("\u0664\7v\2\2\u0664\u0665\7v\2\2\u0665\u0666\7q\2\2\u0666")
+ buf.write("\u0667\7p\2\2\u0667\u0130\3\2\2\2\u0668\u0669\7g\2\2\u0669")
+ buf.write("\u066a\7p\2\2\u066a\u066b\7f\2\2\u066b\u066c\7t\2\2\u066c")
+ buf.write("\u066d\7g\2\2\u066d\u066e\7u\2\2\u066e\u066f\7g\2\2\u066f")
+ buf.write("\u0670\7v\2\2\u0670\u0671\7d\2\2\u0671\u0672\7w\2\2\u0672")
+ buf.write("\u0673\7v\2\2\u0673\u0674\7v\2\2\u0674\u0675\7q\2\2\u0675")
+ buf.write("\u0676\7p\2\2\u0676\u0132\3\2\2\2\u0677\u0678\7f\2\2\u0678")
+ buf.write("\u0679\7g\2\2\u0679\u067a\7h\2\2\u067a\u067b\7c\2\2\u067b")
+ buf.write("\u067c\7w\2\2\u067c\u067d\7n\2\2\u067d\u067e\7v\2\2\u067e")
+ buf.write("\u067f\7u\2\2\u067f\u0680\7v\2\2\u0680\u0681\7q\2\2\u0681")
+ buf.write("\u0682\7t\2\2\u0682\u0683\7g\2\2\u0683\u0134\3\2\2\2\u0684")
+ buf.write("\u0685\7c\2\2\u0685\u0686\7v\2\2\u0686\u0687\7v\2\2\u0687")
+ buf.write("\u0688\7t\2\2\u0688\u0689\7k\2\2\u0689\u068a\7d\2\2\u068a")
+ buf.write("\u068b\7w\2\2\u068b\u068c\7v\2\2\u068c\u068d\7g\2\2\u068d")
+ buf.write("\u0136\3\2\2\2\u068e\u068f\7x\2\2\u068f\u0690\7c\2\2\u0690")
+ buf.write("\u0691\7t\2\2\u0691\u0692\7u\2\2\u0692\u0693\7v\2\2\u0693")
+ buf.write("\u0694\7q\2\2\u0694\u0695\7t\2\2\u0695\u0696\7g\2\2\u0696")
+ buf.write("\u0138\3\2\2\2\u0697\u0698\7g\2\2\u0698\u0699\7h\2\2\u0699")
+ buf.write("\u069a\7k\2\2\u069a\u069b\7x\2\2\u069b\u069c\7c\2\2\u069c")
+ buf.write("\u069d\7t\2\2\u069d\u069e\7u\2\2\u069e\u069f\7v\2\2\u069f")
+ buf.write("\u06a0\7q\2\2\u06a0\u06a1\7t\2\2\u06a1\u06a2\7g\2\2\u06a2")
+ buf.write("\u013a\3\2\2\2\u06a3\u06a4\7x\2\2\u06a4\u06a5\7c\2\2\u06a5")
+ buf.write("\u06a6\7t\2\2\u06a6\u06a7\7u\2\2\u06a7\u06a8\7k\2\2\u06a8")
+ buf.write("\u06a9\7|\2\2\u06a9\u06aa\7g\2\2\u06aa\u013c\3\2\2\2\u06ab")
+ buf.write("\u06ac\7p\2\2\u06ac\u06ad\7c\2\2\u06ad\u06ae\7o\2\2\u06ae")
+ buf.write("\u06af\7g\2\2\u06af\u06b0\7x\2\2\u06b0\u06b1\7c\2\2\u06b1")
+ buf.write("\u06b2\7n\2\2\u06b2\u06b3\7w\2\2\u06b3\u06b4\7g\2\2\u06b4")
+ buf.write("\u06b5\7x\2\2\u06b5\u06b6\7c\2\2\u06b6\u06b7\7t\2\2\u06b7")
+ buf.write("\u06b8\7u\2\2\u06b8\u06b9\7v\2\2\u06b9\u06ba\7q\2\2\u06ba")
+ buf.write("\u06bb\7t\2\2\u06bb\u06bc\7g\2\2\u06bc\u013e\3\2\2\2\u06bd")
+ buf.write("\u06be\7c\2\2\u06be\u06bf\7e\2\2\u06bf\u06c0\7v\2\2\u06c0")
+ buf.write("\u06c1\7k\2\2\u06c1\u06c2\7q\2\2\u06c2\u06c3\7p\2\2\u06c3")
+ buf.write("\u0140\3\2\2\2\u06c4\u06c5\7e\2\2\u06c5\u06c6\7q\2\2\u06c6")
+ buf.write("\u06c7\7p\2\2\u06c7\u06c8\7h\2\2\u06c8\u06c9\7k\2\2\u06c9")
+ buf.write("\u06ca\7i\2\2\u06ca\u0142\3\2\2\2\u06cb\u06cc\7g\2\2\u06cc")
+ buf.write("\u06cd\7p\2\2\u06cd\u06ce\7f\2\2\u06ce\u06cf\7c\2\2\u06cf")
+ buf.write("\u06d0\7e\2\2\u06d0\u06d1\7v\2\2\u06d1\u06d2\7k\2\2\u06d2")
+ buf.write("\u06d3\7q\2\2\u06d3\u06d4\7p\2\2\u06d4\u0144\3\2\2\2\u06d5")
+ buf.write("\u06d6\7t\2\2\u06d6\u06d7\7g\2\2\u06d7\u06d8\7h\2\2\u06d8")
+ buf.write("\u06d9\7t\2\2\u06d9\u06da\7g\2\2\u06da\u06db\7u\2\2\u06db")
+ buf.write("\u06dc\7j\2\2\u06dc\u0146\3\2\2\2\u06dd\u06de\7k\2\2\u06de")
+ buf.write("\u06df\7p\2\2\u06df\u06e0\7v\2\2\u06e0\u06e1\7g\2\2\u06e1")
+ buf.write("\u06e2\7t\2\2\u06e2\u06e3\7x\2\2\u06e3\u06e4\7c\2\2\u06e4")
+ buf.write("\u06e5\7n\2\2\u06e5\u0148\3\2\2\2\u06e6\u06e7\7x\2\2\u06e7")
+ buf.write("\u06e8\7c\2\2\u06e8\u06e9\7t\2\2\u06e9\u06ea\7u\2\2\u06ea")
+ buf.write("\u06eb\7v\2\2\u06eb\u06ec\7q\2\2\u06ec\u06ed\7t\2\2\u06ed")
+ buf.write("\u06ee\7g\2\2\u06ee\u06ef\7f\2\2\u06ef\u06f0\7g\2\2\u06f0")
+ buf.write("\u06f1\7x\2\2\u06f1\u06f2\7k\2\2\u06f2\u06f3\7e\2\2\u06f3")
+ buf.write("\u06f4\7g\2\2\u06f4\u014a\3\2\2\2\u06f5\u06f6\7i\2\2\u06f6")
+ buf.write("\u06f7\7w\2\2\u06f7\u06f8\7k\2\2\u06f8\u06f9\7f\2\2\u06f9")
+ buf.write("\u06fa\7q\2\2\u06fa\u06fb\7r\2\2\u06fb\u014c\3\2\2\2\u06fc")
+ buf.write("\u06fd\7g\2\2\u06fd\u06fe\7p\2\2\u06fe\u06ff\7f\2\2\u06ff")
+ buf.write("\u0700\7i\2\2\u0700\u0701\7w\2\2\u0701\u0702\7k\2\2\u0702")
+ buf.write("\u0703\7f\2\2\u0703\u0704\7q\2\2\u0704\u0705\7r\2\2\u0705")
+ buf.write("\u014e\3\2\2\2\u0706\u0707\7f\2\2\u0707\u0708\7c\2\2\u0708")
+ buf.write("\u0709\7v\2\2\u0709\u070a\7c\2\2\u070a\u070b\7v\2\2\u070b")
+ buf.write("\u070c\7{\2\2\u070c\u070d\7r\2\2\u070d\u070e\7g\2\2\u070e")
+ buf.write("\u0150\3\2\2\2\u070f\u0710\7f\2\2\u0710\u0711\7c\2\2\u0711")
+ buf.write("\u0712\7v\2\2\u0712\u0713\7c\2\2\u0713\u0152\3\2\2\2\u0714")
+ buf.write("\u0715\7o\2\2\u0715\u0716\7q\2\2\u0716\u0717\7f\2\2\u0717")
+ buf.write("\u0718\7c\2\2\u0718\u0719\7n\2\2\u0719\u0154\3\2\2\2\u071a")
+ buf.write("\u071b\7P\2\2\u071b\u071c\7Q\2\2\u071c\u071d\7P\2\2\u071d")
+ buf.write("\u071e\7a\2\2\u071e\u071f\7F\2\2\u071f\u0720\7G\2\2\u0720")
+ buf.write("\u0721\7X\2\2\u0721\u0722\7K\2\2\u0722\u0723\7E\2\2\u0723")
+ buf.write("\u0724\7G\2\2\u0724\u0156\3\2\2\2\u0725\u0726\7F\2\2\u0726")
+ buf.write("\u0727\7K\2\2\u0727\u0728\7U\2\2\u0728\u0729\7M\2\2\u0729")
+ buf.write("\u072a\7a\2\2\u072a\u072b\7F\2\2\u072b\u072c\7G\2\2\u072c")
+ buf.write("\u072d\7X\2\2\u072d\u072e\7K\2\2\u072e\u072f\7E\2\2\u072f")
+ buf.write("\u0730\7G\2\2\u0730\u0158\3\2\2\2\u0731\u0732\7X\2\2\u0732")
+ buf.write("\u0733\7K\2\2\u0733\u0734\7F\2\2\u0734\u0735\7G\2\2\u0735")
+ buf.write("\u0736\7Q\2\2\u0736\u0737\7a\2\2\u0737\u0738\7F\2\2\u0738")
+ buf.write("\u0739\7G\2\2\u0739\u073a\7X\2\2\u073a\u073b\7K\2\2\u073b")
+ buf.write("\u073c\7E\2\2\u073c\u073d\7G\2\2\u073d\u015a\3\2\2\2\u073e")
+ buf.write("\u073f\7P\2\2\u073f\u0740\7G\2\2\u0740\u0741\7V\2\2\u0741")
+ buf.write("\u0742\7Y\2\2\u0742\u0743\7Q\2\2\u0743\u0744\7T\2\2\u0744")
+ buf.write("\u0745\7M\2\2\u0745\u0746\7a\2\2\u0746\u0747\7F\2\2\u0747")
+ buf.write("\u0748\7G\2\2\u0748\u0749\7X\2\2\u0749\u074a\7K\2\2\u074a")
+ buf.write("\u074b\7E\2\2\u074b\u074c\7G\2\2\u074c\u015c\3\2\2\2\u074d")
+ buf.write("\u074e\7K\2\2\u074e\u074f\7P\2\2\u074f\u0750\7R\2\2\u0750")
+ buf.write("\u0751\7W\2\2\u0751\u0752\7V\2\2\u0752\u0753\7a\2\2\u0753")
+ buf.write("\u0754\7F\2\2\u0754\u0755\7G\2\2\u0755\u0756\7X\2\2\u0756")
+ buf.write("\u0757\7K\2\2\u0757\u0758\7E\2\2\u0758\u0759\7G\2\2\u0759")
+ buf.write("\u015e\3\2\2\2\u075a\u075b\7Q\2\2\u075b\u075c\7P\2\2\u075c")
+ buf.write("\u075d\7D\2\2\u075d\u075e\7Q\2\2\u075e\u075f\7C\2\2\u075f")
+ buf.write("\u0760\7T\2\2\u0760\u0761\7F\2\2\u0761\u0762\7a\2\2\u0762")
+ buf.write("\u0763\7F\2\2\u0763\u0764\7G\2\2\u0764\u0765\7X\2\2\u0765")
+ buf.write("\u0766\7K\2\2\u0766\u0767\7E\2\2\u0767\u0768\7G\2\2\u0768")
+ buf.write("\u0160\3\2\2\2\u0769\u076a\7Q\2\2\u076a\u076b\7V\2\2\u076b")
+ buf.write("\u076c\7J\2\2\u076c\u076d\7G\2\2\u076d\u076e\7T\2\2\u076e")
+ buf.write("\u076f\7a\2\2\u076f\u0770\7F\2\2\u0770\u0771\7G\2\2\u0771")
+ buf.write("\u0772\7X\2\2\u0772\u0773\7K\2\2\u0773\u0774\7E\2\2\u0774")
+ buf.write("\u0775\7G\2\2\u0775\u0162\3\2\2\2\u0776\u0777\7U\2\2\u0777")
+ buf.write("\u0778\7G\2\2\u0778\u0779\7V\2\2\u0779\u077a\7W\2\2\u077a")
+ buf.write("\u077b\7R\2\2\u077b\u077c\7a\2\2\u077c\u077d\7C\2\2\u077d")
+ buf.write("\u077e\7R\2\2\u077e\u077f\7R\2\2\u077f\u0780\7N\2\2\u0780")
+ buf.write("\u0781\7K\2\2\u0781\u0782\7E\2\2\u0782\u0783\7C\2\2\u0783")
+ buf.write("\u0784\7V\2\2\u0784\u0785\7K\2\2\u0785\u0786\7Q\2\2\u0786")
+ buf.write("\u0787\7P\2\2\u0787\u0164\3\2\2\2\u0788\u0789\7I\2\2\u0789")
+ buf.write("\u078a\7G\2\2\u078a\u078b\7P\2\2\u078b\u078c\7G\2\2\u078c")
+ buf.write("\u078d\7T\2\2\u078d\u078e\7C\2\2\u078e\u078f\7N\2\2\u078f")
+ buf.write("\u0790\7a\2\2\u0790\u0791\7C\2\2\u0791\u0792\7R\2\2\u0792")
+ buf.write("\u0793\7R\2\2\u0793\u0794\7N\2\2\u0794\u0795\7K\2\2\u0795")
+ buf.write("\u0796\7E\2\2\u0796\u0797\7C\2\2\u0797\u0798\7V\2\2\u0798")
+ buf.write("\u0799\7K\2\2\u0799\u079a\7Q\2\2\u079a\u079b\7P\2\2\u079b")
+ buf.write("\u0166\3\2\2\2\u079c\u079d\7H\2\2\u079d\u079e\7T\2\2\u079e")
+ buf.write("\u079f\7Q\2\2\u079f\u07a0\7P\2\2\u07a0\u07a1\7V\2\2\u07a1")
+ buf.write("\u07a2\7a\2\2\u07a2\u07a3\7R\2\2\u07a3\u07a4\7C\2\2\u07a4")
+ buf.write("\u07a5\7I\2\2\u07a5\u07a6\7G\2\2\u07a6\u0168\3\2\2\2\u07a7")
+ buf.write("\u07a8\7U\2\2\u07a8\u07a9\7K\2\2\u07a9\u07aa\7P\2\2\u07aa")
+ buf.write("\u07ab\7I\2\2\u07ab\u07ac\7N\2\2\u07ac\u07ad\7G\2\2\u07ad")
+ buf.write("\u07ae\7a\2\2\u07ae\u07af\7W\2\2\u07af\u07b0\7U\2\2\u07b0")
+ buf.write("\u07b1\7G\2\2\u07b1\u016a\3\2\2\2\u07b2\u07b3\7[\2\2\u07b3")
+ buf.write("\u07b4\7G\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7T\2\2\u07b6")
+ buf.write("\u07b7\7a\2\2\u07b7\u07b8\7U\2\2\u07b8\u07b9\7W\2\2\u07b9")
+ buf.write("\u07ba\7R\2\2\u07ba\u07bb\7R\2\2\u07bb\u07bc\7T\2\2\u07bc")
+ buf.write("\u07bd\7G\2\2\u07bd\u07be\7U\2\2\u07be\u07bf\7U\2\2\u07bf")
+ buf.write("\u016c\3\2\2\2\u07c0\u07c1\7O\2\2\u07c1\u07c2\7Q\2\2\u07c2")
+ buf.write("\u07c3\7P\2\2\u07c3\u07c4\7V\2\2\u07c4\u07c5\7J\2\2\u07c5")
+ buf.write("\u07c6\7a\2\2\u07c6\u07c7\7U\2\2\u07c7\u07c8\7W\2\2\u07c8")
+ buf.write("\u07c9\7R\2\2\u07c9\u07ca\7R\2\2\u07ca\u07cb\7T\2\2\u07cb")
+ buf.write("\u07cc\7G\2\2\u07cc\u07cd\7U\2\2\u07cd\u07ce\7U\2\2\u07ce")
+ buf.write("\u016e\3\2\2\2\u07cf\u07d0\7F\2\2\u07d0\u07d1\7C\2\2\u07d1")
+ buf.write("\u07d2\7[\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d4\7U\2\2\u07d4")
+ buf.write("\u07d5\7W\2\2\u07d5\u07d6\7R\2\2\u07d6\u07d7\7R\2\2\u07d7")
+ buf.write("\u07d8\7T\2\2\u07d8\u07d9\7G\2\2\u07d9\u07da\7U\2\2\u07da")
+ buf.write("\u07db\7U\2\2\u07db\u0170\3\2\2\2\u07dc\u07dd\7J\2\2\u07dd")
+ buf.write("\u07de\7Q\2\2\u07de\u07df\7W\2\2\u07df\u07e0\7T\2\2\u07e0")
+ buf.write("\u07e1\7a\2\2\u07e1\u07e2\7U\2\2\u07e2\u07e3\7W\2\2\u07e3")
+ buf.write("\u07e4\7R\2\2\u07e4\u07e5\7R\2\2\u07e5\u07e6\7T\2\2\u07e6")
+ buf.write("\u07e7\7G\2\2\u07e7\u07e8\7U\2\2\u07e8\u07e9\7U\2\2\u07e9")
+ buf.write("\u0172\3\2\2\2\u07ea\u07eb\7O\2\2\u07eb\u07ec\7K\2\2\u07ec")
+ buf.write("\u07ed\7P\2\2\u07ed\u07ee\7W\2\2\u07ee\u07ef\7V\2\2\u07ef")
+ buf.write("\u07f0\7G\2\2\u07f0\u07f1\7a\2\2\u07f1\u07f2\7U\2\2\u07f2")
+ buf.write("\u07f3\7W\2\2\u07f3\u07f4\7R\2\2\u07f4\u07f5\7R\2\2\u07f5")
+ buf.write("\u07f6\7T\2\2\u07f6\u07f7\7G\2\2\u07f7\u07f8\7U\2\2\u07f8")
+ buf.write("\u07f9\7U\2\2\u07f9\u0174\3\2\2\2\u07fa\u07fb\7U\2\2\u07fb")
+ buf.write("\u07fc\7G\2\2\u07fc\u07fd\7E\2\2\u07fd\u07fe\7Q\2\2\u07fe")
+ buf.write("\u07ff\7P\2\2\u07ff\u0800\7F\2\2\u0800\u0801\7a\2\2\u0801")
+ buf.write("\u0802\7U\2\2\u0802\u0803\7W\2\2\u0803\u0804\7R\2\2\u0804")
+ buf.write("\u0805\7R\2\2\u0805\u0806\7T\2\2\u0806\u0807\7G\2\2\u0807")
+ buf.write("\u0808\7U\2\2\u0808\u0809\7U\2\2\u0809\u0176\3\2\2\2\u080a")
+ buf.write("\u080b\7U\2\2\u080b\u080c\7V\2\2\u080c\u080d\7Q\2\2\u080d")
+ buf.write("\u080e\7T\2\2\u080e\u080f\7C\2\2\u080f\u0810\7I\2\2\u0810")
+ buf.write("\u0811\7G\2\2\u0811\u0812\7a\2\2\u0812\u0813\7P\2\2\u0813")
+ buf.write("\u0814\7Q\2\2\u0814\u0815\7T\2\2\u0815\u0816\7O\2\2\u0816")
+ buf.write("\u0817\7C\2\2\u0817\u0818\7N\2\2\u0818\u0178\3\2\2\2\u0819")
+ buf.write("\u081a\7U\2\2\u081a\u081b\7V\2\2\u081b\u081c\7Q\2\2\u081c")
+ buf.write("\u081d\7T\2\2\u081d\u081e\7C\2\2\u081e\u081f\7I\2\2\u081f")
+ buf.write("\u0820\7G\2\2\u0820\u0821\7a\2\2\u0821\u0822\7V\2\2\u0822")
+ buf.write("\u0823\7K\2\2\u0823\u0824\7O\2\2\u0824\u0825\7G\2\2\u0825")
+ buf.write("\u017a\3\2\2\2\u0826\u0827\7U\2\2\u0827\u0828\7V\2\2\u0828")
+ buf.write("\u0829\7Q\2\2\u0829\u082a\7T\2\2\u082a\u082b\7C\2\2\u082b")
+ buf.write("\u082c\7I\2\2\u082c\u082d\7G\2\2\u082d\u082e\7a\2\2\u082e")
+ buf.write("\u082f\7Y\2\2\u082f\u0830\7C\2\2\u0830\u0831\7M\2\2\u0831")
+ buf.write("\u0832\7G\2\2\u0832\u0833\7W\2\2\u0833\u0834\7R\2\2\u0834")
+ buf.write("\u017c\3\2\2\2\u0835\u0836\7W\2\2\u0836\u0837\7P\2\2\u0837")
+ buf.write("\u0838\7K\2\2\u0838\u0839\7S\2\2\u0839\u083a\7W\2\2\u083a")
+ buf.write("\u083b\7G\2\2\u083b\u017e\3\2\2\2\u083c\u083d\7P\2\2\u083d")
+ buf.write("\u083e\7Q\2\2\u083e\u083f\7G\2\2\u083f\u0840\7O\2\2\u0840")
+ buf.write("\u0841\7R\2\2\u0841\u0842\7V\2\2\u0842\u0843\7[\2\2\u0843")
+ buf.write("\u0180\3\2\2\2\u0844\u0845\7e\2\2\u0845\u0846\7q\2\2\u0846")
+ buf.write("\u0847\7p\2\2\u0847\u0848\7f\2\2\u0848\u0182\3\2\2\2\u0849")
+ buf.write("\u084a\7h\2\2\u084a\u084b\7k\2\2\u084b\u084c\7p\2\2\u084c")
+ buf.write("\u084d\7f\2\2\u084d\u0184\3\2\2\2\u084e\u084f\7o\2\2\u084f")
+ buf.write("\u0850\7k\2\2\u0850\u0851\7f\2\2\u0851\u0186\3\2\2\2\u0852")
+ buf.write("\u0853\7v\2\2\u0853\u0854\7q\2\2\u0854\u0855\7m\2\2\u0855")
+ buf.write("\u0856\7g\2\2\u0856\u0857\7p\2\2\u0857\u0188\3\2\2\2\u0858")
+ buf.write("\u0859\7u\2\2\u0859\u085a\7r\2\2\u085a\u085b\7c\2\2\u085b")
+ buf.write("\u085c\7p\2\2\u085c\u018a\3\2\2\2\u085d\u085e\7f\2\2\u085e")
+ buf.write("\u085f\7w\2\2\u085f\u0860\7r\2\2\u0860\u018c\3\2\2\2\u0861")
+ buf.write("\u0862\7x\2\2\u0862\u0863\7c\2\2\u0863\u0864\7t\2\2\u0864")
+ buf.write("\u0865\7g\2\2\u0865\u0866\7s\2\2\u0866\u0867\7x\2\2\u0867")
+ buf.write("\u0868\7c\2\2\u0868\u0869\7n\2\2\u0869\u018e\3\2\2\2\u086a")
+ buf.write("\u086b\7x\2\2\u086b\u086c\7c\2\2\u086c\u086d\7t\2\2\u086d")
+ buf.write("\u0190\3\2\2\2\u086e\u086f\7k\2\2\u086f\u0870\7f\2\2\u0870")
+ buf.write("\u0871\7g\2\2\u0871\u0872\7s\2\2\u0872\u0873\7x\2\2\u0873")
+ buf.write("\u0874\7c\2\2\u0874\u0875\7n\2\2\u0875\u0192\3\2\2\2\u0876")
+ buf.write("\u0877\7k\2\2\u0877\u0878\7f\2\2\u0878\u0879\7g\2\2\u0879")
+ buf.write("\u087a\7s\2\2\u087a\u087b\7k\2\2\u087b\u087c\7f\2\2\u087c")
+ buf.write("\u0194\3\2\2\2\u087d\u087e\7k\2\2\u087e\u087f\7f\2\2\u087f")
+ buf.write("\u0880\7g\2\2\u0880\u0881\7s\2\2\u0881\u0882\7x\2\2\u0882")
+ buf.write("\u0883\7c\2\2\u0883\u0884\7n\2\2\u0884\u0885\7n\2\2\u0885")
+ buf.write("\u0886\7k\2\2\u0886\u0887\7u\2\2\u0887\u0888\7v\2\2\u0888")
+ buf.write("\u0196\3\2\2\2\u0889\u088a\7s\2\2\u088a\u088b\7w\2\2\u088b")
+ buf.write("\u088c\7g\2\2\u088c\u088d\7u\2\2\u088d\u088e\7v\2\2\u088e")
+ buf.write("\u088f\7k\2\2\u088f\u0890\7q\2\2\u0890\u0891\7p\2\2\u0891")
+ buf.write("\u0892\7t\2\2\u0892\u0893\7g\2\2\u0893\u0894\7h\2\2\u0894")
+ buf.write("\u0198\3\2\2\2\u0895\u0896\7t\2\2\u0896\u0897\7w\2\2\u0897")
+ buf.write("\u0898\7n\2\2\u0898\u0899\7g\2\2\u0899\u089a\7t\2\2\u089a")
+ buf.write("\u089b\7g\2\2\u089b\u089c\7h\2\2\u089c\u019a\3\2\2\2\u089d")
+ buf.write("\u089e\7u\2\2\u089e\u089f\7v\2\2\u089f\u08a0\7t\2\2\u08a0")
+ buf.write("\u08a1\7k\2\2\u08a1\u08a2\7p\2\2\u08a2\u08a3\7i\2\2\u08a3")
+ buf.write("\u08a4\7t\2\2\u08a4\u08a5\7g\2\2\u08a5\u08a6\7h\2\2\u08a6")
+ buf.write("\u019c\3\2\2\2\u08a7\u08a8\7r\2\2\u08a8\u08a9\7w\2\2\u08a9")
+ buf.write("\u08aa\7u\2\2\u08aa\u08ab\7j\2\2\u08ab\u08ac\7v\2\2\u08ac")
+ buf.write("\u08ad\7j\2\2\u08ad\u08ae\7k\2\2\u08ae\u08af\7u\2\2\u08af")
+ buf.write("\u019e\3\2\2\2\u08b0\u08b1\7u\2\2\u08b1\u08b2\7g\2\2\u08b2")
+ buf.write("\u08b3\7e\2\2\u08b3\u08b4\7w\2\2\u08b4\u08b5\7t\2\2\u08b5")
+ buf.write("\u08b6\7k\2\2\u08b6\u08b7\7v\2\2\u08b7\u08b8\7{\2\2\u08b8")
+ buf.write("\u01a0\3\2\2\2\u08b9\u08ba\7i\2\2\u08ba\u08bb\7g\2\2\u08bb")
+ buf.write("\u08bc\7v\2\2\u08bc\u01a2\3\2\2\2\u08bd\u08be\7V\2\2\u08be")
+ buf.write("\u08bf\7T\2\2\u08bf\u08c0\7W\2\2\u08c0\u08c1\7G\2\2\u08c1")
+ buf.write("\u01a4\3\2\2\2\u08c2\u08c3\7H\2\2\u08c3\u08c4\7C\2\2\u08c4")
+ buf.write("\u08c5\7N\2\2\u08c5\u08c6\7U\2\2\u08c6\u08c7\7G\2\2\u08c7")
+ buf.write("\u01a6\3\2\2\2\u08c8\u08c9\7Q\2\2\u08c9\u08ca\7P\2\2\u08ca")
+ buf.write("\u08cb\7G\2\2\u08cb\u01a8\3\2\2\2\u08cc\u08cd\7Q\2\2\u08cd")
+ buf.write("\u08ce\7P\2\2\u08ce\u08cf\7G\2\2\u08cf\u08d0\7U\2\2\u08d0")
+ buf.write("\u01aa\3\2\2\2\u08d1\u08d2\7\\\2\2\u08d2\u08d3\7G\2\2")
+ buf.write("\u08d3\u08d4\7T\2\2\u08d4\u08d5\7Q\2\2\u08d5\u01ac\3\2")
+ buf.write("\2\2\u08d6\u08d7\7W\2\2\u08d7\u08d8\7P\2\2\u08d8\u08d9")
+ buf.write("\7F\2\2\u08d9\u08da\7G\2\2\u08da\u08db\7H\2\2\u08db\u08dc")
+ buf.write("\7K\2\2\u08dc\u08dd\7P\2\2\u08dd\u08de\7G\2\2\u08de\u08df")
+ buf.write("\7F\2\2\u08df\u01ae\3\2\2\2\u08e0\u08e1\7X\2\2\u08e1\u08e2")
+ buf.write("\7G\2\2\u08e2\u08e3\7T\2\2\u08e3\u08e4\7U\2\2\u08e4\u08e5")
+ buf.write("\7K\2\2\u08e5\u08e6\7Q\2\2\u08e6\u08e7\7P\2\2\u08e7\u01b0")
+ buf.write("\3\2\2\2\u08e8\u08e9\7n\2\2\u08e9\u08ea\7g\2\2\u08ea\u08eb")
+ buf.write("\7p\2\2\u08eb\u08ec\7i\2\2\u08ec\u08ed\7v\2\2\u08ed\u08ee")
+ buf.write("\7j\2\2\u08ee\u01b2\3\2\2\2\u08ef\u08f0\7C\2\2\u08f0\u08f1")
+ buf.write("\7P\2\2\u08f1\u08f2\7F\2\2\u08f2\u01b4\3\2\2\2\u08f3\u08f4")
+ buf.write("\7Q\2\2\u08f4\u08f5\7T\2\2\u08f5\u01b6\3\2\2\2\u08f6\u08f7")
+ buf.write("\7P\2\2\u08f7\u08f8\7Q\2\2\u08f8\u08f9\7V\2\2\u08f9\u01b8")
+ buf.write("\3\2\2\2\u08fa\u08fb\7u\2\2\u08fb\u08fc\7g\2\2\u08fc\u08fd")
+ buf.write("\7v\2\2\u08fd\u01ba\3\2\2\2\u08fe\u08ff\7\u0080\2\2\u08ff")
+ buf.write("\u01bc\3\2\2\2\u0900\u0901\7d\2\2\u0901\u0902\7q\2\2\u0902")
+ buf.write("\u0903\7q\2\2\u0903\u0904\7n\2\2\u0904\u0905\7x\2\2\u0905")
+ buf.write("\u0906\7c\2\2\u0906\u0907\7n\2\2\u0907\u01be\3\2\2\2\u0908")
+ buf.write("\u0909\7u\2\2\u0909\u090a\7v\2\2\u090a\u090b\7t\2\2\u090b")
+ buf.write("\u090c\7k\2\2\u090c\u090d\7p\2\2\u090d\u090e\7i\2\2\u090e")
+ buf.write("\u090f\7x\2\2\u090f\u0910\7c\2\2\u0910\u0911\7n\2\2\u0911")
+ buf.write("\u01c0\3\2\2\2\u0912\u0913\7w\2\2\u0913\u0914\7p\2\2\u0914")
+ buf.write("\u0915\7k\2\2\u0915\u0916\7p\2\2\u0916\u0917\7v\2\2\u0917")
+ buf.write("\u0918\7x\2\2\u0918\u0919\7c\2\2\u0919\u091a\7n\2\2\u091a")
+ buf.write("\u01c2\3\2\2\2\u091b\u091c\7v\2\2\u091c\u091d\7q\2\2\u091d")
+ buf.write("\u091e\7w\2\2\u091e\u091f\7r\2\2\u091f\u0920\7r\2\2\u0920")
+ buf.write("\u0921\7g\2\2\u0921\u0922\7t\2\2\u0922\u01c4\3\2\2\2\u0923")
+ buf.write("\u0924\7v\2\2\u0924\u0925\7q\2\2\u0925\u0926\7n\2\2\u0926")
+ buf.write("\u0927\7q\2\2\u0927\u0928\7y\2\2\u0928\u0929\7g\2\2\u0929")
+ buf.write("\u092a\7t\2\2\u092a\u01c6\3\2\2\2\u092b\u092c\7o\2\2\u092c")
+ buf.write("\u092d\7c\2\2\u092d\u092e\7v\2\2\u092e\u092f\7e\2\2\u092f")
+ buf.write("\u0930\7j\2\2\u0930\u01c8\3\2\2\2\u0931\u0932\7o\2\2\u0932")
+ buf.write("\u0933\7c\2\2\u0933\u0934\7v\2\2\u0934\u0935\7e\2\2\u0935")
+ buf.write("\u0936\7j\2\2\u0936\u0937\7\64\2\2\u0937\u01ca\3\2\2\2")
+ buf.write("\u0938\u0939\7e\2\2\u0939\u093a\7c\2\2\u093a\u093b\7v")
+ buf.write("\2\2\u093b\u093c\7g\2\2\u093c\u093d\7p\2\2\u093d\u093e")
+ buf.write("\7c\2\2\u093e\u093f\7v\2\2\u093f\u0940\7g\2\2\u0940\u01cc")
+ buf.write("\3\2\2\2\u0941\u0942\7s\2\2\u0942\u0943\7w\2\2\u0943\u0944")
+ buf.write("\7g\2\2\u0944\u0945\7u\2\2\u0945\u0946\7v\2\2\u0946\u0947")
+ buf.write("\7k\2\2\u0947\u0948\7q\2\2\u0948\u0949\7p\2\2\u0949\u094a")
+ buf.write("\7t\2\2\u094a\u094b\7g\2\2\u094b\u094c\7h\2\2\u094c\u094d")
+ buf.write("\7x\2\2\u094d\u094e\7c\2\2\u094e\u094f\7n\2\2\u094f\u01ce")
+ buf.write("\3\2\2\2\u0950\u0951\7u\2\2\u0951\u0952\7v\2\2\u0952\u0953")
+ buf.write("\7t\2\2\u0953\u0954\7k\2\2\u0954\u0955\7p\2\2\u0955\u0956")
+ buf.write("\7i\2\2\u0956\u0957\7t\2\2\u0957\u0958\7g\2\2\u0958\u0959")
+ buf.write("\7h\2\2\u0959\u095a\7x\2\2\u095a\u095b\7c\2\2\u095b\u095c")
+ buf.write("\7n\2\2\u095c\u01d0\3\2\2\2\u095d\u095e\7o\2\2\u095e\u095f")
+ buf.write("\7c\2\2\u095f\u0960\7r\2\2\u0960\u01d2\3\2\2\2\u0961\u0962")
+ buf.write("\7t\2\2\u0962\u0963\7g\2\2\u0963\u0964\7h\2\2\u0964\u0965")
+ buf.write("\7t\2\2\u0965\u0966\7g\2\2\u0966\u0967\7u\2\2\u0967\u0968")
+ buf.write("\7j\2\2\u0968\u0969\7i\2\2\u0969\u096a\7w\2\2\u096a\u096b")
+ buf.write("\7k\2\2\u096b\u096c\7f\2\2\u096c\u01d4\3\2\2\2\u096d\u096e")
+ buf.write("\7U\2\2\u096e\u096f\7V\2\2\u096f\u0970\7T\2\2\u0970\u0971")
+ buf.write("\7K\2\2\u0971\u0972\7P\2\2\u0972\u0973\7I\2\2\u0973\u0974")
+ buf.write("\7a\2\2\u0974\u0975\7V\2\2\u0975\u0976\7Q\2\2\u0976\u0977")
+ buf.write("\7M\2\2\u0977\u0978\7G\2\2\u0978\u0979\7P\2\2\u0979\u01d6")
+ buf.write("\3\2\2\2\u097a\u097b\7Q\2\2\u097b\u097c\7R\2\2\u097c\u097d")
+ buf.write("\7V\2\2\u097d\u097e\7K\2\2\u097e\u097f\7Q\2\2\u097f\u0980")
+ buf.write("\7P\2\2\u0980\u0981\7a\2\2\u0981\u0982\7F\2\2\u0982\u0983")
+ buf.write("\7G\2\2\u0983\u0984\7H\2\2\u0984\u0985\7C\2\2\u0985\u0986")
+ buf.write("\7W\2\2\u0986\u0987\7N\2\2\u0987\u0988\7V\2\2\u0988\u01d8")
+ buf.write("\3\2\2\2\u0989\u098a\7Q\2\2\u098a\u098b\7R\2\2\u098b\u098c")
+ buf.write("\7V\2\2\u098c\u098d\7K\2\2\u098d\u098e\7Q\2\2\u098e\u098f")
+ buf.write("\7P\2\2\u098f\u0990\7a\2\2\u0990\u0991\7F\2\2\u0991\u0992")
+ buf.write("\7G\2\2\u0992\u0993\7H\2\2\u0993\u0994\7C\2\2\u0994\u0995")
+ buf.write("\7W\2\2\u0995\u0996\7N\2\2\u0996\u0997\7V\2\2\u0997\u0998")
+ buf.write("\7a\2\2\u0998\u0999\7O\2\2\u0999\u099a\7H\2\2\u099a\u099b")
+ buf.write("\7I\2\2\u099b\u01da\3\2\2\2\u099c\u099d\7P\2\2\u099d\u099e")
+ buf.write("\7W\2\2\u099e\u099f\7O\2\2\u099f\u09a0\7G\2\2\u09a0\u09a1")
+ buf.write("\7T\2\2\u09a1\u09a2\7K\2\2\u09a2\u09a3\7E\2\2\u09a3\u09a4")
+ buf.write("\7a\2\2\u09a4\u09a5\7U\2\2\u09a5\u09a6\7K\2\2\u09a6\u09a7")
+ buf.write("\7\\\2\2\u09a7\u09a8\7G\2\2\u09a8\u09a9\7a\2\2\u09a9\u09aa")
+ buf.write("\7\63\2\2\u09aa\u01dc\3\2\2\2\u09ab\u09ac\7P\2\2\u09ac")
+ buf.write("\u09ad\7W\2\2\u09ad\u09ae\7O\2\2\u09ae\u09af\7G\2\2\u09af")
+ buf.write("\u09b0\7T\2\2\u09b0\u09b1\7K\2\2\u09b1\u09b2\7E\2\2\u09b2")
+ buf.write("\u09b3\7a\2\2\u09b3\u09b4\7U\2\2\u09b4\u09b5\7K\2\2\u09b5")
+ buf.write("\u09b6\7\\\2\2\u09b6\u09b7\7G\2\2\u09b7\u09b8\7a\2\2\u09b8")
+ buf.write("\u09b9\7\64\2\2\u09b9\u01de\3\2\2\2\u09ba\u09bb\7P\2\2")
+ buf.write("\u09bb\u09bc\7W\2\2\u09bc\u09bd\7O\2\2\u09bd\u09be\7G")
+ buf.write("\2\2\u09be\u09bf\7T\2\2\u09bf\u09c0\7K\2\2\u09c0\u09c1")
+ buf.write("\7E\2\2\u09c1\u09c2\7a\2\2\u09c2\u09c3\7U\2\2\u09c3\u09c4")
+ buf.write("\7K\2\2\u09c4\u09c5\7\\\2\2\u09c5\u09c6\7G\2\2\u09c6\u09c7")
+ buf.write("\7a\2\2\u09c7\u09c8\7\66\2\2\u09c8\u01e0\3\2\2\2\u09c9")
+ buf.write("\u09ca\7P\2\2\u09ca\u09cb\7W\2\2\u09cb\u09cc\7O\2\2\u09cc")
+ buf.write("\u09cd\7G\2\2\u09cd\u09ce\7T\2\2\u09ce\u09cf\7K\2\2\u09cf")
+ buf.write("\u09d0\7E\2\2\u09d0\u09d1\7a\2\2\u09d1\u09d2\7U\2\2\u09d2")
+ buf.write("\u09d3\7K\2\2\u09d3\u09d4\7\\\2\2\u09d4\u09d5\7G\2\2\u09d5")
+ buf.write("\u09d6\7a\2\2\u09d6\u09d7\7:\2\2\u09d7\u01e2\3\2\2\2\u09d8")
+ buf.write("\u09d9\7F\2\2\u09d9\u09da\7K\2\2\u09da\u09db\7U\2\2\u09db")
+ buf.write("\u09dc\7R\2\2\u09dc\u09dd\7N\2\2\u09dd\u09de\7C\2\2\u09de")
+ buf.write("\u09df\7[\2\2\u09df\u09e0\7a\2\2\u09e0\u09e1\7K\2\2\u09e1")
+ buf.write("\u09e2\7P\2\2\u09e2\u09e3\7V\2\2\u09e3\u09e4\7a\2\2\u09e4")
+ buf.write("\u09e5\7F\2\2\u09e5\u09e6\7G\2\2\u09e6\u09e7\7E\2\2\u09e7")
+ buf.write("\u01e4\3\2\2\2\u09e8\u09e9\7F\2\2\u09e9\u09ea\7K\2\2\u09ea")
+ buf.write("\u09eb\7U\2\2\u09eb\u09ec\7R\2\2\u09ec\u09ed\7N\2\2\u09ed")
+ buf.write("\u09ee\7C\2\2\u09ee\u09ef\7[\2\2\u09ef\u09f0\7a\2\2\u09f0")
+ buf.write("\u09f1\7W\2\2\u09f1\u09f2\7K\2\2\u09f2\u09f3\7P\2\2\u09f3")
+ buf.write("\u09f4\7V\2\2\u09f4\u09f5\7a\2\2\u09f5\u09f6\7F\2\2\u09f6")
+ buf.write("\u09f7\7G\2\2\u09f7\u09f8\7E\2\2\u09f8\u01e6\3\2\2\2\u09f9")
+ buf.write("\u09fa\7F\2\2\u09fa\u09fb\7K\2\2\u09fb\u09fc\7U\2\2\u09fc")
+ buf.write("\u09fd\7R\2\2\u09fd\u09fe\7N\2\2\u09fe\u09ff\7C\2\2\u09ff")
+ buf.write("\u0a00\7[\2\2\u0a00\u0a01\7a\2\2\u0a01\u0a02\7W\2\2\u0a02")
+ buf.write("\u0a03\7K\2\2\u0a03\u0a04\7P\2\2\u0a04\u0a05\7V\2\2\u0a05")
+ buf.write("\u0a06\7a\2\2\u0a06\u0a07\7J\2\2\u0a07\u0a08\7G\2\2\u0a08")
+ buf.write("\u0a09\7Z\2\2\u0a09\u01e8\3\2\2\2\u0a0a\u0a0b\7K\2\2\u0a0b")
+ buf.write("\u0a0c\7P\2\2\u0a0c\u0a0d\7U\2\2\u0a0d\u0a0e\7G\2\2\u0a0e")
+ buf.write("\u0a0f\7P\2\2\u0a0f\u0a10\7U\2\2\u0a10\u0a11\7K\2\2\u0a11")
+ buf.write("\u0a12\7V\2\2\u0a12\u0a13\7K\2\2\u0a13\u0a14\7X\2\2\u0a14")
+ buf.write("\u0a15\7G\2\2\u0a15\u01ea\3\2\2\2\u0a16\u0a17\7U\2\2\u0a17")
+ buf.write("\u0a18\7G\2\2\u0a18\u0a19\7P\2\2\u0a19\u0a1a\7U\2\2\u0a1a")
+ buf.write("\u0a1b\7K\2\2\u0a1b\u0a1c\7V\2\2\u0a1c\u0a1d\7K\2\2\u0a1d")
+ buf.write("\u0a1e\7X\2\2\u0a1e\u0a1f\7G\2\2\u0a1f\u01ec\3\2\2\2\u0a20")
+ buf.write("\u0a21\7N\2\2\u0a21\u0a22\7C\2\2\u0a22\u0a23\7U\2\2\u0a23")
+ buf.write("\u0a24\7V\2\2\u0a24\u0a25\7a\2\2\u0a25\u0a26\7P\2\2\u0a26")
+ buf.write("\u0a27\7Q\2\2\u0a27\u0a28\7P\2\2\u0a28\u0a29\7a\2\2\u0a29")
+ buf.write("\u0a2a\7O\2\2\u0a2a\u0a2b\7C\2\2\u0a2b\u0a2c\7V\2\2\u0a2c")
+ buf.write("\u0a2d\7E\2\2\u0a2d\u0a2e\7J\2\2\u0a2e\u01ee\3\2\2\2\u0a2f")
+ buf.write("\u0a30\7H\2\2\u0a30\u0a31\7K\2\2\u0a31\u0a32\7T\2\2\u0a32")
+ buf.write("\u0a33\7U\2\2\u0a33\u0a34\7V\2\2\u0a34\u0a35\7a\2\2\u0a35")
+ buf.write("\u0a36\7P\2\2\u0a36\u0a37\7Q\2\2\u0a37\u0a38\7P\2\2\u0a38")
+ buf.write("\u0a39\7a\2\2\u0a39\u0a3a\7O\2\2\u0a3a\u0a3b\7C\2\2\u0a3b")
+ buf.write("\u0a3c\7V\2\2\u0a3c\u0a3d\7E\2\2\u0a3d\u0a3e\7J\2\2\u0a3e")
+ buf.write("\u01f0\3\2\2\2\u0a3f\u0a40\7\62\2\2\u0a40\u0a41\7z\2\2")
+ buf.write("\u0a41\u0a43\3\2\2\2\u0a42\u0a44\t\2\2\2\u0a43\u0a42\3")
+ buf.write("\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46")
+ buf.write("\3\2\2\2\u0a46\u0a4d\3\2\2\2\u0a47\u0a49\t\3\2\2\u0a48")
+ buf.write("\u0a47\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a48\3\2\2\2")
+ buf.write("\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4d\3\2\2\2\u0a4c\u0a3f\3")
+ buf.write("\2\2\2\u0a4c\u0a48\3\2\2\2\u0a4d\u01f2\3\2\2\2\u0a4e\u0a52")
+ buf.write("\t\4\2\2\u0a4f\u0a51\t\5\2\2\u0a50\u0a4f\3\2\2\2\u0a51")
+ buf.write("\u0a54\3\2\2\2\u0a52\u0a50\3\2\2\2\u0a52\u0a53\3\2\2\2")
+ buf.write("\u0a53\u01f4\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a55\u0a57\7")
+ buf.write("%\2\2\u0a56\u0a58\5\u01fb\u00fe\2\u0a57\u0a56\3\2\2\2")
+ buf.write("\u0a57\u0a58\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\7")
+ buf.write("f\2\2\u0a5a\u0a5b\7g\2\2\u0a5b\u0a5c\7h\2\2\u0a5c\u0a5d")
+ buf.write("\7k\2\2\u0a5d\u0a5e\7p\2\2\u0a5e\u0a5f\7g\2\2\u0a5f\u0a63")
+ buf.write("\3\2\2\2\u0a60\u0a62\n\6\2\2\u0a61\u0a60\3\2\2\2\u0a62")
+ buf.write("\u0a65\3\2\2\2\u0a63\u0a61\3\2\2\2\u0a63\u0a64\3\2\2\2")
+ buf.write("\u0a64\u0a66\3\2\2\2\u0a65\u0a63\3\2\2\2\u0a66\u0a67\b")
+ buf.write("\u00fb\2\2\u0a67\u01f6\3\2\2\2\u0a68\u0a6a\7%\2\2\u0a69")
+ buf.write("\u0a6b\5\u01fb\u00fe\2\u0a6a\u0a69\3\2\2\2\u0a6a\u0a6b")
+ buf.write("\3\2\2\2\u0a6b\u0a6c\3\2\2\2\u0a6c\u0a6d\7n\2\2\u0a6d")
+ buf.write("\u0a6e\7k\2\2\u0a6e\u0a6f\7p\2\2\u0a6f\u0a70\7g\2\2\u0a70")
+ buf.write("\u0a74\3\2\2\2\u0a71\u0a73\n\6\2\2\u0a72\u0a71\3\2\2\2")
+ buf.write("\u0a73\u0a76\3\2\2\2\u0a74\u0a72\3\2\2\2\u0a74\u0a75\3")
+ buf.write("\2\2\2\u0a75\u0a77\3\2\2\2\u0a76\u0a74\3\2\2\2\u0a77\u0a78")
+ buf.write("\b\u00fc\2\2\u0a78\u01f8\3\2\2\2\u0a79\u0a7b\7%\2\2\u0a7a")
+ buf.write("\u0a7c\5\u01fb\u00fe\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c")
+ buf.write("\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7e\7k\2\2\u0a7e")
+ buf.write("\u0a7f\7p\2\2\u0a7f\u0a80\7e\2\2\u0a80\u0a81\7n\2\2\u0a81")
+ buf.write("\u0a82\7w\2\2\u0a82\u0a83\7f\2\2\u0a83\u0a84\7g\2\2\u0a84")
+ buf.write("\u0a88\3\2\2\2\u0a85\u0a87\n\6\2\2\u0a86\u0a85\3\2\2\2")
+ buf.write("\u0a87\u0a8a\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a88\u0a89\3")
+ buf.write("\2\2\2\u0a89\u0a8b\3\2\2\2\u0a8a\u0a88\3\2\2\2\u0a8b\u0a8c")
+ buf.write("\b\u00fd\2\2\u0a8c\u01fa\3\2\2\2\u0a8d\u0a8f\t\7\2\2\u0a8e")
+ buf.write("\u0a8d\3\2\2\2\u0a8f\u0a90\3\2\2\2\u0a90\u0a8e\3\2\2\2")
+ buf.write("\u0a90\u0a91\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a93\b")
+ buf.write("\u00fe\2\2\u0a93\u01fc\3\2\2\2\u0a94\u0a96\7\17\2\2\u0a95")
+ buf.write("\u0a97\7\f\2\2\u0a96\u0a95\3\2\2\2\u0a96\u0a97\3\2\2\2")
+ buf.write("\u0a97\u0a9a\3\2\2\2\u0a98\u0a9a\7\f\2\2\u0a99\u0a94\3")
+ buf.write("\2\2\2\u0a99\u0a98\3\2\2\2\u0a9a\u0a9b\3\2\2\2\u0a9b\u0a9c")
+ buf.write("\b\u00ff\2\2\u0a9c\u01fe\3\2\2\2\u0a9d\u0a9e\7\61\2\2")
+ buf.write("\u0a9e\u0a9f\7\61\2\2\u0a9f\u0aa3\3\2\2\2\u0aa0\u0aa2")
+ buf.write("\n\b\2\2\u0aa1\u0aa0\3\2\2\2\u0aa2\u0aa5\3\2\2\2\u0aa3")
+ buf.write("\u0aa1\3\2\2\2\u0aa3\u0aa4\3\2\2\2\u0aa4\u0aa6\3\2\2\2")
+ buf.write("\u0aa5\u0aa3\3\2\2\2\u0aa6\u0aa7\b\u0100\2\2\u0aa7\u0200")
+ buf.write("\3\2\2\2\u0aa8\u0aa9\7g\2\2\u0aa9\u0aaa\7z\2\2\u0aaa\u0aab")
+ buf.write("\7v\2\2\u0aab\u0aac\7g\2\2\u0aac\u0aad\7t\2\2\u0aad\u0aae")
+ buf.write("\7p\2\2\u0aae\u0ab2\3\2\2\2\u0aaf\u0ab1\n\6\2\2\u0ab0")
+ buf.write("\u0aaf\3\2\2\2\u0ab1\u0ab4\3\2\2\2\u0ab2\u0ab0\3\2\2\2")
+ buf.write("\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0ab2\3")
+ buf.write("\2\2\2\u0ab5\u0ab6\b\u0101\2\2\u0ab6\u0202\3\2\2\2\22")
+ buf.write("\2\u0a45\u0a4a\u0a4c\u0a52\u0a57\u0a63\u0a6a\u0a74\u0a7b")
+ buf.write("\u0a88\u0a90\u0a96\u0a99\u0aa3\u0ab2\3\b\2\2")
+ return buf.getvalue()
+
+
+class VfrSyntaxLexer(Lexer):
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ T__0 = 1
+ T__1 = 2
+ T__2 = 3
+ T__3 = 4
+ T__4 = 5
+ T__5 = 6
+ T__6 = 7
+ T__7 = 8
+ T__8 = 9
+ T__9 = 10
+ T__10 = 11
+ T__11 = 12
+ T__12 = 13
+ T__13 = 14
+ T__14 = 15
+ T__15 = 16
+ Define = 17
+ Include = 18
+ FormPkgType = 19
+ OpenBrace = 20
+ CloseBrace = 21
+ OpenParen = 22
+ CloseParen = 23
+ OpenBracket = 24
+ CloseBracket = 25
+ Dot = 26
+ Negative = 27
+ Colon = 28
+ Slash = 29
+ Semicolon = 30
+ Comma = 31
+ Equal = 32
+ NotEqual = 33
+ LessEqual = 34
+ Less = 35
+ GreaterEqual = 36
+ Greater = 37
+ BitWiseOr = 38
+ BitWiseAnd = 39
+ DevicePath = 40
+ FormSet = 41
+ FormSetId = 42
+ EndFormSet = 43
+ Title = 44
+ FormId = 45
+ OneOf = 46
+ EndOneOf = 47
+ Prompt = 48
+ OrderedList = 49
+ MaxContainers = 50
+ EndList = 51
+ EndForm = 52
+ Form = 53
+ FormMap = 54
+ MapTitle = 55
+ MapGuid = 56
+ Subtitle = 57
+ EndSubtitle = 58
+ Help = 59
+ Text = 60
+ Option = 61
+ FLAGS = 62
+ Date = 63
+ EndDate = 64
+ Year = 65
+ Month = 66
+ Day = 67
+ Time = 68
+ EndTime = 69
+ Hour = 70
+ Minute = 71
+ Second = 72
+ GrayOutIf = 73
+ Label = 74
+ Timeout = 75
+ Inventory = 76
+ NonNvDataMap = 77
+ Struct = 78
+ Union = 79
+ Boolean = 80
+ Uint64 = 81
+ Uint32 = 82
+ Uint16 = 83
+ Uint8 = 84
+ EFI_STRING_ID = 85
+ EFI_HII_DATE = 86
+ EFI_HII_TIME = 87
+ EFI_HII_REF = 88
+ Uuid = 89
+ CheckBox = 90
+ EndCheckBox = 91
+ Numeric = 92
+ EndNumeric = 93
+ Minimum = 94
+ Maximum = 95
+ Step = 96
+ Default = 97
+ Password = 98
+ EndPassword = 99
+ String = 100
+ EndString = 101
+ MinSize = 102
+ MaxSize = 103
+ Encoding = 104
+ SuppressIf = 105
+ DisableIf = 106
+ Hidden = 107
+ Goto = 108
+ FormSetGuid = 109
+ InconsistentIf = 110
+ WarningIf = 111
+ NoSubmitIf = 112
+ EndIf = 113
+ Key = 114
+ DefaultFlag = 115
+ ManufacturingFlag = 116
+ CheckBoxDefaultFlag = 117
+ CheckBoxDefaultMfgFlag = 118
+ InteractiveFlag = 119
+ NVAccessFlag = 120
+ ResetRequiredFlag = 121
+ ReconnectRequiredFlag = 122
+ LateCheckFlag = 123
+ ReadOnlyFlag = 124
+ OptionOnlyFlag = 125
+ RestStyleFlag = 126
+ Class = 127
+ Subclass = 128
+ ClassGuid = 129
+ TypeDef = 130
+ Restore = 131
+ Save = 132
+ Defaults = 133
+ Banner = 134
+ Align = 135
+ Left = 136
+ Right = 137
+ Center = 138
+ Line = 139
+ Name = 140
+ VarId = 141
+ Question = 142
+ QuestionId = 143
+ Image = 144
+ Locked = 145
+ Rule = 146
+ EndRule = 147
+ Value = 148
+ Read = 149
+ Write = 150
+ ResetButton = 151
+ EndResetButton = 152
+ DefaultStore = 153
+ Attribute = 154
+ Varstore = 155
+ Efivarstore = 156
+ VarSize = 157
+ NameValueVarStore = 158
+ Action = 159
+ Config = 160
+ EndAction = 161
+ Refresh = 162
+ Interval = 163
+ VarstoreDevice = 164
+ GuidOp = 165
+ EndGuidOp = 166
+ DataType = 167
+ Data = 168
+ Modal = 169
+ ClassNonDevice = 170
+ ClassDiskDevice = 171
+ ClassVideoDevice = 172
+ ClassNetworkDevice = 173
+ ClassInputDevice = 174
+ ClassOnBoardDevice = 175
+ ClassOtherDevice = 176
+ SubclassSetupApplication = 177
+ SubclassGeneralApplication = 178
+ SubclassFrontPage = 179
+ SubclassSingleUse = 180
+ YearSupppressFlag = 181
+ MonthSuppressFlag = 182
+ DaySuppressFlag = 183
+ HourSupppressFlag = 184
+ MinuteSuppressFlag = 185
+ SecondSuppressFlag = 186
+ StorageNormalFlag = 187
+ StorageTimeFlag = 188
+ StorageWakeUpFlag = 189
+ UniQueFlag = 190
+ NoEmptyFlag = 191
+ Cond = 192
+ Find = 193
+ Mid = 194
+ Tok = 195
+ Span = 196
+ Dup = 197
+ VarEqVal = 198
+ Var = 199
+ IdEqVal = 200
+ IdEqId = 201
+ IdEqValList = 202
+ QuestionRef = 203
+ RuleRef = 204
+ StringRef = 205
+ PushThis = 206
+ Security = 207
+ Get = 208
+ TrueSymbol = 209
+ FalseSymbol = 210
+ One = 211
+ Ones = 212
+ Zero = 213
+ Undefined = 214
+ Version = 215
+ Length = 216
+ AND = 217
+ OR = 218
+ NOT = 219
+ Set = 220
+ BitWiseNot = 221
+ BoolVal = 222
+ StringVal = 223
+ UnIntVal = 224
+ ToUpper = 225
+ ToLower = 226
+ Match = 227
+ Match2 = 228
+ Catenate = 229
+ QuestionRefVal = 230
+ StringRefVal = 231
+ Map = 232
+ RefreshGuid = 233
+ StringToken = 234
+ OptionDefault = 235
+ OptionDefaultMfg = 236
+ NumericSizeOne = 237
+ NumericSizeTwo = 238
+ NumericSizeFour = 239
+ NumericSizeEight = 240
+ DisPlayIntDec = 241
+ DisPlayUIntDec = 242
+ DisPlayUIntHex = 243
+ Insensitive = 244
+ Sensitive = 245
+ LastNonMatch = 246
+ FirstNonMatch = 247
+ Number = 248
+ StringIdentifier = 249
+ ComplexDefine = 250
+ LineDefinition = 251
+ IncludeDefinition = 252
+ Whitespace = 253
+ Newline = 254
+ LineComment = 255
+ Extern = 256
+
+ channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+ modeNames = [ "DEFAULT_MODE" ]
+
+ literalNames = [ "<INVALID>",
+ "'show'", "'push'", "'pop'", "'#pragma'", "'pack'", "'='", "'IMAGE_TOKEN'",
+ "'HORIZONTAL'", "'MULTI_LINE'", "'<<'", "'>>'", "'+'", "'*'",
+ "'%'", "'format'", "'?'", "'#define'", "'#include'", "'formpkgtype'",
+ "'{'", "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
+ "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'", "'>='",
+ "'>'", "'|'", "'&'", "'devicepath'", "'formset'", "'formsetid'",
+ "'endformset'", "'title'", "'formid'", "'oneof'", "'endoneof'",
+ "'prompt'", "'orderedlist'", "'maxcontainers'", "'endlist'",
+ "'endform'", "'form'", "'formmap'", "'maptitle'", "'mapguid'",
+ "'subtitle'", "'endsubtitle'", "'help'", "'text'", "'option'",
+ "'flags'", "'date'", "'enddate'", "'year'", "'month'", "'day'",
+ "'time'", "'endtime'", "'hour'", "'minute'", "'second'", "'grayoutif'",
+ "'label'", "'timeout'", "'inventory'", "'_NON_NV_DATA_MAP'",
+ "'struct'", "'union'", "'BOOLEAN'", "'UINT64'", "'UINT32'",
+ "'UINT16'", "'UINT8'", "'EFI_STRING_ID'", "'EFI_HII_DATE'",
+ "'EFI_HII_TIME'", "'EFI_HII_REF'", "'guid'", "'checkbox'", "'endcheckbox'",
+ "'numeric'", "'endnumeric'", "'minimum'", "'maximum'", "'step'",
+ "'default'", "'password'", "'endpassword'", "'string'", "'endstring'",
+ "'minsize'", "'maxsize'", "'encoding'", "'suppressif'", "'disableif'",
+ "'hidden'", "'goto'", "'formsetguid'", "'inconsistentif'", "'warningif'",
+ "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'",
+ "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'", "'INTERACTIVE'",
+ "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'", "'LATE_CHECK'",
+ "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'", "'class'",
+ "'subclass'", "'classguid'", "'typedef'", "'restore'", "'save'",
+ "'defaults'", "'banner'", "'align'", "'left'", "'right'", "'center'",
+ "'line'", "'name'", "'varid'", "'question'", "'questionid'",
+ "'image'", "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
+ "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
+ "'attribute'", "'varstore'", "'efivarstore'", "'varsize'", "'namevaluevarstore'",
+ "'action'", "'config'", "'endaction'", "'refresh'", "'interval'",
+ "'varstoredevice'", "'guidop'", "'endguidop'", "'datatype'",
+ "'data'", "'modal'", "'NON_DEVICE'", "'DISK_DEVICE'", "'VIDEO_DEVICE'",
+ "'NETWORK_DEVICE'", "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'",
+ "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'",
+ "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'", "'DAY_SUPPRESS'",
+ "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'", "'SECOND_SUPPRESS'",
+ "'STORAGE_NORMAL'", "'STORAGE_TIME'", "'STORAGE_WAKEUP'", "'UNIQUE'",
+ "'NOEMPTY'", "'cond'", "'find'", "'mid'", "'token'", "'span'",
+ "'dup'", "'vareqval'", "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
+ "'questionref'", "'ruleref'", "'stringref'", "'pushthis'", "'security'",
+ "'get'", "'TRUE'", "'FALSE'", "'ONE'", "'ONES'", "'ZERO'", "'UNDEFINED'",
+ "'VERSION'", "'length'", "'AND'", "'OR'", "'NOT'", "'set'",
+ "'~'", "'boolval'", "'stringval'", "'unintval'", "'toupper'",
+ "'tolower'", "'match'", "'match2'", "'catenate'", "'questionrefval'",
+ "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
+ "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'", "'NUMERIC_SIZE_1'",
+ "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
+ "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'",
+ "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'", "'FIRST_NON_MATCH'" ]
+
+ symbolicNames = [ "<INVALID>",
+ "Define", "Include", "FormPkgType", "OpenBrace", "CloseBrace",
+ "OpenParen", "CloseParen", "OpenBracket", "CloseBracket", "Dot",
+ "Negative", "Colon", "Slash", "Semicolon", "Comma", "Equal",
+ "NotEqual", "LessEqual", "Less", "GreaterEqual", "Greater",
+ "BitWiseOr", "BitWiseAnd", "DevicePath", "FormSet", "FormSetId",
+ "EndFormSet", "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
+ "OrderedList", "MaxContainers", "EndList", "EndForm", "Form",
+ "FormMap", "MapTitle", "MapGuid", "Subtitle", "EndSubtitle",
+ "Help", "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
+ "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
+ "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
+ "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
+ "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME", "EFI_HII_REF",
+ "Uuid", "CheckBox", "EndCheckBox", "Numeric", "EndNumeric",
+ "Minimum", "Maximum", "Step", "Default", "Password", "EndPassword",
+ "String", "EndString", "MinSize", "MaxSize", "Encoding", "SuppressIf",
+ "DisableIf", "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
+ "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag",
+ "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag",
+ "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
+ "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag",
+ "Class", "Subclass", "ClassGuid", "TypeDef", "Restore", "Save",
+ "Defaults", "Banner", "Align", "Left", "Right", "Center", "Line",
+ "Name", "VarId", "Question", "QuestionId", "Image", "Locked",
+ "Rule", "EndRule", "Value", "Read", "Write", "ResetButton",
+ "EndResetButton", "DefaultStore", "Attribute", "Varstore", "Efivarstore",
+ "VarSize", "NameValueVarStore", "Action", "Config", "EndAction",
+ "Refresh", "Interval", "VarstoreDevice", "GuidOp", "EndGuidOp",
+ "DataType", "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
+ "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
+ "ClassOnBoardDevice", "ClassOtherDevice", "SubclassSetupApplication",
+ "SubclassGeneralApplication", "SubclassFrontPage", "SubclassSingleUse",
+ "YearSupppressFlag", "MonthSuppressFlag", "DaySuppressFlag",
+ "HourSupppressFlag", "MinuteSuppressFlag", "SecondSuppressFlag",
+ "StorageNormalFlag", "StorageTimeFlag", "StorageWakeUpFlag",
+ "UniQueFlag", "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span",
+ "Dup", "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
+ "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
+ "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero", "Undefined",
+ "Version", "Length", "AND", "OR", "NOT", "Set", "BitWiseNot",
+ "BoolVal", "StringVal", "UnIntVal", "ToUpper", "ToLower", "Match",
+ "Match2", "Catenate", "QuestionRefVal", "StringRefVal", "Map",
+ "RefreshGuid", "StringToken", "OptionDefault", "OptionDefaultMfg",
+ "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour", "NumericSizeEight",
+ "DisPlayIntDec", "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive",
+ "Sensitive", "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier",
+ "ComplexDefine", "LineDefinition", "IncludeDefinition", "Whitespace",
+ "Newline", "LineComment", "Extern" ]
+
+ ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
+ "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
+ "T__14", "T__15", "Define", "Include", "FormPkgType",
+ "OpenBrace", "CloseBrace", "OpenParen", "CloseParen",
+ "OpenBracket", "CloseBracket", "Dot", "Negative", "Colon",
+ "Slash", "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
+ "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
+ "DevicePath", "FormSet", "FormSetId", "EndFormSet", "Title",
+ "FormId", "OneOf", "EndOneOf", "Prompt", "OrderedList",
+ "MaxContainers", "EndList", "EndForm", "Form", "FormMap",
+ "MapTitle", "MapGuid", "Subtitle", "EndSubtitle", "Help",
+ "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
+ "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
+ "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
+ "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
+ "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
+ "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox", "Numeric",
+ "EndNumeric", "Minimum", "Maximum", "Step", "Default",
+ "Password", "EndPassword", "String", "EndString", "MinSize",
+ "MaxSize", "Encoding", "SuppressIf", "DisableIf", "Hidden",
+ "Goto", "FormSetGuid", "InconsistentIf", "WarningIf",
+ "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag",
+ "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag",
+ "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
+ "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag",
+ "Class", "Subclass", "ClassGuid", "TypeDef", "Restore",
+ "Save", "Defaults", "Banner", "Align", "Left", "Right",
+ "Center", "Line", "Name", "VarId", "Question", "QuestionId",
+ "Image", "Locked", "Rule", "EndRule", "Value", "Read",
+ "Write", "ResetButton", "EndResetButton", "DefaultStore",
+ "Attribute", "Varstore", "Efivarstore", "VarSize", "NameValueVarStore",
+ "Action", "Config", "EndAction", "Refresh", "Interval",
+ "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType", "Data",
+ "Modal", "ClassNonDevice", "ClassDiskDevice", "ClassVideoDevice",
+ "ClassNetworkDevice", "ClassInputDevice", "ClassOnBoardDevice",
+ "ClassOtherDevice", "SubclassSetupApplication", "SubclassGeneralApplication",
+ "SubclassFrontPage", "SubclassSingleUse", "YearSupppressFlag",
+ "MonthSuppressFlag", "DaySuppressFlag", "HourSupppressFlag",
+ "MinuteSuppressFlag", "SecondSuppressFlag", "StorageNormalFlag",
+ "StorageTimeFlag", "StorageWakeUpFlag", "UniQueFlag",
+ "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span", "Dup",
+ "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
+ "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
+ "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
+ "Undefined", "Version", "Length", "AND", "OR", "NOT",
+ "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
+ "ToUpper", "ToLower", "Match", "Match2", "Catenate", "QuestionRefVal",
+ "StringRefVal", "Map", "RefreshGuid", "StringToken", "OptionDefault",
+ "OptionDefaultMfg", "NumericSizeOne", "NumericSizeTwo",
+ "NumericSizeFour", "NumericSizeEight", "DisPlayIntDec",
+ "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive", "Sensitive",
+ "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier",
+ "ComplexDefine", "LineDefinition", "IncludeDefinition",
+ "Whitespace", "Newline", "LineComment", "Extern" ]
+
+ grammarFileName = "VfrSyntax.g4"
+
+ def __init__(self, input=None, output:TextIO = sys.stdout):
+ super().__init__(input, output)
+ self.checkVersion("4.7.2")
+ self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+ self._actions = None
+ self._predicates = None
diff --git a/edk2basetools/VfrCompiler/VfrSyntaxParser.py b/edk2basetools/VfrCompiler/VfrSyntaxParser.py
new file mode 100644
index 0000000..dc9f300
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrSyntaxParser.py
@@ -0,0 +1,20460 @@
+# Generated from VfrSyntax.g4 by ANTLR 4.7.2
+# encoding: utf-8
+from antlr4 import *
+from io import StringIO
+from typing import TextIO
+import sys
+
+
+
+from VfrCompiler.CommonCtypes import *
+from VfrCompiler.VfrFormPkg import *
+from VfrCompiler.VfrUtility import *
+from VfrCompiler.VfrTree import *
+
+
+def serializedATN():
+ with StringIO() as buf:
+ buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0102")
+ buf.write("\u0ba3\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+ buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
+ buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
+ buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
+ buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
+ buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
+ buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
+ buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
+ buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
+ buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
+ buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
+ buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
+ buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
+ buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
+ buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
+ buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
+ buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
+ buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
+ buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
+ buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
+ buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
+ buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
+ buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
+ buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
+ buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
+ buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
+ buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
+ buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
+ buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
+ buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
+ buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
+ buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
+ buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
+ buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
+ buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
+ buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
+ buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
+ buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
+ buf.write("\t\u00ca\4\u00cb\t\u00cb\3\2\3\2\3\2\7\2\u019a\n\2\f\2")
+ buf.write("\16\2\u019d\13\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\5\4\u01a6")
+ buf.write("\n\4\3\4\3\4\5\4\u01aa\n\4\3\5\5\5\u01ad\n\5\3\6\3\6\3")
+ buf.write("\6\3\6\3\6\3\6\5\6\u01b5\n\6\3\6\3\6\3\7\5\7\u01ba\n\7")
+ buf.write("\3\7\3\7\5\7\u01be\n\7\3\7\5\7\u01c1\n\7\3\7\3\7\3\7\3")
+ buf.write("\7\5\7\u01c7\n\7\3\7\3\7\3\b\5\b\u01cc\n\b\3\b\3\b\5\b")
+ buf.write("\u01d0\n\b\3\b\5\b\u01d3\n\b\3\b\3\b\3\b\3\b\5\b\u01d9")
+ buf.write("\n\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
+ buf.write("\t\3\t\3\t\3\t\7\t\u01eb\n\t\f\t\16\t\u01ee\13\t\3\n\3")
+ buf.write("\n\3\n\3\n\3\n\5\n\u01f5\n\n\3\n\3\n\3\13\3\13\3\13\3")
+ buf.write("\13\3\13\5\13\u01fe\n\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f")
+ buf.write("\5\f\u0207\n\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\5\r\u0210\n")
+ buf.write("\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\5\16\u0219\n\16\3")
+ buf.write("\16\3\16\3\17\3\17\3\17\3\17\3\17\5\17\u0222\n\17\3\17")
+ buf.write("\3\17\3\20\3\20\3\20\3\20\3\20\5\20\u022b\n\20\3\20\3")
+ buf.write("\20\3\21\3\21\3\21\3\21\3\21\5\21\u0234\n\21\3\21\3\21")
+ buf.write("\3\22\3\22\3\22\3\22\3\22\5\22\u023d\n\22\3\22\3\22\3")
+ buf.write("\23\3\23\3\23\3\23\3\23\5\23\u0246\n\23\3\23\3\23\3\24")
+ buf.write("\3\24\5\24\u024c\n\24\3\24\3\24\3\24\3\24\3\25\3\25\5")
+ buf.write("\25\u0254\n\25\3\25\3\25\3\25\3\25\3\26\3\26\5\26\u025c")
+ buf.write("\n\26\3\26\3\26\3\26\3\26\3\27\3\27\5\27\u0264\n\27\3")
+ buf.write("\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
+ buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
+ buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0282\n\30\3\30\3")
+ buf.write("\30\3\30\3\30\3\30\5\30\u0289\n\30\3\30\3\30\3\30\3\30")
+ buf.write("\3\30\5\30\u0290\n\30\3\30\3\30\3\30\3\30\3\31\3\31\3")
+ buf.write("\31\5\31\u0299\n\31\3\31\3\31\5\31\u029d\n\31\3\31\3\31")
+ buf.write("\5\31\u02a1\n\31\3\32\3\32\3\32\7\32\u02a6\n\32\f\32\16")
+ buf.write("\32\u02a9\13\32\3\33\3\33\3\34\3\34\3\35\7\35\u02b0\n")
+ buf.write("\35\f\35\16\35\u02b3\13\35\3\36\3\36\3\36\3\36\3\36\3")
+ buf.write("\36\3\36\3\36\3\36\3\36\5\36\u02bf\n\36\3\37\3\37\3\37")
+ buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\5\37")
+ buf.write("\u02ce\n\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3")
+ buf.write(" \3 \3 \3 \3 \3 \3 \5 \u02e3\n \3 \3 \3 \3 \5 \u02e9\n")
+ buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3!\3!\3")
+ buf.write("!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0305\n!\3!\3!\3!\3!\5!\u030b")
+ buf.write("\n!\3!\3!\3!\3!\3!\7!\u0312\n!\f!\16!\u0315\13!\3!\3!")
+ buf.write("\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0327\n")
+ buf.write("!\3!\3!\3!\3!\3!\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\5#\u0337")
+ buf.write("\n#\3#\3#\3#\3#\3#\3#\3#\6#\u0340\n#\r#\16#\u0341\3#\3")
+ buf.write("#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3")
+ buf.write("&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3\'\3\'")
+ buf.write("\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u0373\n\'")
+ buf.write("\3\'\3\'\3(\3(\3(\3(\3(\3)\3)\3)\3*\3*\3*\3*\5*\u0383")
+ buf.write("\n*\3*\3*\3*\3*\3*\5*\u038a\n*\3*\3*\3*\3*\5*\u0390\n")
+ buf.write("*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\3")
+ buf.write(",\3,\3,\3,\3,\5,\u03a8\n,\3-\3-\3-\3-\3-\3-\3-\7-\u03b1")
+ buf.write("\n-\f-\16-\u03b4\13-\5-\u03b6\n-\3.\5.\u03b9\n.\3.\3.")
+ buf.write("\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3")
+ buf.write(".\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\7.\u03de")
+ buf.write("\n.\f.\16.\u03e1\13.\3.\5.\u03e4\n.\3/\3/\3/\3/\3/\3/")
+ buf.write("\3/\3\60\3\60\3\61\3\61\5\61\u03f1\n\61\3\62\3\62\3\62")
+ buf.write("\7\62\u03f6\n\62\f\62\16\62\u03f9\13\62\3\63\3\63\3\63")
+ buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\7\63")
+ buf.write("\u0408\n\63\f\63\16\63\u040b\13\63\3\63\3\63\3\63\3\64")
+ buf.write("\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64")
+ buf.write("\3\64\3\64\3\64\5\64\u041f\n\64\3\65\3\65\3\65\3\65\3")
+ buf.write("\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
+ buf.write("\3\65\3\65\7\65\u0432\n\65\f\65\16\65\u0435\13\65\3\65")
+ buf.write("\7\65\u0438\n\65\f\65\16\65\u043b\13\65\3\65\3\65\3\65")
+ buf.write("\3\66\3\66\3\66\3\67\3\67\3\67\38\38\38\38\38\38\38\3")
+ buf.write("9\39\39\59\u0450\n9\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\5")
+ buf.write(":\u045d\n:\3:\3:\5:\u0461\n:\3:\3:\3:\5:\u0466\n:\3:\3")
+ buf.write(":\7:\u046a\n:\f:\16:\u046d\13:\5:\u046f\n:\3:\3:\5:\u0473")
+ buf.write("\n:\3;\3;\5;\u0477\n;\3<\3<\3<\7<\u047c\n<\f<\16<\u047f")
+ buf.write("\13<\3=\3=\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3>\3")
+ buf.write(">\3>\3>\3>\3>\3>\3>\5>\u0498\n>\3>\3>\3>\3>\3>\3>\7>\u04a0")
+ buf.write("\n>\f>\16>\u04a3\13>\3>\3>\3>\3>\3>\5>\u04aa\n>\3>\3>")
+ buf.write("\5>\u04ae\n>\3>\3>\3?\3?\5?\u04b4\n?\3@\3@\5@\u04b8\n")
+ buf.write("@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3")
+ buf.write("A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3")
+ buf.write("A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u04e6\nA\3A\3A\5A\u04ea\n")
+ buf.write("A\3A\3A\3A\3A\3A\5A\u04f1\nA\3A\3A\3A\3A\5A\u04f7\nA\3")
+ buf.write("A\3A\5A\u04fb\nA\3A\3A\3B\3B\3B\7B\u0502\nB\fB\16B\u0505")
+ buf.write("\13B\3C\3C\5C\u0509\nC\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\5")
+ buf.write("D\u0515\nD\3D\3D\3D\3E\3E\3E\3E\3E\3E\5E\u0520\nE\3F\3")
+ buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u052d\nF\3G\3G\3G\3G\3")
+ buf.write("G\3G\3G\3G\3G\3G\3G\3G\3G\7G\u053c\nG\fG\16G\u053f\13")
+ buf.write("G\3G\3G\5G\u0543\nG\3G\3G\3G\5G\u0548\nG\3H\3H\3H\3H\3")
+ buf.write("H\3H\3H\3H\3H\3H\3H\3H\3H\7H\u0557\nH\fH\16H\u055a\13")
+ buf.write("H\3H\3H\5H\u055e\nH\3H\3H\3H\5H\u0563\nH\3I\3I\3I\3I\3")
+ buf.write("I\3I\5I\u056b\nI\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3")
+ buf.write("K\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\5")
+ buf.write("M\u058b\nM\3M\3M\3M\5M\u0590\nM\3N\7N\u0593\nN\fN\16N")
+ buf.write("\u0596\13N\3O\3O\3O\3O\3O\3O\3O\5O\u059f\nO\3P\3P\3P\3")
+ buf.write("P\3P\3P\3P\3P\5P\u05a9\nP\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u05b3")
+ buf.write("\nQ\fQ\16Q\u05b6\13Q\3Q\3Q\5Q\u05ba\nQ\3Q\3Q\3Q\5Q\u05bf")
+ buf.write("\nQ\3R\3R\3R\3R\3R\3R\3R\3R\7R\u05c9\nR\fR\16R\u05cc\13")
+ buf.write("R\3R\3R\5R\u05d0\nR\3R\3R\3R\5R\u05d5\nR\3S\3S\3S\3S\3")
+ buf.write("S\3S\3S\3S\5S\u05df\nS\3S\3S\3S\3S\5S\u05e5\nS\3T\3T\3")
+ buf.write("T\3T\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3")
+ buf.write("V\3V\3V\3V\3V\5V\u0600\nV\3V\3V\7V\u0604\nV\fV\16V\u0607")
+ buf.write("\13V\3V\3V\3W\3W\3W\7W\u060e\nW\fW\16W\u0611\13W\3X\3")
+ buf.write("X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u061e\nX\3Y\3Y\3Y\3Y\3")
+ buf.write("Z\3Z\3Z\3Z\3[\7[\u0629\n[\f[\16[\u062c\13[\3\\\3\\\5\\")
+ buf.write("\u0630\n\\\3]\3]\5]\u0634\n]\3^\3^\3^\3^\3^\3^\3^\3^\3")
+ buf.write("^\5^\u063f\n^\3^\3^\3^\3^\5^\u0645\n^\3^\3^\3^\3^\3_\3")
+ buf.write("_\3_\7_\u064e\n_\f_\16_\u0651\13_\3`\3`\3`\3`\3`\3`\5")
+ buf.write("`\u0659\n`\3a\3a\3a\3a\3a\3a\3a\3a\5a\u0663\na\3a\3a\3")
+ buf.write("a\3a\3a\3a\3a\3a\3a\3a\3a\3b\3b\3b\7b\u0673\nb\fb\16b")
+ buf.write("\u0676\13b\3c\3c\5c\u067a\nc\3d\3d\5d\u067e\nd\3e\3e\3")
+ buf.write("e\3e\3e\3e\3e\3e\3e\5e\u0689\ne\3e\3e\3e\3e\5e\u068f\n")
+ buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\5f\u0699\nf\3f\3f\3f\3f\3f\5")
+ buf.write("f\u06a0\nf\3f\3f\3f\3f\3f\3f\5f\u06a8\nf\3g\3g\3g\7g\u06ad")
+ buf.write("\ng\fg\16g\u06b0\13g\3h\3h\3h\3h\3h\3h\3h\3h\3h\5h\u06bb")
+ buf.write("\nh\3i\3i\3i\3i\3i\3i\3i\3i\3i\5i\u06c6\ni\3i\5i\u06c9")
+ buf.write("\ni\3i\3i\3i\3i\3j\3j\3j\7j\u06d2\nj\fj\16j\u06d5\13j")
+ buf.write("\3k\3k\5k\u06d9\nk\3l\3l\3l\3l\3l\3l\3l\3l\5l\u06e3\n")
+ buf.write("l\3l\3l\3l\3l\5l\u06e9\nl\3l\3l\3l\3l\3l\3l\3l\3l\3l\3")
+ buf.write("l\3l\3l\3m\3m\3m\7m\u06fa\nm\fm\16m\u06fd\13m\3n\3n\3")
+ buf.write("n\5n\u0702\nn\3o\3o\3o\3o\3o\3o\3o\3o\5o\u070c\no\3o\3")
+ buf.write("o\3o\3o\5o\u0712\no\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3")
+ buf.write("o\5o\u0720\no\3o\3o\3o\3o\3p\3p\3p\7p\u0729\np\fp\16p")
+ buf.write("\u072c\13p\3q\3q\5q\u0730\nq\3r\3r\3r\3r\3r\3r\3r\5r\u0739")
+ buf.write("\nr\3r\3r\3r\3r\3r\5r\u0740\nr\3r\3r\3r\3r\3s\3s\3s\7")
+ buf.write("s\u0749\ns\fs\16s\u074c\13s\3t\3t\3t\3t\5t\u0752\nt\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\5u\u075c\nu\3u\3u\3u\3u\3u\3u\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3u\5u\u07a7\nu\3u\7")
+ buf.write("u\u07aa\nu\fu\16u\u07ad\13u\5u\u07af\nu\3u\3u\3u\3v\3")
+ buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\5v\u07c0\nv\3v\3v\3v\3")
+ buf.write("v\5v\u07c6\nv\3w\3w\3w\7w\u07cb\nw\fw\16w\u07ce\13w\3")
+ buf.write("x\3x\3y\3y\3y\3y\3y\3y\3y\3y\5y\u07da\ny\3y\3y\3y\3y\3")
+ buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3")
+ buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3")
+ buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3")
+ buf.write("y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\5y\u0825\n")
+ buf.write("y\3y\7y\u0828\ny\fy\16y\u082b\13y\5y\u082d\ny\3y\3y\3")
+ buf.write("y\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\5z\u083e\nz\3z\3")
+ buf.write("z\3z\3z\5z\u0844\nz\3{\3{\3{\7{\u0849\n{\f{\16{\u084c")
+ buf.write("\13{\3|\3|\3}\3}\3}\3}\5}\u0854\n}\3~\3~\3~\3~\3~\3\177")
+ buf.write("\3\177\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081")
+ buf.write("\3\u0081\3\u0081\5\u0081\u0865\n\u0081\3\u0082\3\u0082")
+ buf.write("\3\u0082\3\u0082\5\u0082\u086b\n\u0082\3\u0083\3\u0083")
+ buf.write("\3\u0083\3\u0083\7\u0083\u0871\n\u0083\f\u0083\16\u0083")
+ buf.write("\u0874\13\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084")
+ buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\7\u0084\u087f\n\u0084")
+ buf.write("\f\u0084\16\u0084\u0882\13\u0084\3\u0084\3\u0084\5\u0084")
+ buf.write("\u0886\n\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085")
+ buf.write("\3\u0085\3\u0085\3\u0085\3\u0085\7\u0085\u0891\n\u0085")
+ buf.write("\f\u0085\16\u0085\u0894\13\u0085\3\u0085\3\u0085\5\u0085")
+ buf.write("\u0898\n\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086")
+ buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\7\u0086\u08a3\n\u0086")
+ buf.write("\f\u0086\16\u0086\u08a6\13\u0086\3\u0086\3\u0086\5\u0086")
+ buf.write("\u08aa\n\u0086\3\u0086\3\u0086\3\u0086\7\u0086\u08af\n")
+ buf.write("\u0086\f\u0086\16\u0086\u08b2\13\u0086\3\u0086\3\u0086")
+ buf.write("\3\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087")
+ buf.write("\7\u0087\u08bd\n\u0087\f\u0087\16\u0087\u08c0\13\u0087")
+ buf.write("\3\u0087\3\u0087\5\u0087\u08c4\n\u0087\3\u0087\3\u0087")
+ buf.write("\3\u0087\7\u0087\u08c9\n\u0087\f\u0087\16\u0087\u08cc")
+ buf.write("\13\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088")
+ buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088")
+ buf.write("\3\u0088\3\u0088\3\u0088\7\u0088\u08de\n\u0088\f\u0088")
+ buf.write("\16\u0088\u08e1\13\u0088\3\u0088\3\u0088\5\u0088\u08e5")
+ buf.write("\n\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089")
+ buf.write("\3\u0089\5\u0089\u08ee\n\u0089\3\u008a\3\u008a\3\u008a")
+ buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
+ buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
+ buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
+ buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
+ buf.write("\5\u008b\u090f\n\u008b\3\u008b\3\u008b\3\u008c\3\u008c")
+ buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c")
+ buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c")
+ buf.write("\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c")
+ buf.write("\3\u008c\3\u008c\3\u008c\7\u008c\u092d\n\u008c\f\u008c")
+ buf.write("\16\u008c\u0930\13\u008c\5\u008c\u0932\n\u008c\3\u008c")
+ buf.write("\3\u008c\3\u008c\3\u008c\5\u008c\u0938\n\u008c\3\u008c")
+ buf.write("\3\u008c\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e")
+ buf.write("\5\u008e\u0942\n\u008e\3\u008e\3\u008e\3\u008e\3\u008e")
+ buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e")
+ buf.write("\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e")
+ buf.write("\u0955\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f")
+ buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0962\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0968\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u096e\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0974\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u097a\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0980\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0986\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u098c\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0992\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f")
+ buf.write("\u0998\n\u008f\5\u008f\u099a\n\u008f\3\u008f\7\u008f\u099d")
+ buf.write("\n\u008f\f\u008f\16\u008f\u09a0\13\u008f\5\u008f\u09a2")
+ buf.write("\n\u008f\3\u008f\3\u008f\7\u008f\u09a6\n\u008f\f\u008f")
+ buf.write("\16\u008f\u09a9\13\u008f\3\u008f\5\u008f\u09ac\n\u008f")
+ buf.write("\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090")
+ buf.write("\5\u0090\u09b5\n\u0090\3\u0090\3\u0090\7\u0090\u09b9\n")
+ buf.write("\u0090\f\u0090\16\u0090\u09bc\13\u0090\3\u0090\3\u0090")
+ buf.write("\3\u0090\3\u0091\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093")
+ buf.write("\3\u0093\3\u0093\7\u0093\u09c9\n\u0093\f\u0093\16\u0093")
+ buf.write("\u09cc\13\u0093\3\u0094\3\u0094\3\u0094\7\u0094\u09d1")
+ buf.write("\n\u0094\f\u0094\16\u0094\u09d4\13\u0094\3\u0095\3\u0095")
+ buf.write("\3\u0095\7\u0095\u09d9\n\u0095\f\u0095\16\u0095\u09dc")
+ buf.write("\13\u0095\3\u0096\3\u0096\3\u0096\7\u0096\u09e1\n\u0096")
+ buf.write("\f\u0096\16\u0096\u09e4\13\u0096\3\u0097\3\u0097\3\u0097")
+ buf.write("\7\u0097\u09e9\n\u0097\f\u0097\16\u0097\u09ec\13\u0097")
+ buf.write("\3\u0098\3\u0098\7\u0098\u09f0\n\u0098\f\u0098\16\u0098")
+ buf.write("\u09f3\13\u0098\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099")
+ buf.write("\u09f9\n\u0099\3\u009a\3\u009a\7\u009a\u09fd\n\u009a\f")
+ buf.write("\u009a\16\u009a\u0a00\13\u009a\3\u009b\3\u009b\3\u009b")
+ buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u0a0a")
+ buf.write("\n\u009b\3\u009c\3\u009c\7\u009c\u0a0e\n\u009c\f\u009c")
+ buf.write("\16\u009c\u0a11\13\u009c\3\u009d\3\u009d\3\u009d\3\u009d")
+ buf.write("\5\u009d\u0a17\n\u009d\3\u009e\3\u009e\7\u009e\u0a1b\n")
+ buf.write("\u009e\f\u009e\16\u009e\u0a1e\13\u009e\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\5\u009f\u0a24\n\u009f\3\u00a0\3\u00a0")
+ buf.write("\7\u00a0\u0a28\n\u00a0\f\u00a0\16\u00a0\u0a2b\13\u00a0")
+ buf.write("\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\5\u00a1")
+ buf.write("\u0a33\n\u00a1\3\u00a2\3\u00a2\3\u00a2\7\u00a2\u0a38\n")
+ buf.write("\u00a2\f\u00a2\16\u00a2\u0a3b\13\u00a2\3\u00a2\3\u00a2")
+ buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3")
+ buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\5\u00a3\u0a4b")
+ buf.write("\n\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
+ buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
+ buf.write("\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
+ buf.write("\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
+ buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
+ buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0a73\n\u00a8")
+ buf.write("\3\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
+ buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa")
+ buf.write("\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0a86\n\u00aa\3\u00ab")
+ buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
+ buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab\u0a94\n\u00ab")
+ buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
+ buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0aa2")
+ buf.write("\n\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\6\u00ad\u0aa8")
+ buf.write("\n\u00ad\r\u00ad\16\u00ad\u0aa9\3\u00ae\3\u00ae\3\u00ae")
+ buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\7\u00ae\u0ab3\n\u00ae")
+ buf.write("\f\u00ae\16\u00ae\u0ab6\13\u00ae\5\u00ae\u0ab8\n\u00ae")
+ buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u0abe\n\u00af")
+ buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1")
+ buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u0ad1\n\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b3\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4")
+ buf.write("\3\u00b4\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
+ buf.write("\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0ae5\n\u00b6\3\u00b6")
+ buf.write("\3\u00b6\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
+ buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\5\u00b8")
+ buf.write("\u0af5\n\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
+ buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb")
+ buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\5\u00bb\u0b0a\n\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\3\u00bb\5\u00bb\u0b11\n\u00bb\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd")
+ buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be\3\u00be\3\u00be")
+ buf.write("\3\u00be\5\u00be\u0b25\n\u00be\3\u00be\3\u00be\3\u00be")
+ buf.write("\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0")
+ buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1\3\u00c1")
+ buf.write("\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2")
+ buf.write("\3\u00c2\3\u00c2\5\u00c2\u0b41\n\u00c2\3\u00c2\3\u00c2")
+ buf.write("\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3")
+ buf.write("\5\u00c3\u0b4c\n\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
+ buf.write("\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5")
+ buf.write("\3\u00c5\3\u00c5\3\u00c5\7\u00c5\u0b5c\n\u00c5\f\u00c5")
+ buf.write("\16\u00c5\u0b5f\13\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5")
+ buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c7")
+ buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
+ buf.write("\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8")
+ buf.write("\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
+ buf.write("\3\u00c9\3\u00c9\3\u00c9\7\u00c9\u0b84\n\u00c9\f\u00c9")
+ buf.write("\16\u00c9\u0b87\13\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
+ buf.write("\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00cb")
+ buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
+ buf.write("\3\u00cb\7\u00cb\u0b9c\n\u00cb\f\u00cb\16\u00cb\u0b9f")
+ buf.write("\13\u00cb\3\u00cb\3\u00cb\3\u00cb\2\2\u00cc\2\4\6\b\n")
+ buf.write("\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<")
+ buf.write(">@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
+ buf.write("\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098")
+ buf.write("\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa")
+ buf.write("\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc")
+ buf.write("\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce")
+ buf.write("\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0")
+ buf.write("\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2")
+ buf.write("\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104")
+ buf.write("\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116")
+ buf.write("\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128")
+ buf.write("\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a")
+ buf.write("\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c")
+ buf.write("\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e")
+ buf.write("\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170")
+ buf.write("\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182")
+ buf.write("\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194")
+ buf.write("\2\20\3\2\4\5\4\2\u00ac\u00b2\u00fa\u00fa\4\2\u00b3\u00b6")
+ buf.write("\u00fa\u00fa\4\2\n\n\u00fa\u00fa\5\2\u00b7\u00b9\u00bd")
+ buf.write("\u00bf\u00fa\u00fa\4\2\u00ba\u00bf\u00fa\u00fa\3\2\u0085")
+ buf.write("\u0086\3\2\u008a\u008c\3\2RV\3\2\u00fa\u00fb\3\2\u00ef")
+ buf.write("\u00f2\4\2\u00d3\u00d9\u00fa\u00fa\3\2\u00f6\u00f7\3\2")
+ buf.write("\u00f8\u00fa\2\u0c6e\2\u019b\3\2\2\2\4\u01a0\3\2\2\2\6")
+ buf.write("\u01a2\3\2\2\2\b\u01ac\3\2\2\2\n\u01ae\3\2\2\2\f\u01b9")
+ buf.write("\3\2\2\2\16\u01cb\3\2\2\2\20\u01ec\3\2\2\2\22\u01ef\3")
+ buf.write("\2\2\2\24\u01f8\3\2\2\2\26\u0201\3\2\2\2\30\u020a\3\2")
+ buf.write("\2\2\32\u0213\3\2\2\2\34\u021c\3\2\2\2\36\u0225\3\2\2")
+ buf.write("\2 \u022e\3\2\2\2\"\u0237\3\2\2\2$\u0240\3\2\2\2&\u0249")
+ buf.write("\3\2\2\2(\u0251\3\2\2\2*\u0259\3\2\2\2,\u0261\3\2\2\2")
+ buf.write(".\u0269\3\2\2\2\60\u0295\3\2\2\2\62\u02a2\3\2\2\2\64\u02aa")
+ buf.write("\3\2\2\2\66\u02ac\3\2\2\28\u02b1\3\2\2\2:\u02be\3\2\2")
+ buf.write("\2<\u02c0\3\2\2\2>\u02d1\3\2\2\2@\u02f3\3\2\2\2B\u032d")
+ buf.write("\3\2\2\2D\u032f\3\2\2\2F\u0348\3\2\2\2H\u034f\3\2\2\2")
+ buf.write("J\u0356\3\2\2\2L\u0366\3\2\2\2N\u0376\3\2\2\2P\u037b\3")
+ buf.write("\2\2\2R\u0382\3\2\2\2T\u0391\3\2\2\2V\u03a7\3\2\2\2X\u03b5")
+ buf.write("\3\2\2\2Z\u03e3\3\2\2\2\\\u03e5\3\2\2\2^\u03ec\3\2\2\2")
+ buf.write("`\u03f0\3\2\2\2b\u03f2\3\2\2\2d\u03fa\3\2\2\2f\u041e\3")
+ buf.write("\2\2\2h\u0420\3\2\2\2j\u043f\3\2\2\2l\u0442\3\2\2\2n\u0445")
+ buf.write("\3\2\2\2p\u044f\3\2\2\2r\u0451\3\2\2\2t\u0476\3\2\2\2")
+ buf.write("v\u0478\3\2\2\2x\u0480\3\2\2\2z\u0482\3\2\2\2|\u04b3\3")
+ buf.write("\2\2\2~\u04b7\3\2\2\2\u0080\u04b9\3\2\2\2\u0082\u04fe")
+ buf.write("\3\2\2\2\u0084\u0508\3\2\2\2\u0086\u050a\3\2\2\2\u0088")
+ buf.write("\u051f\3\2\2\2\u008a\u052c\3\2\2\2\u008c\u052e\3\2\2\2")
+ buf.write("\u008e\u0549\3\2\2\2\u0090\u0564\3\2\2\2\u0092\u056c\3")
+ buf.write("\2\2\2\u0094\u0571\3\2\2\2\u0096\u0579\3\2\2\2\u0098\u057e")
+ buf.write("\3\2\2\2\u009a\u0594\3\2\2\2\u009c\u059e\3\2\2\2\u009e")
+ buf.write("\u05a8\3\2\2\2\u00a0\u05aa\3\2\2\2\u00a2\u05c0\3\2\2\2")
+ buf.write("\u00a4\u05d6\3\2\2\2\u00a6\u05e6\3\2\2\2\u00a8\u05ea\3")
+ buf.write("\2\2\2\u00aa\u05ec\3\2\2\2\u00ac\u060a\3\2\2\2\u00ae\u061d")
+ buf.write("\3\2\2\2\u00b0\u061f\3\2\2\2\u00b2\u0623\3\2\2\2\u00b4")
+ buf.write("\u062a\3\2\2\2\u00b6\u062f\3\2\2\2\u00b8\u0633\3\2\2\2")
+ buf.write("\u00ba\u0635\3\2\2\2\u00bc\u064a\3\2\2\2\u00be\u0658\3")
+ buf.write("\2\2\2\u00c0\u065a\3\2\2\2\u00c2\u066f\3\2\2\2\u00c4\u0679")
+ buf.write("\3\2\2\2\u00c6\u067d\3\2\2\2\u00c8\u067f\3\2\2\2\u00ca")
+ buf.write("\u0695\3\2\2\2\u00cc\u06a9\3\2\2\2\u00ce\u06ba\3\2\2\2")
+ buf.write("\u00d0\u06bc\3\2\2\2\u00d2\u06ce\3\2\2\2\u00d4\u06d8\3")
+ buf.write("\2\2\2\u00d6\u06da\3\2\2\2\u00d8\u06f6\3\2\2\2\u00da\u0701")
+ buf.write("\3\2\2\2\u00dc\u0703\3\2\2\2\u00de\u0725\3\2\2\2\u00e0")
+ buf.write("\u072f\3\2\2\2\u00e2\u0731\3\2\2\2\u00e4\u0745\3\2\2\2")
+ buf.write("\u00e6\u0751\3\2\2\2\u00e8\u0753\3\2\2\2\u00ea\u07b3\3")
+ buf.write("\2\2\2\u00ec\u07c7\3\2\2\2\u00ee\u07cf\3\2\2\2\u00f0\u07d1")
+ buf.write("\3\2\2\2\u00f2\u0831\3\2\2\2\u00f4\u0845\3\2\2\2\u00f6")
+ buf.write("\u084d\3\2\2\2\u00f8\u0853\3\2\2\2\u00fa\u0855\3\2\2\2")
+ buf.write("\u00fc\u085a\3\2\2\2\u00fe\u085c\3\2\2\2\u0100\u0864\3")
+ buf.write("\2\2\2\u0102\u086a\3\2\2\2\u0104\u086c\3\2\2\2\u0106\u0878")
+ buf.write("\3\2\2\2\u0108\u088a\3\2\2\2\u010a\u089c\3\2\2\2\u010c")
+ buf.write("\u08b6\3\2\2\2\u010e\u08d0\3\2\2\2\u0110\u08ed\3\2\2\2")
+ buf.write("\u0112\u08ef\3\2\2\2\u0114\u08f9\3\2\2\2\u0116\u0912\3")
+ buf.write("\2\2\2\u0118\u093b\3\2\2\2\u011a\u093f\3\2\2\2\u011c\u0956")
+ buf.write("\3\2\2\2\u011e\u09af\3\2\2\2\u0120\u09c0\3\2\2\2\u0122")
+ buf.write("\u09c3\3\2\2\2\u0124\u09c5\3\2\2\2\u0126\u09cd\3\2\2\2")
+ buf.write("\u0128\u09d5\3\2\2\2\u012a\u09dd\3\2\2\2\u012c\u09e5\3")
+ buf.write("\2\2\2\u012e\u09ed\3\2\2\2\u0130\u09f8\3\2\2\2\u0132\u09fa")
+ buf.write("\3\2\2\2\u0134\u0a09\3\2\2\2\u0136\u0a0b\3\2\2\2\u0138")
+ buf.write("\u0a16\3\2\2\2\u013a\u0a18\3\2\2\2\u013c\u0a23\3\2\2\2")
+ buf.write("\u013e\u0a25\3\2\2\2\u0140\u0a32\3\2\2\2\u0142\u0a39\3")
+ buf.write("\2\2\2\u0144\u0a4a\3\2\2\2\u0146\u0a4c\3\2\2\2\u0148\u0a53")
+ buf.write("\3\2\2\2\u014a\u0a5a\3\2\2\2\u014c\u0a63\3\2\2\2\u014e")
+ buf.write("\u0a72\3\2\2\2\u0150\u0a74\3\2\2\2\u0152\u0a76\3\2\2\2")
+ buf.write("\u0154\u0a87\3\2\2\2\u0156\u0a95\3\2\2\2\u0158\u0aa3\3")
+ buf.write("\2\2\2\u015a\u0ab7\3\2\2\2\u015c\u0ab9\3\2\2\2\u015e\u0abf")
+ buf.write("\3\2\2\2\u0160\u0ac4\3\2\2\2\u0162\u0ac9\3\2\2\2\u0164")
+ buf.write("\u0ad4\3\2\2\2\u0166\u0ad6\3\2\2\2\u0168\u0adb\3\2\2\2")
+ buf.write("\u016a\u0add\3\2\2\2\u016c\u0ae8\3\2\2\2\u016e\u0af4\3")
+ buf.write("\2\2\2\u0170\u0af6\3\2\2\2\u0172\u0afb\3\2\2\2\u0174\u0b00")
+ buf.write("\3\2\2\2\u0176\u0b15\3\2\2\2\u0178\u0b1a\3\2\2\2\u017a")
+ buf.write("\u0b1f\3\2\2\2\u017c\u0b2a\3\2\2\2\u017e\u0b2f\3\2\2\2")
+ buf.write("\u0180\u0b34\3\2\2\2\u0182\u0b39\3\2\2\2\u0184\u0b4b\3")
+ buf.write("\2\2\2\u0186\u0b4d\3\2\2\2\u0188\u0b56\3\2\2\2\u018a\u0b68")
+ buf.write("\3\2\2\2\u018c\u0b6a\3\2\2\2\u018e\u0b73\3\2\2\2\u0190")
+ buf.write("\u0b7c\3\2\2\2\u0192\u0b90\3\2\2\2\u0194\u0b92\3\2\2\2")
+ buf.write("\u0196\u019a\5\n\6\2\u0197\u019a\5\f\7\2\u0198\u019a\5")
+ buf.write("\16\b\2\u0199\u0196\3\2\2\2\u0199\u0197\3\2\2\2\u0199")
+ buf.write("\u0198\3\2\2\2\u019a\u019d\3\2\2\2\u019b\u0199\3\2\2\2")
+ buf.write("\u019b\u019c\3\2\2\2\u019c\u019e\3\2\2\2\u019d\u019b\3")
+ buf.write("\2\2\2\u019e\u019f\5.\30\2\u019f\3\3\2\2\2\u01a0\u01a1")
+ buf.write("\7\3\2\2\u01a1\5\3\2\2\2\u01a2\u01a5\t\2\2\2\u01a3\u01a4")
+ buf.write("\7!\2\2\u01a4\u01a6\7\u00fb\2\2\u01a5\u01a3\3\2\2\2\u01a5")
+ buf.write("\u01a6\3\2\2\2\u01a6\u01a9\3\2\2\2\u01a7\u01a8\7!\2\2")
+ buf.write("\u01a8\u01aa\7\u00fa\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01aa")
+ buf.write("\3\2\2\2\u01aa\7\3\2\2\2\u01ab\u01ad\7\u00fa\2\2\u01ac")
+ buf.write("\u01ab\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\t\3\2\2\2\u01ae")
+ buf.write("\u01af\7\6\2\2\u01af\u01b0\7\7\2\2\u01b0\u01b4\7\30\2")
+ buf.write("\2\u01b1\u01b5\5\4\3\2\u01b2\u01b5\5\6\4\2\u01b3\u01b5")
+ buf.write("\5\b\5\2\u01b4\u01b1\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b4")
+ buf.write("\u01b3\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b6\3\2\2\2")
+ buf.write("\u01b6\u01b7\7\31\2\2\u01b7\13\3\2\2\2\u01b8\u01ba\7\u0084")
+ buf.write("\2\2\u01b9\u01b8\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb")
+ buf.write("\3\2\2\2\u01bb\u01bd\7P\2\2\u01bc\u01be\7O\2\2\u01bd\u01bc")
+ buf.write("\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01c0\3\2\2\2\u01bf")
+ buf.write("\u01c1\7\u00fb\2\2\u01c0\u01bf\3\2\2\2\u01c0\u01c1\3\2")
+ buf.write("\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c3\7\26\2\2\u01c3\u01c4")
+ buf.write("\5\20\t\2\u01c4\u01c6\7\27\2\2\u01c5\u01c7\7\u00fb\2\2")
+ buf.write("\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3")
+ buf.write("\2\2\2\u01c8\u01c9\7 \2\2\u01c9\r\3\2\2\2\u01ca\u01cc")
+ buf.write("\7\u0084\2\2\u01cb\u01ca\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc")
+ buf.write("\u01cd\3\2\2\2\u01cd\u01cf\7Q\2\2\u01ce\u01d0\7O\2\2\u01cf")
+ buf.write("\u01ce\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d2\3\2\2\2")
+ buf.write("\u01d1\u01d3\7\u00fb\2\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3")
+ buf.write("\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d5\7\26\2\2\u01d5")
+ buf.write("\u01d6\5\20\t\2\u01d6\u01d8\7\27\2\2\u01d7\u01d9\7\u00fb")
+ buf.write("\2\2\u01d8\u01d7\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da")
+ buf.write("\3\2\2\2\u01da\u01db\7 \2\2\u01db\17\3\2\2\2\u01dc\u01eb")
+ buf.write("\5\22\n\2\u01dd\u01eb\5\24\13\2\u01de\u01eb\5\26\f\2\u01df")
+ buf.write("\u01eb\5\30\r\2\u01e0\u01eb\5\32\16\2\u01e1\u01eb\5\34")
+ buf.write("\17\2\u01e2\u01eb\5\36\20\2\u01e3\u01eb\5 \21\2\u01e4")
+ buf.write("\u01eb\5\"\22\2\u01e5\u01eb\5$\23\2\u01e6\u01eb\5&\24")
+ buf.write("\2\u01e7\u01eb\5(\25\2\u01e8\u01eb\5*\26\2\u01e9\u01eb")
+ buf.write("\5,\27\2\u01ea\u01dc\3\2\2\2\u01ea\u01dd\3\2\2\2\u01ea")
+ buf.write("\u01de\3\2\2\2\u01ea\u01df\3\2\2\2\u01ea\u01e0\3\2\2\2")
+ buf.write("\u01ea\u01e1\3\2\2\2\u01ea\u01e2\3\2\2\2\u01ea\u01e3\3")
+ buf.write("\2\2\2\u01ea\u01e4\3\2\2\2\u01ea\u01e5\3\2\2\2\u01ea\u01e6")
+ buf.write("\3\2\2\2\u01ea\u01e7\3\2\2\2\u01ea\u01e8\3\2\2\2\u01ea")
+ buf.write("\u01e9\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2")
+ buf.write("\u01ec\u01ed\3\2\2\2\u01ed\21\3\2\2\2\u01ee\u01ec\3\2")
+ buf.write("\2\2\u01ef\u01f0\7S\2\2\u01f0\u01f4\7\u00fb\2\2\u01f1")
+ buf.write("\u01f2\7\32\2\2\u01f2\u01f3\7\u00fa\2\2\u01f3\u01f5\7")
+ buf.write("\33\2\2\u01f4\u01f1\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5")
+ buf.write("\u01f6\3\2\2\2\u01f6\u01f7\7 \2\2\u01f7\23\3\2\2\2\u01f8")
+ buf.write("\u01f9\7T\2\2\u01f9\u01fd\7\u00fb\2\2\u01fa\u01fb\7\32")
+ buf.write("\2\2\u01fb\u01fc\7\u00fa\2\2\u01fc\u01fe\7\33\2\2\u01fd")
+ buf.write("\u01fa\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u01ff\3\2\2\2")
+ buf.write("\u01ff\u0200\7 \2\2\u0200\25\3\2\2\2\u0201\u0202\7U\2")
+ buf.write("\2\u0202\u0206\7\u00fb\2\2\u0203\u0204\7\32\2\2\u0204")
+ buf.write("\u0205\7\u00fa\2\2\u0205\u0207\7\33\2\2\u0206\u0203\3")
+ buf.write("\2\2\2\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0209")
+ buf.write("\7 \2\2\u0209\27\3\2\2\2\u020a\u020b\7V\2\2\u020b\u020f")
+ buf.write("\7\u00fb\2\2\u020c\u020d\7\32\2\2\u020d\u020e\7\u00fa")
+ buf.write("\2\2\u020e\u0210\7\33\2\2\u020f\u020c\3\2\2\2\u020f\u0210")
+ buf.write("\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u0212\7 \2\2\u0212")
+ buf.write("\31\3\2\2\2\u0213\u0214\7R\2\2\u0214\u0218\7\u00fb\2\2")
+ buf.write("\u0215\u0216\7\32\2\2\u0216\u0217\7\u00fa\2\2\u0217\u0219")
+ buf.write("\7\33\2\2\u0218\u0215\3\2\2\2\u0218\u0219\3\2\2\2\u0219")
+ buf.write("\u021a\3\2\2\2\u021a\u021b\7 \2\2\u021b\33\3\2\2\2\u021c")
+ buf.write("\u021d\7W\2\2\u021d\u0221\7\u00fb\2\2\u021e\u021f\7\32")
+ buf.write("\2\2\u021f\u0220\7\u00fa\2\2\u0220\u0222\7\33\2\2\u0221")
+ buf.write("\u021e\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0223\3\2\2\2")
+ buf.write("\u0223\u0224\7 \2\2\u0224\35\3\2\2\2\u0225\u0226\7X\2")
+ buf.write("\2\u0226\u022a\7\u00fb\2\2\u0227\u0228\7\32\2\2\u0228")
+ buf.write("\u0229\7\u00fa\2\2\u0229\u022b\7\33\2\2\u022a\u0227\3")
+ buf.write("\2\2\2\u022a\u022b\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022d")
+ buf.write("\7 \2\2\u022d\37\3\2\2\2\u022e\u022f\7Y\2\2\u022f\u0233")
+ buf.write("\7\u00fb\2\2\u0230\u0231\7\32\2\2\u0231\u0232\7\u00fa")
+ buf.write("\2\2\u0232\u0234\7\33\2\2\u0233\u0230\3\2\2\2\u0233\u0234")
+ buf.write("\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\7 \2\2\u0236")
+ buf.write("!\3\2\2\2\u0237\u0238\7Z\2\2\u0238\u023c\7\u00fb\2\2\u0239")
+ buf.write("\u023a\7\32\2\2\u023a\u023b\7\u00fa\2\2\u023b\u023d\7")
+ buf.write("\33\2\2\u023c\u0239\3\2\2\2\u023c\u023d\3\2\2\2\u023d")
+ buf.write("\u023e\3\2\2\2\u023e\u023f\7 \2\2\u023f#\3\2\2\2\u0240")
+ buf.write("\u0241\7\u00fb\2\2\u0241\u0245\7\u00fb\2\2\u0242\u0243")
+ buf.write("\7\32\2\2\u0243\u0244\7\u00fa\2\2\u0244\u0246\7\33\2\2")
+ buf.write("\u0245\u0242\3\2\2\2\u0245\u0246\3\2\2\2\u0246\u0247\3")
+ buf.write("\2\2\2\u0247\u0248\7 \2\2\u0248%\3\2\2\2\u0249\u024b\7")
+ buf.write("S\2\2\u024a\u024c\7\u00fb\2\2\u024b\u024a\3\2\2\2\u024b")
+ buf.write("\u024c\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u024e\7\36\2")
+ buf.write("\2\u024e\u024f\7\u00fa\2\2\u024f\u0250\7 \2\2\u0250\'")
+ buf.write("\3\2\2\2\u0251\u0253\7T\2\2\u0252\u0254\7\u00fb\2\2\u0253")
+ buf.write("\u0252\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0255\3\2\2\2")
+ buf.write("\u0255\u0256\7\36\2\2\u0256\u0257\7\u00fa\2\2\u0257\u0258")
+ buf.write("\7 \2\2\u0258)\3\2\2\2\u0259\u025b\7U\2\2\u025a\u025c")
+ buf.write("\7\u00fb\2\2\u025b\u025a\3\2\2\2\u025b\u025c\3\2\2\2\u025c")
+ buf.write("\u025d\3\2\2\2\u025d\u025e\7\36\2\2\u025e\u025f\7\u00fa")
+ buf.write("\2\2\u025f\u0260\7 \2\2\u0260+\3\2\2\2\u0261\u0263\7V")
+ buf.write("\2\2\u0262\u0264\7\u00fb\2\2\u0263\u0262\3\2\2\2\u0263")
+ buf.write("\u0264\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0266\7\36\2")
+ buf.write("\2\u0266\u0267\7\u00fa\2\2\u0267\u0268\7 \2\2\u0268-\3")
+ buf.write("\2\2\2\u0269\u026a\7+\2\2\u026a\u026b\7[\2\2\u026b\u026c")
+ buf.write("\7\b\2\2\u026c\u026d\5L\'\2\u026d\u026e\7!\2\2\u026e\u026f")
+ buf.write("\7.\2\2\u026f\u0270\7\b\2\2\u0270\u0271\7\u00ec\2\2\u0271")
+ buf.write("\u0272\7\30\2\2\u0272\u0273\7\u00fa\2\2\u0273\u0274\7")
+ buf.write("\31\2\2\u0274\u0275\7!\2\2\u0275\u0276\7=\2\2\u0276\u0277")
+ buf.write("\7\b\2\2\u0277\u0278\7\u00ec\2\2\u0278\u0279\7\30\2\2")
+ buf.write("\u0279\u027a\7\u00fa\2\2\u027a\u027b\7\31\2\2\u027b\u0281")
+ buf.write("\7!\2\2\u027c\u027d\7\u0083\2\2\u027d\u027e\7\b\2\2\u027e")
+ buf.write("\u027f\5\60\31\2\u027f\u0280\7!\2\2\u0280\u0282\3\2\2")
+ buf.write("\2\u0281\u027c\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0288")
+ buf.write("\3\2\2\2\u0283\u0284\7\u0081\2\2\u0284\u0285\7\b\2\2\u0285")
+ buf.write("\u0286\5\62\32\2\u0286\u0287\7!\2\2\u0287\u0289\3\2\2")
+ buf.write("\2\u0288\u0283\3\2\2\2\u0288\u0289\3\2\2\2\u0289\u028f")
+ buf.write("\3\2\2\2\u028a\u028b\7\u0082\2\2\u028b\u028c\7\b\2\2\u028c")
+ buf.write("\u028d\5\66\34\2\u028d\u028e\7!\2\2\u028e\u0290\3\2\2")
+ buf.write("\2\u028f\u028a\3\2\2\2\u028f\u0290\3\2\2\2\u0290\u0291")
+ buf.write("\3\2\2\2\u0291\u0292\58\35\2\u0292\u0293\7-\2\2\u0293")
+ buf.write("\u0294\7 \2\2\u0294/\3\2\2\2\u0295\u0298\5L\'\2\u0296")
+ buf.write("\u0297\7(\2\2\u0297\u0299\5L\'\2\u0298\u0296\3\2\2\2\u0298")
+ buf.write("\u0299\3\2\2\2\u0299\u029c\3\2\2\2\u029a\u029b\7(\2\2")
+ buf.write("\u029b\u029d\5L\'\2\u029c\u029a\3\2\2\2\u029c\u029d\3")
+ buf.write("\2\2\2\u029d\u02a0\3\2\2\2\u029e\u029f\7(\2\2\u029f\u02a1")
+ buf.write("\5L\'\2\u02a0\u029e\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1")
+ buf.write("\61\3\2\2\2\u02a2\u02a7\5\64\33\2\u02a3\u02a4\7(\2\2\u02a4")
+ buf.write("\u02a6\5\64\33\2\u02a5\u02a3\3\2\2\2\u02a6\u02a9\3\2\2")
+ buf.write("\2\u02a7\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\63\3")
+ buf.write("\2\2\2\u02a9\u02a7\3\2\2\2\u02aa\u02ab\t\3\2\2\u02ab\65")
+ buf.write("\3\2\2\2\u02ac\u02ad\t\4\2\2\u02ad\67\3\2\2\2\u02ae\u02b0")
+ buf.write("\5:\36\2\u02af\u02ae\3\2\2\2\u02b0\u02b3\3\2\2\2\u02b1")
+ buf.write("\u02af\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b29\3\2\2\2\u02b3")
+ buf.write("\u02b1\3\2\2\2\u02b4\u02bf\5d\63\2\u02b5\u02bf\5h\65\2")
+ buf.write("\u02b6\u02bf\5j\66\2\u02b7\u02bf\5> \2\u02b8\u02bf\5@")
+ buf.write("!\2\u02b9\u02bf\5D#\2\u02ba\u02bf\5<\37\2\u02bb\u02bf")
+ buf.write("\5F$\2\u02bc\u02bf\5H%\2\u02bd\u02bf\5\u011c\u008f\2\u02be")
+ buf.write("\u02b4\3\2\2\2\u02be\u02b5\3\2\2\2\u02be\u02b6\3\2\2\2")
+ buf.write("\u02be\u02b7\3\2\2\2\u02be\u02b8\3\2\2\2\u02be\u02b9\3")
+ buf.write("\2\2\2\u02be\u02ba\3\2\2\2\u02be\u02bb\3\2\2\2\u02be\u02bc")
+ buf.write("\3\2\2\2\u02be\u02bd\3\2\2\2\u02bf;\3\2\2\2\u02c0\u02c1")
+ buf.write("\7\u009b\2\2\u02c1\u02c2\7\u00fb\2\2\u02c2\u02c3\7!\2")
+ buf.write("\2\u02c3\u02c4\7\62\2\2\u02c4\u02c5\7\b\2\2\u02c5\u02c6")
+ buf.write("\7\u00ec\2\2\u02c6\u02c7\7\30\2\2\u02c7\u02c8\7\u00fa")
+ buf.write("\2\2\u02c8\u02cd\7\31\2\2\u02c9\u02ca\7!\2\2\u02ca\u02cb")
+ buf.write("\7\u009c\2\2\u02cb\u02cc\7\b\2\2\u02cc\u02ce\7\u00fa\2")
+ buf.write("\2\u02cd\u02c9\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf")
+ buf.write("\3\2\2\2\u02cf\u02d0\7 \2\2\u02d0=\3\2\2\2\u02d1\u02e2")
+ buf.write("\7\u009d\2\2\u02d2\u02d3\7\u00fb\2\2\u02d3\u02e3\7!\2")
+ buf.write("\2\u02d4\u02d5\7V\2\2\u02d5\u02e3\7!\2\2\u02d6\u02d7\7")
+ buf.write("U\2\2\u02d7\u02e3\7!\2\2\u02d8\u02d9\7T\2\2\u02d9\u02e3")
+ buf.write("\7!\2\2\u02da\u02db\7S\2\2\u02db\u02e3\7!\2\2\u02dc\u02dd")
+ buf.write("\7X\2\2\u02dd\u02e3\7!\2\2\u02de\u02df\7Y\2\2\u02df\u02e3")
+ buf.write("\7!\2\2\u02e0\u02e1\7Z\2\2\u02e1\u02e3\7!\2\2\u02e2\u02d2")
+ buf.write("\3\2\2\2\u02e2\u02d4\3\2\2\2\u02e2\u02d6\3\2\2\2\u02e2")
+ buf.write("\u02d8\3\2\2\2\u02e2\u02da\3\2\2\2\u02e2\u02dc\3\2\2\2")
+ buf.write("\u02e2\u02de\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3\u02e8\3")
+ buf.write("\2\2\2\u02e4\u02e5\7\u008f\2\2\u02e5\u02e6\7\b\2\2\u02e6")
+ buf.write("\u02e7\7\u00fa\2\2\u02e7\u02e9\7!\2\2\u02e8\u02e4\3\2")
+ buf.write("\2\2\u02e8\u02e9\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\u02eb")
+ buf.write("\7\u008e\2\2\u02eb\u02ec\7\b\2\2\u02ec\u02ed\7\u00fb\2")
+ buf.write("\2\u02ed\u02ee\7!\2\2\u02ee\u02ef\7[\2\2\u02ef\u02f0\7")
+ buf.write("\b\2\2\u02f0\u02f1\5L\'\2\u02f1\u02f2\7 \2\2\u02f2?\3")
+ buf.write("\2\2\2\u02f3\u0304\7\u009e\2\2\u02f4\u02f5\7\u00fb\2\2")
+ buf.write("\u02f5\u0305\7!\2\2\u02f6\u02f7\7V\2\2\u02f7\u0305\7!")
+ buf.write("\2\2\u02f8\u02f9\7U\2\2\u02f9\u0305\7!\2\2\u02fa\u02fb")
+ buf.write("\7T\2\2\u02fb\u0305\7!\2\2\u02fc\u02fd\7S\2\2\u02fd\u0305")
+ buf.write("\7!\2\2\u02fe\u02ff\7X\2\2\u02ff\u0305\7!\2\2\u0300\u0301")
+ buf.write("\7Y\2\2\u0301\u0305\7!\2\2\u0302\u0303\7Z\2\2\u0303\u0305")
+ buf.write("\7!\2\2\u0304\u02f4\3\2\2\2\u0304\u02f6\3\2\2\2\u0304")
+ buf.write("\u02f8\3\2\2\2\u0304\u02fa\3\2\2\2\u0304\u02fc\3\2\2\2")
+ buf.write("\u0304\u02fe\3\2\2\2\u0304\u0300\3\2\2\2\u0304\u0302\3")
+ buf.write("\2\2\2\u0305\u030a\3\2\2\2\u0306\u0307\7\u008f\2\2\u0307")
+ buf.write("\u0308\7\b\2\2\u0308\u0309\7\u00fa\2\2\u0309\u030b\7!")
+ buf.write("\2\2\u030a\u0306\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030c")
+ buf.write("\3\2\2\2\u030c\u030d\7\u009c\2\2\u030d\u030e\7\b\2\2\u030e")
+ buf.write("\u0313\5B\"\2\u030f\u0310\7(\2\2\u0310\u0312\5B\"\2\u0311")
+ buf.write("\u030f\3\2\2\2\u0312\u0315\3\2\2\2\u0313\u0311\3\2\2\2")
+ buf.write("\u0313\u0314\3\2\2\2\u0314\u0316\3\2\2\2\u0315\u0313\3")
+ buf.write("\2\2\2\u0316\u0326\7!\2\2\u0317\u0318\7\u008e\2\2\u0318")
+ buf.write("\u0319\7\b\2\2\u0319\u031a\7\u00fb\2\2\u031a\u0327\7!")
+ buf.write("\2\2\u031b\u031c\7\u008e\2\2\u031c\u031d\7\b\2\2\u031d")
+ buf.write("\u031e\7\u00ec\2\2\u031e\u031f\7\30\2\2\u031f\u0320\7")
+ buf.write("\u00fa\2\2\u0320\u0321\7\31\2\2\u0321\u0322\7!\2\2\u0322")
+ buf.write("\u0323\7\u009f\2\2\u0323\u0324\7\b\2\2\u0324\u0325\7\u00fa")
+ buf.write("\2\2\u0325\u0327\7!\2\2\u0326\u0317\3\2\2\2\u0326\u031b")
+ buf.write("\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\7[\2\2\u0329")
+ buf.write("\u032a\7\b\2\2\u032a\u032b\5L\'\2\u032b\u032c\7 \2\2\u032c")
+ buf.write("A\3\2\2\2\u032d\u032e\7\u00fa\2\2\u032eC\3\2\2\2\u032f")
+ buf.write("\u0330\7\u00a0\2\2\u0330\u0331\7\u00fb\2\2\u0331\u0336")
+ buf.write("\7!\2\2\u0332\u0333\7\u008f\2\2\u0333\u0334\7\b\2\2\u0334")
+ buf.write("\u0335\7\u00fa\2\2\u0335\u0337\7!\2\2\u0336\u0332\3\2")
+ buf.write("\2\2\u0336\u0337\3\2\2\2\u0337\u033f\3\2\2\2\u0338\u0339")
+ buf.write("\7\u008e\2\2\u0339\u033a\7\b\2\2\u033a\u033b\7\u00ec\2")
+ buf.write("\2\u033b\u033c\7\30\2\2\u033c\u033d\7\u00fa\2\2\u033d")
+ buf.write("\u033e\7\31\2\2\u033e\u0340\7!\2\2\u033f\u0338\3\2\2\2")
+ buf.write("\u0340\u0341\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3")
+ buf.write("\2\2\2\u0342\u0343\3\2\2\2\u0343\u0344\7[\2\2\u0344\u0345")
+ buf.write("\7\b\2\2\u0345\u0346\5L\'\2\u0346\u0347\7 \2\2\u0347E")
+ buf.write("\3\2\2\2\u0348\u0349\7l\2\2\u0349\u034a\5\u0124\u0093")
+ buf.write("\2\u034a\u034b\7 \2\2\u034b\u034c\58\35\2\u034c\u034d")
+ buf.write("\7s\2\2\u034d\u034e\7 \2\2\u034eG\3\2\2\2\u034f\u0350")
+ buf.write("\7k\2\2\u0350\u0351\5\u0124\u0093\2\u0351\u0352\7 \2\2")
+ buf.write("\u0352\u0353\58\35\2\u0353\u0354\7s\2\2\u0354\u0355\7")
+ buf.write(" \2\2\u0355I\3\2\2\2\u0356\u0357\7\u00fa\2\2\u0357\u0358")
+ buf.write("\7!\2\2\u0358\u0359\7\u00fa\2\2\u0359\u035a\7!\2\2\u035a")
+ buf.write("\u035b\7\u00fa\2\2\u035b\u035c\7!\2\2\u035c\u035d\7\u00fa")
+ buf.write("\2\2\u035d\u035e\7!\2\2\u035e\u035f\7\u00fa\2\2\u035f")
+ buf.write("\u0360\7!\2\2\u0360\u0361\7\u00fa\2\2\u0361\u0362\7!\2")
+ buf.write("\2\u0362\u0363\7\u00fa\2\2\u0363\u0364\7!\2\2\u0364\u0365")
+ buf.write("\7\u00fa\2\2\u0365K\3\2\2\2\u0366\u0367\7\26\2\2\u0367")
+ buf.write("\u0368\7\u00fa\2\2\u0368\u0369\7!\2\2\u0369\u036a\7\u00fa")
+ buf.write("\2\2\u036a\u036b\7!\2\2\u036b\u036c\7\u00fa\2\2\u036c")
+ buf.write("\u0372\7!\2\2\u036d\u036e\7\26\2\2\u036e\u036f\5J&\2\u036f")
+ buf.write("\u0370\7\27\2\2\u0370\u0373\3\2\2\2\u0371\u0373\5J&\2")
+ buf.write("\u0372\u036d\3\2\2\2\u0372\u0371\3\2\2\2\u0373\u0374\3")
+ buf.write("\2\2\2\u0374\u0375\7\27\2\2\u0375M\3\2\2\2\u0376\u0377")
+ buf.write("\7\u00ec\2\2\u0377\u0378\7\30\2\2\u0378\u0379\7\u00fa")
+ buf.write("\2\2\u0379\u037a\7\31\2\2\u037aO\3\2\2\2\u037b\u037c\5")
+ buf.write("R*\2\u037c\u037d\5T+\2\u037dQ\3\2\2\2\u037e\u037f\7\u008e")
+ buf.write("\2\2\u037f\u0380\7\b\2\2\u0380\u0381\7\u00fb\2\2\u0381")
+ buf.write("\u0383\7!\2\2\u0382\u037e\3\2\2\2\u0382\u0383\3\2\2\2")
+ buf.write("\u0383\u0389\3\2\2\2\u0384\u0385\7\u008f\2\2\u0385\u0386")
+ buf.write("\7\b\2\2\u0386\u0387\5X-\2\u0387\u0388\7!\2\2\u0388\u038a")
+ buf.write("\3\2\2\2\u0389\u0384\3\2\2\2\u0389\u038a\3\2\2\2\u038a")
+ buf.write("\u038f\3\2\2\2\u038b\u038c\7\u0091\2\2\u038c\u038d\7\b")
+ buf.write("\2\2\u038d\u038e\7\u00fa\2\2\u038e\u0390\7!\2\2\u038f")
+ buf.write("\u038b\3\2\2\2\u038f\u0390\3\2\2\2\u0390S\3\2\2\2\u0391")
+ buf.write("\u0392\7\62\2\2\u0392\u0393\7\b\2\2\u0393\u0394\7\u00ec")
+ buf.write("\2\2\u0394\u0395\7\30\2\2\u0395\u0396\7\u00fa\2\2\u0396")
+ buf.write("\u0397\7\31\2\2\u0397\u0398\7!\2\2\u0398\u0399\7=\2\2")
+ buf.write("\u0399\u039a\7\b\2\2\u039a\u039b\7\u00ec\2\2\u039b\u039c")
+ buf.write("\7\30\2\2\u039c\u039d\7\u00fa\2\2\u039d\u039e\7\31\2\2")
+ buf.write("\u039eU\3\2\2\2\u039f\u03a8\7~\2\2\u03a0\u03a8\7y\2\2")
+ buf.write("\u03a1\u03a8\7{\2\2\u03a2\u03a8\7\u0080\2\2\u03a3\u03a8")
+ buf.write("\7|\2\2\u03a4\u03a8\7\177\2\2\u03a5\u03a8\7z\2\2\u03a6")
+ buf.write("\u03a8\7}\2\2\u03a7\u039f\3\2\2\2\u03a7\u03a0\3\2\2\2")
+ buf.write("\u03a7\u03a1\3\2\2\2\u03a7\u03a2\3\2\2\2\u03a7\u03a3\3")
+ buf.write("\2\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6")
+ buf.write("\3\2\2\2\u03a8W\3\2\2\2\u03a9\u03aa\7\u00fb\2\2\u03aa")
+ buf.write("\u03ab\7\32\2\2\u03ab\u03ac\7\u00fa\2\2\u03ac\u03b6\7")
+ buf.write("\33\2\2\u03ad\u03b2\7\u00fb\2\2\u03ae\u03af\7\34\2\2\u03af")
+ buf.write("\u03b1\5\u015c\u00af\2\u03b0\u03ae\3\2\2\2\u03b1\u03b4")
+ buf.write("\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3")
+ buf.write("\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b5\u03a9\3\2\2\2")
+ buf.write("\u03b5\u03ad\3\2\2\2\u03b6Y\3\2\2\2\u03b7\u03b9\7\35\2")
+ buf.write("\2\u03b8\u03b7\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba")
+ buf.write("\3\2\2\2\u03ba\u03e4\7\u00fa\2\2\u03bb\u03e4\7\u00d3\2")
+ buf.write("\2\u03bc\u03e4\7\u00d4\2\2\u03bd\u03e4\7\u00d5\2\2\u03be")
+ buf.write("\u03e4\7\u00d6\2\2\u03bf\u03e4\7\u00d7\2\2\u03c0\u03c1")
+ buf.write("\7\u00fa\2\2\u03c1\u03c2\7\36\2\2\u03c2\u03c3\7\u00fa")
+ buf.write("\2\2\u03c3\u03c4\7\36\2\2\u03c4\u03e4\7\u00fa\2\2\u03c5")
+ buf.write("\u03c6\7\u00fa\2\2\u03c6\u03c7\7\37\2\2\u03c7\u03c8\7")
+ buf.write("\u00fa\2\2\u03c8\u03c9\7\37\2\2\u03c9\u03e4\7\u00fa\2")
+ buf.write("\2\u03ca\u03cb\7\u00fa\2\2\u03cb\u03cc\7 \2\2\u03cc\u03cd")
+ buf.write("\7\u00fa\2\2\u03cd\u03ce\7 \2\2\u03ce\u03cf\5L\'\2\u03cf")
+ buf.write("\u03d0\7 \2\2\u03d0\u03d1\7\u00ec\2\2\u03d1\u03d2\7\30")
+ buf.write("\2\2\u03d2\u03d3\7\u00fa\2\2\u03d3\u03d4\7\31\2\2\u03d4")
+ buf.write("\u03e4\3\2\2\2\u03d5\u03d6\7\u00ec\2\2\u03d6\u03d7\7\30")
+ buf.write("\2\2\u03d7\u03d8\7\u00fa\2\2\u03d8\u03e4\7\31\2\2\u03d9")
+ buf.write("\u03da\7\26\2\2\u03da\u03df\7\u00fa\2\2\u03db\u03dc\7")
+ buf.write("!\2\2\u03dc\u03de\7\u00fa\2\2\u03dd\u03db\3\2\2\2\u03de")
+ buf.write("\u03e1\3\2\2\2\u03df\u03dd\3\2\2\2\u03df\u03e0\3\2\2\2")
+ buf.write("\u03e0\u03e2\3\2\2\2\u03e1\u03df\3\2\2\2\u03e2\u03e4\7")
+ buf.write("\27\2\2\u03e3\u03b8\3\2\2\2\u03e3\u03bb\3\2\2\2\u03e3")
+ buf.write("\u03bc\3\2\2\2\u03e3\u03bd\3\2\2\2\u03e3\u03be\3\2\2\2")
+ buf.write("\u03e3\u03bf\3\2\2\2\u03e3\u03c0\3\2\2\2\u03e3\u03c5\3")
+ buf.write("\2\2\2\u03e3\u03ca\3\2\2\2\u03e3\u03d5\3\2\2\2\u03e3\u03d9")
+ buf.write("\3\2\2\2\u03e4[\3\2\2\2\u03e5\u03e6\7\u0092\2\2\u03e6")
+ buf.write("\u03e7\7\b\2\2\u03e7\u03e8\7\t\2\2\u03e8\u03e9\7\30\2")
+ buf.write("\2\u03e9\u03ea\7\u00fa\2\2\u03ea\u03eb\7\31\2\2\u03eb")
+ buf.write("]\3\2\2\2\u03ec\u03ed\7\u0093\2\2\u03ed_\3\2\2\2\u03ee")
+ buf.write("\u03f1\5\\/\2\u03ef\u03f1\5^\60\2\u03f0\u03ee\3\2\2\2")
+ buf.write("\u03f0\u03ef\3\2\2\2\u03f1a\3\2\2\2\u03f2\u03f7\5`\61")
+ buf.write("\2\u03f3\u03f4\7!\2\2\u03f4\u03f6\5`\61\2\u03f5\u03f3")
+ buf.write("\3\2\2\2\u03f6\u03f9\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7")
+ buf.write("\u03f8\3\2\2\2\u03f8c\3\2\2\2\u03f9\u03f7\3\2\2\2\u03fa")
+ buf.write("\u03fb\7\67\2\2\u03fb\u03fc\7/\2\2\u03fc\u03fd\7\b\2\2")
+ buf.write("\u03fd\u03fe\7\u00fa\2\2\u03fe\u03ff\7!\2\2\u03ff\u0400")
+ buf.write("\7.\2\2\u0400\u0401\7\b\2\2\u0401\u0402\7\u00ec\2\2\u0402")
+ buf.write("\u0403\7\30\2\2\u0403\u0404\7\u00fa\2\2\u0404\u0405\7")
+ buf.write("\31\2\2\u0405\u0409\7 \2\2\u0406\u0408\5f\64\2\u0407\u0406")
+ buf.write("\3\2\2\2\u0408\u040b\3\2\2\2\u0409\u0407\3\2\2\2\u0409")
+ buf.write("\u040a\3\2\2\2\u040a\u040c\3\2\2\2\u040b\u0409\3\2\2\2")
+ buf.write("\u040c\u040d\7\66\2\2\u040d\u040e\7 \2\2\u040ee\3\2\2")
+ buf.write("\2\u040f\u041f\5j\66\2\u0410\u041f\5l\67\2\u0411\u041f")
+ buf.write("\5n8\2\u0412\u041f\5\u00a4S\2\u0413\u041f\5p9\2\u0414")
+ buf.write("\u041f\5\u0088E\2\u0415\u041f\5\u00f8}\2\u0416\u041f\5")
+ buf.write("\u0118\u008d\2\u0417\u041f\5\u011a\u008e\2\u0418\u041f")
+ buf.write("\5\u0110\u0089\2\u0419\u041f\5\u011c\u008f\2\u041a\u041f")
+ buf.write("\5\u0120\u0091\2\u041b\u041c\5\u0096L\2\u041c\u041d\7")
+ buf.write(" \2\2\u041d\u041f\3\2\2\2\u041e\u040f\3\2\2\2\u041e\u0410")
+ buf.write("\3\2\2\2\u041e\u0411\3\2\2\2\u041e\u0412\3\2\2\2\u041e")
+ buf.write("\u0413\3\2\2\2\u041e\u0414\3\2\2\2\u041e\u0415\3\2\2\2")
+ buf.write("\u041e\u0416\3\2\2\2\u041e\u0417\3\2\2\2\u041e\u0418\3")
+ buf.write("\2\2\2\u041e\u0419\3\2\2\2\u041e\u041a\3\2\2\2\u041e\u041b")
+ buf.write("\3\2\2\2\u041fg\3\2\2\2\u0420\u0421\78\2\2\u0421\u0422")
+ buf.write("\7/\2\2\u0422\u0423\7\b\2\2\u0423\u0424\7\u00fa\2\2\u0424")
+ buf.write("\u0433\7!\2\2\u0425\u0426\79\2\2\u0426\u0427\7\b\2\2\u0427")
+ buf.write("\u0428\7\u00ec\2\2\u0428\u0429\7\30\2\2\u0429\u042a\7")
+ buf.write("\u00fa\2\2\u042a\u042b\7\31\2\2\u042b\u042c\7 \2\2\u042c")
+ buf.write("\u042d\7:\2\2\u042d\u042e\7\b\2\2\u042e\u042f\5L\'\2\u042f")
+ buf.write("\u0430\7 \2\2\u0430\u0432\3\2\2\2\u0431\u0425\3\2\2\2")
+ buf.write("\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3")
+ buf.write("\2\2\2\u0434\u0439\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438")
+ buf.write("\5f\64\2\u0437\u0436\3\2\2\2\u0438\u043b\3\2\2\2\u0439")
+ buf.write("\u0437\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043c\3\2\2\2")
+ buf.write("\u043b\u0439\3\2\2\2\u043c\u043d\7\66\2\2\u043d\u043e")
+ buf.write("\7 \2\2\u043ei\3\2\2\2\u043f\u0440\5\\/\2\u0440\u0441")
+ buf.write("\7 \2\2\u0441k\3\2\2\2\u0442\u0443\5^\60\2\u0443\u0444")
+ buf.write("\7 \2\2\u0444m\3\2\2\2\u0445\u0446\7\u0094\2\2\u0446\u0447")
+ buf.write("\7\u00fb\2\2\u0447\u0448\7!\2\2\u0448\u0449\5\u0124\u0093")
+ buf.write("\2\u0449\u044a\7\u0095\2\2\u044a\u044b\7 \2\2\u044bo\3")
+ buf.write("\2\2\2\u044c\u0450\5r:\2\u044d\u0450\5z>\2\u044e\u0450")
+ buf.write("\5~@\2\u044f\u044c\3\2\2\2\u044f\u044d\3\2\2\2\u044f\u044e")
+ buf.write("\3\2\2\2\u0450q\3\2\2\2\u0451\u0452\7;\2\2\u0452\u0453")
+ buf.write("\7>\2\2\u0453\u0454\7\b\2\2\u0454\u0455\7\u00ec\2\2\u0455")
+ buf.write("\u0456\7\30\2\2\u0456\u0457\7\u00fa\2\2\u0457\u045c\7")
+ buf.write("\31\2\2\u0458\u0459\7!\2\2\u0459\u045a\7@\2\2\u045a\u045b")
+ buf.write("\7\b\2\2\u045b\u045d\5v<\2\u045c\u0458\3\2\2\2\u045c\u045d")
+ buf.write("\3\2\2\2\u045d\u0472\3\2\2\2\u045e\u045f\7!\2\2\u045f")
+ buf.write("\u0461\5b\62\2\u0460\u045e\3\2\2\2\u0460\u0461\3\2\2\2")
+ buf.write("\u0461\u0462\3\2\2\2\u0462\u0473\7 \2\2\u0463\u0464\7")
+ buf.write("!\2\2\u0464\u0466\5b\62\2\u0465\u0463\3\2\2\2\u0465\u0466")
+ buf.write("\3\2\2\2\u0466\u046e\3\2\2\2\u0467\u046b\7!\2\2\u0468")
+ buf.write("\u046a\5t;\2\u0469\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b")
+ buf.write("\u0469\3\2\2\2\u046b\u046c\3\2\2\2\u046c\u046f\3\2\2\2")
+ buf.write("\u046d\u046b\3\2\2\2\u046e\u0467\3\2\2\2\u046e\u046f\3")
+ buf.write("\2\2\2\u046f\u0470\3\2\2\2\u0470\u0471\7<\2\2\u0471\u0473")
+ buf.write("\7 \2\2\u0472\u0460\3\2\2\2\u0472\u0465\3\2\2\2\u0473")
+ buf.write("s\3\2\2\2\u0474\u0477\5p9\2\u0475\u0477\5\u0088E\2\u0476")
+ buf.write("\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477u\3\2\2\2\u0478")
+ buf.write("\u047d\5x=\2\u0479\u047a\7(\2\2\u047a\u047c\5x=\2\u047b")
+ buf.write("\u0479\3\2\2\2\u047c\u047f\3\2\2\2\u047d\u047b\3\2\2\2")
+ buf.write("\u047d\u047e\3\2\2\2\u047ew\3\2\2\2\u047f\u047d\3\2\2")
+ buf.write("\2\u0480\u0481\t\5\2\2\u0481y\3\2\2\2\u0482\u0483\7>\2")
+ buf.write("\2\u0483\u0484\7=\2\2\u0484\u0485\7\b\2\2\u0485\u0486")
+ buf.write("\7\u00ec\2\2\u0486\u0487\7\30\2\2\u0487\u0488\7\u00fa")
+ buf.write("\2\2\u0488\u0489\7\31\2\2\u0489\u048a\7!\2\2\u048a\u048b")
+ buf.write("\7>\2\2\u048b\u048c\7\b\2\2\u048c\u048d\7\u00ec\2\2\u048d")
+ buf.write("\u048e\7\30\2\2\u048e\u048f\7\u00fa\2\2\u048f\u0497\7")
+ buf.write("\31\2\2\u0490\u0491\7!\2\2\u0491\u0492\7>\2\2\u0492\u0493")
+ buf.write("\7\b\2\2\u0493\u0494\7\u00ec\2\2\u0494\u0495\7\30\2\2")
+ buf.write("\u0495\u0496\7\u00fa\2\2\u0496\u0498\7\31\2\2\u0497\u0490")
+ buf.write("\3\2\2\2\u0497\u0498\3\2\2\2\u0498\u04a9\3\2\2\2\u0499")
+ buf.write("\u049a\7!\2\2\u049a\u049b\7@\2\2\u049b\u049c\7\b\2\2\u049c")
+ buf.write("\u04a1\5|?\2\u049d\u049e\7(\2\2\u049e\u04a0\5|?\2\u049f")
+ buf.write("\u049d\3\2\2\2\u04a0\u04a3\3\2\2\2\u04a1\u049f\3\2\2\2")
+ buf.write("\u04a1\u04a2\3\2\2\2\u04a2\u04a4\3\2\2\2\u04a3\u04a1\3")
+ buf.write("\2\2\2\u04a4\u04a5\7!\2\2\u04a5\u04a6\7t\2\2\u04a6\u04a7")
+ buf.write("\7\b\2\2\u04a7\u04a8\7\u00fa\2\2\u04a8\u04aa\3\2\2\2\u04a9")
+ buf.write("\u0499\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ad\3\2\2\2")
+ buf.write("\u04ab\u04ac\7!\2\2\u04ac\u04ae\5b\62\2\u04ad\u04ab\3")
+ buf.write("\2\2\2\u04ad\u04ae\3\2\2\2\u04ae\u04af\3\2\2\2\u04af\u04b0")
+ buf.write("\7 \2\2\u04b0{\3\2\2\2\u04b1\u04b4\7\u00fa\2\2\u04b2\u04b4")
+ buf.write("\5V,\2\u04b3\u04b1\3\2\2\2\u04b3\u04b2\3\2\2\2\u04b4}")
+ buf.write("\3\2\2\2\u04b5\u04b8\5\u0080A\2\u04b6\u04b8\5\u0086D\2")
+ buf.write("\u04b7\u04b5\3\2\2\2\u04b7\u04b6\3\2\2\2\u04b8\177\3\2")
+ buf.write("\2\2\u04b9\u04e9\7n\2\2\u04ba\u04bb\7*\2\2\u04bb\u04bc")
+ buf.write("\7\b\2\2\u04bc\u04bd\7\u00ec\2\2\u04bd\u04be\7\30\2\2")
+ buf.write("\u04be\u04bf\7\u00fa\2\2\u04bf\u04c0\7\31\2\2\u04c0\u04c1")
+ buf.write("\7!\2\2\u04c1\u04c2\7o\2\2\u04c2\u04c3\7\b\2\2\u04c3\u04c4")
+ buf.write("\5L\'\2\u04c4\u04c5\7!\2\2\u04c5\u04c6\7/\2\2\u04c6\u04c7")
+ buf.write("\7\b\2\2\u04c7\u04c8\7\u00fa\2\2\u04c8\u04c9\7!\2\2\u04c9")
+ buf.write("\u04ca\7\u0090\2\2\u04ca\u04cb\7\b\2\2\u04cb\u04cc\7\u00fa")
+ buf.write("\2\2\u04cc\u04cd\7!\2\2\u04cd\u04ea\3\2\2\2\u04ce\u04cf")
+ buf.write("\7o\2\2\u04cf\u04d0\7\b\2\2\u04d0\u04d1\5L\'\2\u04d1\u04d2")
+ buf.write("\7!\2\2\u04d2\u04d3\7/\2\2\u04d3\u04d4\7\b\2\2\u04d4\u04d5")
+ buf.write("\7\u00fa\2\2\u04d5\u04d6\7!\2\2\u04d6\u04d7\7\u0090\2")
+ buf.write("\2\u04d7\u04d8\7\b\2\2\u04d8\u04d9\7\u00fa\2\2\u04d9\u04da")
+ buf.write("\7!\2\2\u04da\u04ea\3\2\2\2\u04db\u04dc\7/\2\2\u04dc\u04dd")
+ buf.write("\7\b\2\2\u04dd\u04de\7\u00fa\2\2\u04de\u04df\7!\2\2\u04df")
+ buf.write("\u04e0\7\u0090\2\2\u04e0\u04e5\7\b\2\2\u04e1\u04e2\7\u00fb")
+ buf.write("\2\2\u04e2\u04e6\7!\2\2\u04e3\u04e4\7\u00fa\2\2\u04e4")
+ buf.write("\u04e6\7!\2\2\u04e5\u04e1\3\2\2\2\u04e5\u04e3\3\2\2\2")
+ buf.write("\u04e6\u04ea\3\2\2\2\u04e7\u04e8\7\u00fa\2\2\u04e8\u04ea")
+ buf.write("\7!\2\2\u04e9\u04ba\3\2\2\2\u04e9\u04ce\3\2\2\2\u04e9")
+ buf.write("\u04db\3\2\2\2\u04e9\u04e7\3\2\2\2\u04e9\u04ea\3\2\2\2")
+ buf.write("\u04ea\u04eb\3\2\2\2\u04eb\u04f0\5P)\2\u04ec\u04ed\7!")
+ buf.write("\2\2\u04ed\u04ee\7@\2\2\u04ee\u04ef\7\b\2\2\u04ef\u04f1")
+ buf.write("\5\u0082B\2\u04f0\u04ec\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1")
+ buf.write("\u04f6\3\2\2\2\u04f2\u04f3\7!\2\2\u04f3\u04f4\7t\2\2\u04f4")
+ buf.write("\u04f5\7\b\2\2\u04f5\u04f7\7\u00fa\2\2\u04f6\u04f2\3\2")
+ buf.write("\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04fa\3\2\2\2\u04f8\u04f9")
+ buf.write("\7!\2\2\u04f9\u04fb\5\u00b4[\2\u04fa\u04f8\3\2\2\2\u04fa")
+ buf.write("\u04fb\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u04fd\7 \2\2")
+ buf.write("\u04fd\u0081\3\2\2\2\u04fe\u0503\5\u0084C\2\u04ff\u0500")
+ buf.write("\7(\2\2\u0500\u0502\5\u0084C\2\u0501\u04ff\3\2\2\2\u0502")
+ buf.write("\u0505\3\2\2\2\u0503\u0501\3\2\2\2\u0503\u0504\3\2\2\2")
+ buf.write("\u0504\u0083\3\2\2\2\u0505\u0503\3\2\2\2\u0506\u0509\7")
+ buf.write("\u00fa\2\2\u0507\u0509\5V,\2\u0508\u0506\3\2\2\2\u0508")
+ buf.write("\u0507\3\2\2\2\u0509\u0085\3\2\2\2\u050a\u050b\7\u0099")
+ buf.write("\2\2\u050b\u050c\7\u009b\2\2\u050c\u050d\7\b\2\2\u050d")
+ buf.write("\u050e\7\u00fb\2\2\u050e\u050f\7!\2\2\u050f\u0510\5T+")
+ buf.write("\2\u0510\u0514\7!\2\2\u0511\u0512\5b\62\2\u0512\u0513")
+ buf.write("\7!\2\2\u0513\u0515\3\2\2\2\u0514\u0511\3\2\2\2\u0514")
+ buf.write("\u0515\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0517\7\u009a")
+ buf.write("\2\2\u0517\u0518\7 \2\2\u0518\u0087\3\2\2\2\u0519\u0520")
+ buf.write("\5\u00b8]\2\u051a\u0520\5\u00e8u\2\u051b\u0520\5\u00c6")
+ buf.write("d\2\u051c\u0520\5\u00d4k\2\u051d\u0520\5\u00e2r\2\u051e")
+ buf.write("\u0520\5\u00f0y\2\u051f\u0519\3\2\2\2\u051f\u051a\3\2")
+ buf.write("\2\2\u051f\u051b\3\2\2\2\u051f\u051c\3\2\2\2\u051f\u051d")
+ buf.write("\3\2\2\2\u051f\u051e\3\2\2\2\u0520\u0089\3\2\2\2\u0521")
+ buf.write("\u0522\5`\61\2\u0522\u0523\7!\2\2\u0523\u052d\3\2\2\2")
+ buf.write("\u0524\u052d\5\u008cG\2\u0525\u052d\5\u008eH\2\u0526\u052d")
+ buf.write("\5\u0090I\2\u0527\u052d\5\u0092J\2\u0528\u052d\5\u0094")
+ buf.write("K\2\u0529\u052d\5\u011c\u008f\2\u052a\u052d\5\u0096L\2")
+ buf.write("\u052b\u052d\5\u0098M\2\u052c\u0521\3\2\2\2\u052c\u0524")
+ buf.write("\3\2\2\2\u052c\u0525\3\2\2\2\u052c\u0526\3\2\2\2\u052c")
+ buf.write("\u0527\3\2\2\2\u052c\u0528\3\2\2\2\u052c\u0529\3\2\2\2")
+ buf.write("\u052c\u052a\3\2\2\2\u052c\u052b\3\2\2\2\u052d\u008b\3")
+ buf.write("\2\2\2\u052e\u052f\7p\2\2\u052f\u0530\7\62\2\2\u0530\u0531")
+ buf.write("\7\b\2\2\u0531\u0532\7\u00ec\2\2\u0532\u0533\7\30\2\2")
+ buf.write("\u0533\u0534\7\u00fa\2\2\u0534\u0535\7\31\2\2\u0535\u0542")
+ buf.write("\7!\2\2\u0536\u0537\7@\2\2\u0537\u0538\7\b\2\2\u0538\u053d")
+ buf.write("\5\u009eP\2\u0539\u053a\7(\2\2\u053a\u053c\5\u009eP\2")
+ buf.write("\u053b\u0539\3\2\2\2\u053c\u053f\3\2\2\2\u053d\u053b\3")
+ buf.write("\2\2\2\u053d\u053e\3\2\2\2\u053e\u0540\3\2\2\2\u053f\u053d")
+ buf.write("\3\2\2\2\u0540\u0541\7!\2\2\u0541\u0543\3\2\2\2\u0542")
+ buf.write("\u0536\3\2\2\2\u0542\u0543\3\2\2\2\u0543\u0544\3\2\2\2")
+ buf.write("\u0544\u0545\5\u0124\u0093\2\u0545\u0547\7s\2\2\u0546")
+ buf.write("\u0548\7 \2\2\u0547\u0546\3\2\2\2\u0547\u0548\3\2\2\2")
+ buf.write("\u0548\u008d\3\2\2\2\u0549\u054a\7r\2\2\u054a\u054b\7")
+ buf.write("\62\2\2\u054b\u054c\7\b\2\2\u054c\u054d\7\u00ec\2\2\u054d")
+ buf.write("\u054e\7\30\2\2\u054e\u054f\7\u00fa\2\2\u054f\u0550\7")
+ buf.write("\31\2\2\u0550\u055d\7!\2\2\u0551\u0552\7@\2\2\u0552\u0553")
+ buf.write("\7\b\2\2\u0553\u0558\5\u009eP\2\u0554\u0555\7(\2\2\u0555")
+ buf.write("\u0557\5\u009eP\2\u0556\u0554\3\2\2\2\u0557\u055a\3\2")
+ buf.write("\2\2\u0558\u0556\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u055b")
+ buf.write("\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7!\2\2\u055c")
+ buf.write("\u055e\3\2\2\2\u055d\u0551\3\2\2\2\u055d\u055e\3\2\2\2")
+ buf.write("\u055e\u055f\3\2\2\2\u055f\u0560\5\u0124\u0093\2\u0560")
+ buf.write("\u0562\7s\2\2\u0561\u0563\7 \2\2\u0562\u0561\3\2\2\2\u0562")
+ buf.write("\u0563\3\2\2\2\u0563\u008f\3\2\2\2\u0564\u0565\7l\2\2")
+ buf.write("\u0565\u0566\5\u0124\u0093\2\u0566\u0567\7 \2\2\u0567")
+ buf.write("\u0568\5\u00b4[\2\u0568\u056a\7s\2\2\u0569\u056b\7 \2")
+ buf.write("\2\u056a\u0569\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u0091")
+ buf.write("\3\2\2\2\u056c\u056d\7\u00a4\2\2\u056d\u056e\7\u00a5\2")
+ buf.write("\2\u056e\u056f\7\b\2\2\u056f\u0570\7\u00fa\2\2\u0570\u0093")
+ buf.write("\3\2\2\2\u0571\u0572\7\u00a6\2\2\u0572\u0573\7\b\2\2\u0573")
+ buf.write("\u0574\7\u00ec\2\2\u0574\u0575\7\30\2\2\u0575\u0576\7")
+ buf.write("\u00fa\2\2\u0576\u0577\7\31\2\2\u0577\u0578\7!\2\2\u0578")
+ buf.write("\u0095\3\2\2\2\u0579\u057a\7\u00eb\2\2\u057a\u057b\7\b")
+ buf.write("\2\2\u057b\u057c\5L\'\2\u057c\u057d\7!\2\2\u057d\u0097")
+ buf.write("\3\2\2\2\u057e\u057f\7q\2\2\u057f\u0580\7\62\2\2\u0580")
+ buf.write("\u0581\7\b\2\2\u0581\u0582\7\u00ec\2\2\u0582\u0583\7\30")
+ buf.write("\2\2\u0583\u0584\7\u00fa\2\2\u0584\u0585\7\31\2\2\u0585")
+ buf.write("\u058a\7!\2\2\u0586\u0587\7M\2\2\u0587\u0588\7\b\2\2\u0588")
+ buf.write("\u0589\7\u00fa\2\2\u0589\u058b\7!\2\2\u058a\u0586\3\2")
+ buf.write("\2\2\u058a\u058b\3\2\2\2\u058b\u058c\3\2\2\2\u058c\u058d")
+ buf.write("\5\u0124\u0093\2\u058d\u058f\7s\2\2\u058e\u0590\7 \2\2")
+ buf.write("\u058f\u058e\3\2\2\2\u058f\u0590\3\2\2\2\u0590\u0099\3")
+ buf.write("\2\2\2\u0591\u0593\5\u008aF\2\u0592\u0591\3\2\2\2\u0593")
+ buf.write("\u0596\3\2\2\2\u0594\u0592\3\2\2\2\u0594\u0595\3\2\2\2")
+ buf.write("\u0595\u009b\3\2\2\2\u0596\u0594\3\2\2\2\u0597\u059f\5")
+ buf.write("\u00a0Q\2\u0598\u059f\5\u00a2R\2\u0599\u059f\5\u00a6T")
+ buf.write("\2\u059a\u059f\5\u00a4S\2\u059b\u059f\5\u00a8U\2\u059c")
+ buf.write("\u059f\5\u00b0Y\2\u059d\u059f\5\u00b2Z\2\u059e\u0597\3")
+ buf.write("\2\2\2\u059e\u0598\3\2\2\2\u059e\u0599\3\2\2\2\u059e\u059a")
+ buf.write("\3\2\2\2\u059e\u059b\3\2\2\2\u059e\u059c\3\2\2\2\u059e")
+ buf.write("\u059d\3\2\2\2\u059f\u009d\3\2\2\2\u05a0\u05a9\7\u00fa")
+ buf.write("\2\2\u05a1\u05a9\7y\2\2\u05a2\u05a9\7v\2\2\u05a3\u05a9")
+ buf.write("\7u\2\2\u05a4\u05a9\7{\2\2\u05a5\u05a9\7|\2\2\u05a6\u05a9")
+ buf.write("\7z\2\2\u05a7\u05a9\7}\2\2\u05a8\u05a0\3\2\2\2\u05a8\u05a1")
+ buf.write("\3\2\2\2\u05a8\u05a2\3\2\2\2\u05a8\u05a3\3\2\2\2\u05a8")
+ buf.write("\u05a4\3\2\2\2\u05a8\u05a5\3\2\2\2\u05a8\u05a6\3\2\2\2")
+ buf.write("\u05a8\u05a7\3\2\2\2\u05a9\u009f\3\2\2\2\u05aa\u05ab\7")
+ buf.write("k\2\2\u05ab\u05ac\5\u0124\u0093\2\u05ac\u05b9\7 \2\2\u05ad")
+ buf.write("\u05ae\7@\2\2\u05ae\u05af\7\b\2\2\u05af\u05b4\5\u009e")
+ buf.write("P\2\u05b0\u05b1\7(\2\2\u05b1\u05b3\5\u009eP\2\u05b2\u05b0")
+ buf.write("\3\2\2\2\u05b3\u05b6\3\2\2\2\u05b4\u05b2\3\2\2\2\u05b4")
+ buf.write("\u05b5\3\2\2\2\u05b5\u05b7\3\2\2\2\u05b6\u05b4\3\2\2\2")
+ buf.write("\u05b7\u05b8\7!\2\2\u05b8\u05ba\3\2\2\2\u05b9\u05ad\3")
+ buf.write("\2\2\2\u05b9\u05ba\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc")
+ buf.write("\5\u00b4[\2\u05bc\u05be\7s\2\2\u05bd\u05bf\7 \2\2\u05be")
+ buf.write("\u05bd\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf\u00a1\3\2\2\2")
+ buf.write("\u05c0\u05c1\7K\2\2\u05c1\u05c2\5\u0124\u0093\2\u05c2")
+ buf.write("\u05cf\7 \2\2\u05c3\u05c4\7@\2\2\u05c4\u05c5\7\b\2\2\u05c5")
+ buf.write("\u05ca\5\u009eP\2\u05c6\u05c7\7(\2\2\u05c7\u05c9\5\u009e")
+ buf.write("P\2\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3\2\2\2\u05ca\u05c8")
+ buf.write("\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cd\3\2\2\2\u05cc")
+ buf.write("\u05ca\3\2\2\2\u05cd\u05ce\7!\2\2\u05ce\u05d0\3\2\2\2")
+ buf.write("\u05cf\u05c3\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u05d1\3")
+ buf.write("\2\2\2\u05d1\u05d2\5\u00b4[\2\u05d2\u05d4\7s\2\2\u05d3")
+ buf.write("\u05d5\7 \2\2\u05d4\u05d3\3\2\2\2\u05d4\u05d5\3\2\2\2")
+ buf.write("\u05d5\u00a3\3\2\2\2\u05d6\u05de\7c\2\2\u05d7\u05d8\5")
+ buf.write("\u00a6T\2\u05d8\u05d9\7!\2\2\u05d9\u05df\3\2\2\2\u05da")
+ buf.write("\u05db\7\b\2\2\u05db\u05dc\5Z.\2\u05dc\u05dd\7!\2\2\u05dd")
+ buf.write("\u05df\3\2\2\2\u05de\u05d7\3\2\2\2\u05de\u05da\3\2\2\2")
+ buf.write("\u05df\u05e4\3\2\2\2\u05e0\u05e1\7\u009b\2\2\u05e1\u05e2")
+ buf.write("\7\b\2\2\u05e2\u05e3\7\u00fb\2\2\u05e3\u05e5\7!\2\2\u05e4")
+ buf.write("\u05e0\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5\u00a5\3\2\2\2")
+ buf.write("\u05e6\u05e7\7\u0096\2\2\u05e7\u05e8\7\b\2\2\u05e8\u05e9")
+ buf.write("\5\u0124\u0093\2\u05e9\u00a7\3\2\2\2\u05ea\u05eb\5\u00aa")
+ buf.write("V\2\u05eb\u00a9\3\2\2\2\u05ec\u05ed\7?\2\2\u05ed\u05ee")
+ buf.write("\7>\2\2\u05ee\u05ef\7\b\2\2\u05ef\u05f0\7\u00ec\2\2\u05f0")
+ buf.write("\u05f1\7\30\2\2\u05f1\u05f2\7\u00fa\2\2\u05f2\u05f3\7")
+ buf.write("\31\2\2\u05f3\u05f4\7!\2\2\u05f4\u05f5\7\u0096\2\2\u05f5")
+ buf.write("\u05f6\7\b\2\2\u05f6\u05f7\5Z.\2\u05f7\u05f8\7!\2\2\u05f8")
+ buf.write("\u05f9\7@\2\2\u05f9\u05fa\7\b\2\2\u05fa\u05ff\5\u00ac")
+ buf.write("W\2\u05fb\u05fc\7!\2\2\u05fc\u05fd\7t\2\2\u05fd\u05fe")
+ buf.write("\7\b\2\2\u05fe\u0600\7\u00fa\2\2\u05ff\u05fb\3\2\2\2\u05ff")
+ buf.write("\u0600\3\2\2\2\u0600\u0605\3\2\2\2\u0601\u0602\7!\2\2")
+ buf.write("\u0602\u0604\5\\/\2\u0603\u0601\3\2\2\2\u0604\u0607\3")
+ buf.write("\2\2\2\u0605\u0603\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0608")
+ buf.write("\3\2\2\2\u0607\u0605\3\2\2\2\u0608\u0609\7 \2\2\u0609")
+ buf.write("\u00ab\3\2\2\2\u060a\u060f\5\u00aeX\2\u060b\u060c\7(\2")
+ buf.write("\2\u060c\u060e\5\u00aeX\2\u060d\u060b\3\2\2\2\u060e\u0611")
+ buf.write("\3\2\2\2\u060f\u060d\3\2\2\2\u060f\u0610\3\2\2\2\u0610")
+ buf.write("\u00ad\3\2\2\2\u0611\u060f\3\2\2\2\u0612\u061e\7\u00fa")
+ buf.write("\2\2\u0613\u061e\7\u00ed\2\2\u0614\u061e\7\u00ee\2\2\u0615")
+ buf.write("\u061e\7y\2\2\u0616\u061e\7{\2\2\u0617\u061e\7\u0080\2")
+ buf.write("\2\u0618\u061e\7|\2\2\u0619\u061e\7v\2\2\u061a\u061e\7")
+ buf.write("u\2\2\u061b\u061e\7z\2\2\u061c\u061e\7}\2\2\u061d\u0612")
+ buf.write("\3\2\2\2\u061d\u0613\3\2\2\2\u061d\u0614\3\2\2\2\u061d")
+ buf.write("\u0615\3\2\2\2\u061d\u0616\3\2\2\2\u061d\u0617\3\2\2\2")
+ buf.write("\u061d\u0618\3\2\2\2\u061d\u0619\3\2\2\2\u061d\u061a\3")
+ buf.write("\2\2\2\u061d\u061b\3\2\2\2\u061d\u061c\3\2\2\2\u061e\u00af")
+ buf.write("\3\2\2\2\u061f\u0620\7\u0097\2\2\u0620\u0621\5\u0124\u0093")
+ buf.write("\2\u0621\u0622\7 \2\2\u0622\u00b1\3\2\2\2\u0623\u0624")
+ buf.write("\7\u0098\2\2\u0624\u0625\5\u0124\u0093\2\u0625\u0626\7")
+ buf.write(" \2\2\u0626\u00b3\3\2\2\2\u0627\u0629\5\u00b6\\\2\u0628")
+ buf.write("\u0627\3\2\2\2\u0629\u062c\3\2\2\2\u062a\u0628\3\2\2\2")
+ buf.write("\u062a\u062b\3\2\2\2\u062b\u00b5\3\2\2\2\u062c\u062a\3")
+ buf.write("\2\2\2\u062d\u0630\5\u008aF\2\u062e\u0630\5\u009cO\2\u062f")
+ buf.write("\u062d\3\2\2\2\u062f\u062e\3\2\2\2\u0630\u00b7\3\2\2\2")
+ buf.write("\u0631\u0634\5\u00ba^\2\u0632\u0634\5\u00c0a\2\u0633\u0631")
+ buf.write("\3\2\2\2\u0633\u0632\3\2\2\2\u0634\u00b9\3\2\2\2\u0635")
+ buf.write("\u0636\7\\\2\2\u0636\u0637\5R*\2\u0637\u0638\5T+\2\u0638")
+ buf.write("\u063e\7!\2\2\u0639\u063a\7@\2\2\u063a\u063b\7\b\2\2\u063b")
+ buf.write("\u063c\5\u00bc_\2\u063c\u063d\7!\2\2\u063d\u063f\3\2\2")
+ buf.write("\2\u063e\u0639\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0644")
+ buf.write("\3\2\2\2\u0640\u0641\7t\2\2\u0641\u0642\7\b\2\2\u0642")
+ buf.write("\u0643\7\u00fa\2\2\u0643\u0645\7!\2\2\u0644\u0640\3\2")
+ buf.write("\2\2\u0644\u0645\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0647")
+ buf.write("\5\u00b4[\2\u0647\u0648\7]\2\2\u0648\u0649\7 \2\2\u0649")
+ buf.write("\u00bb\3\2\2\2\u064a\u064f\5\u00be`\2\u064b\u064c\7(\2")
+ buf.write("\2\u064c\u064e\5\u00be`\2\u064d\u064b\3\2\2\2\u064e\u0651")
+ buf.write("\3\2\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650")
+ buf.write("\u00bd\3\2\2\2\u0651\u064f\3\2\2\2\u0652\u0659\7\u00fa")
+ buf.write("\2\2\u0653\u0659\7u\2\2\u0654\u0659\7v\2\2\u0655\u0659")
+ buf.write("\7w\2\2\u0656\u0659\7x\2\2\u0657\u0659\5V,\2\u0658\u0652")
+ buf.write("\3\2\2\2\u0658\u0653\3\2\2\2\u0658\u0654\3\2\2\2\u0658")
+ buf.write("\u0655\3\2\2\2\u0658\u0656\3\2\2\2\u0658\u0657\3\2\2\2")
+ buf.write("\u0659\u00bf\3\2\2\2\u065a\u065b\7\u00a1\2\2\u065b\u065c")
+ buf.write("\5P)\2\u065c\u0662\7!\2\2\u065d\u065e\7@\2\2\u065e\u065f")
+ buf.write("\7\b\2\2\u065f\u0660\5\u00c2b\2\u0660\u0661\7!\2\2\u0661")
+ buf.write("\u0663\3\2\2\2\u0662\u065d\3\2\2\2\u0662\u0663\3\2\2\2")
+ buf.write("\u0663\u0664\3\2\2\2\u0664\u0665\7\u00a2\2\2\u0665\u0666")
+ buf.write("\7\b\2\2\u0666\u0667\7\u00ec\2\2\u0667\u0668\7\30\2\2")
+ buf.write("\u0668\u0669\7\u00fa\2\2\u0669\u066a\7\31\2\2\u066a\u066b")
+ buf.write("\7!\2\2\u066b\u066c\5\u009aN\2\u066c\u066d\7\u00a3\2\2")
+ buf.write("\u066d\u066e\7 \2\2\u066e\u00c1\3\2\2\2\u066f\u0674\5")
+ buf.write("\u00c4c\2\u0670\u0671\7(\2\2\u0671\u0673\5\u00c4c\2\u0672")
+ buf.write("\u0670\3\2\2\2\u0673\u0676\3\2\2\2\u0674\u0672\3\2\2\2")
+ buf.write("\u0674\u0675\3\2\2\2\u0675\u00c3\3\2\2\2\u0676\u0674\3")
+ buf.write("\2\2\2\u0677\u067a\7\u00fa\2\2\u0678\u067a\5V,\2\u0679")
+ buf.write("\u0677\3\2\2\2\u0679\u0678\3\2\2\2\u067a\u00c5\3\2\2\2")
+ buf.write("\u067b\u067e\5\u00c8e\2\u067c\u067e\5\u00d0i\2\u067d\u067b")
+ buf.write("\3\2\2\2\u067d\u067c\3\2\2\2\u067e\u00c7\3\2\2\2\u067f")
+ buf.write("\u0680\7^\2\2\u0680\u0681\5R*\2\u0681\u0682\5T+\2\u0682")
+ buf.write("\u0688\7!\2\2\u0683\u0684\7@\2\2\u0684\u0685\7\b\2\2\u0685")
+ buf.write("\u0686\5\u00ccg\2\u0686\u0687\7!\2\2\u0687\u0689\3\2\2")
+ buf.write("\2\u0688\u0683\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068e")
+ buf.write("\3\2\2\2\u068a\u068b\7t\2\2\u068b\u068c\7\b\2\2\u068c")
+ buf.write("\u068d\7\u00fa\2\2\u068d\u068f\7!\2\2\u068e\u068a\3\2")
+ buf.write("\2\2\u068e\u068f\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u0691")
+ buf.write("\5\u00caf\2\u0691\u0692\5\u00b4[\2\u0692\u0693\7_\2\2")
+ buf.write("\u0693\u0694\7 \2\2\u0694\u00c9\3\2\2\2\u0695\u0696\7")
+ buf.write("`\2\2\u0696\u0698\7\b\2\2\u0697\u0699\7\35\2\2\u0698\u0697")
+ buf.write("\3\2\2\2\u0698\u0699\3\2\2\2\u0699\u069a\3\2\2\2\u069a")
+ buf.write("\u069b\7\u00fa\2\2\u069b\u069c\7!\2\2\u069c\u069d\7a\2")
+ buf.write("\2\u069d\u069f\7\b\2\2\u069e\u06a0\7\35\2\2\u069f\u069e")
+ buf.write("\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1")
+ buf.write("\u06a2\7\u00fa\2\2\u06a2\u06a7\7!\2\2\u06a3\u06a4\7b\2")
+ buf.write("\2\u06a4\u06a5\7\b\2\2\u06a5\u06a6\7\u00fa\2\2\u06a6\u06a8")
+ buf.write("\7!\2\2\u06a7\u06a3\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8")
+ buf.write("\u00cb\3\2\2\2\u06a9\u06ae\5\u00ceh\2\u06aa\u06ab\7(\2")
+ buf.write("\2\u06ab\u06ad\5\u00ceh\2\u06ac\u06aa\3\2\2\2\u06ad\u06b0")
+ buf.write("\3\2\2\2\u06ae\u06ac\3\2\2\2\u06ae\u06af\3\2\2\2\u06af")
+ buf.write("\u00cd\3\2\2\2\u06b0\u06ae\3\2\2\2\u06b1\u06bb\7\u00fa")
+ buf.write("\2\2\u06b2\u06bb\7\u00ef\2\2\u06b3\u06bb\7\u00f0\2\2\u06b4")
+ buf.write("\u06bb\7\u00f1\2\2\u06b5\u06bb\7\u00f2\2\2\u06b6\u06bb")
+ buf.write("\7\u00f3\2\2\u06b7\u06bb\7\u00f4\2\2\u06b8\u06bb\7\u00f5")
+ buf.write("\2\2\u06b9\u06bb\5V,\2\u06ba\u06b1\3\2\2\2\u06ba\u06b2")
+ buf.write("\3\2\2\2\u06ba\u06b3\3\2\2\2\u06ba\u06b4\3\2\2\2\u06ba")
+ buf.write("\u06b5\3\2\2\2\u06ba\u06b6\3\2\2\2\u06ba\u06b7\3\2\2\2")
+ buf.write("\u06ba\u06b8\3\2\2\2\u06ba\u06b9\3\2\2\2\u06bb\u00cf\3")
+ buf.write("\2\2\2\u06bc\u06bd\7\60\2\2\u06bd\u06be\5R*\2\u06be\u06bf")
+ buf.write("\5T+\2\u06bf\u06c5\7!\2\2\u06c0\u06c1\7@\2\2\u06c1\u06c2")
+ buf.write("\7\b\2\2\u06c2\u06c3\5\u00d2j\2\u06c3\u06c4\7!\2\2\u06c4")
+ buf.write("\u06c6\3\2\2\2\u06c5\u06c0\3\2\2\2\u06c5\u06c6\3\2\2\2")
+ buf.write("\u06c6\u06c8\3\2\2\2\u06c7\u06c9\5\u00caf\2\u06c8\u06c7")
+ buf.write("\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06ca\3\2\2\2\u06ca")
+ buf.write("\u06cb\5\u00b4[\2\u06cb\u06cc\7\61\2\2\u06cc\u06cd\7 ")
+ buf.write("\2\2\u06cd\u00d1\3\2\2\2\u06ce\u06d3\5\u00ceh\2\u06cf")
+ buf.write("\u06d0\7(\2\2\u06d0\u06d2\5\u00ceh\2\u06d1\u06cf\3\2\2")
+ buf.write("\2\u06d2\u06d5\3\2\2\2\u06d3\u06d1\3\2\2\2\u06d3\u06d4")
+ buf.write("\3\2\2\2\u06d4\u00d3\3\2\2\2\u06d5\u06d3\3\2\2\2\u06d6")
+ buf.write("\u06d9\5\u00d6l\2\u06d7\u06d9\5\u00dco\2\u06d8\u06d6\3")
+ buf.write("\2\2\2\u06d8\u06d7\3\2\2\2\u06d9\u00d5\3\2\2\2\u06da\u06db")
+ buf.write("\7f\2\2\u06db\u06dc\5P)\2\u06dc\u06e2\7!\2\2\u06dd\u06de")
+ buf.write("\7@\2\2\u06de\u06df\7\b\2\2\u06df\u06e0\5\u00d8m\2\u06e0")
+ buf.write("\u06e1\7!\2\2\u06e1\u06e3\3\2\2\2\u06e2\u06dd\3\2\2\2")
+ buf.write("\u06e2\u06e3\3\2\2\2\u06e3\u06e8\3\2\2\2\u06e4\u06e5\7")
+ buf.write("t\2\2\u06e5\u06e6\7\b\2\2\u06e6\u06e7\7\u00fa\2\2\u06e7")
+ buf.write("\u06e9\7!\2\2\u06e8\u06e4\3\2\2\2\u06e8\u06e9\3\2\2\2")
+ buf.write("\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7h\2\2\u06eb\u06ec\7")
+ buf.write("\b\2\2\u06ec\u06ed\7\u00fa\2\2\u06ed\u06ee\7!\2\2\u06ee")
+ buf.write("\u06ef\7i\2\2\u06ef\u06f0\7\b\2\2\u06f0\u06f1\7\u00fa")
+ buf.write("\2\2\u06f1\u06f2\7!\2\2\u06f2\u06f3\5\u00b4[\2\u06f3\u06f4")
+ buf.write("\7g\2\2\u06f4\u06f5\7 \2\2\u06f5\u00d7\3\2\2\2\u06f6\u06fb")
+ buf.write("\5\u00dan\2\u06f7\u06f8\7(\2\2\u06f8\u06fa\5\u00dan\2")
+ buf.write("\u06f9\u06f7\3\2\2\2\u06fa\u06fd\3\2\2\2\u06fb\u06f9\3")
+ buf.write("\2\2\2\u06fb\u06fc\3\2\2\2\u06fc\u00d9\3\2\2\2\u06fd\u06fb")
+ buf.write("\3\2\2\2\u06fe\u0702\7\u00fa\2\2\u06ff\u0702\7\13\2\2")
+ buf.write("\u0700\u0702\5V,\2\u0701\u06fe\3\2\2\2\u0701\u06ff\3\2")
+ buf.write("\2\2\u0701\u0700\3\2\2\2\u0702\u00db\3\2\2\2\u0703\u0704")
+ buf.write("\7d\2\2\u0704\u0705\5P)\2\u0705\u070b\7!\2\2\u0706\u0707")
+ buf.write("\7@\2\2\u0707\u0708\7\b\2\2\u0708\u0709\5\u00dep\2\u0709")
+ buf.write("\u070a\7!\2\2\u070a\u070c\3\2\2\2\u070b\u0706\3\2\2\2")
+ buf.write("\u070b\u070c\3\2\2\2\u070c\u0711\3\2\2\2\u070d\u070e\7")
+ buf.write("t\2\2\u070e\u070f\7\b\2\2\u070f\u0710\7\u00fa\2\2\u0710")
+ buf.write("\u0712\7!\2\2\u0711\u070d\3\2\2\2\u0711\u0712\3\2\2\2")
+ buf.write("\u0712\u0713\3\2\2\2\u0713\u0714\7h\2\2\u0714\u0715\7")
+ buf.write("\b\2\2\u0715\u0716\7\u00fa\2\2\u0716\u0717\7!\2\2\u0717")
+ buf.write("\u0718\7i\2\2\u0718\u0719\7\b\2\2\u0719\u071a\7\u00fa")
+ buf.write("\2\2\u071a\u071f\7!\2\2\u071b\u071c\7j\2\2\u071c\u071d")
+ buf.write("\7\b\2\2\u071d\u071e\7\u00fa\2\2\u071e\u0720\7!\2\2\u071f")
+ buf.write("\u071b\3\2\2\2\u071f\u0720\3\2\2\2\u0720\u0721\3\2\2\2")
+ buf.write("\u0721\u0722\5\u00b4[\2\u0722\u0723\7e\2\2\u0723\u0724")
+ buf.write("\7 \2\2\u0724\u00dd\3\2\2\2\u0725\u072a\5\u00e0q\2\u0726")
+ buf.write("\u0727\7(\2\2\u0727\u0729\5\u00e0q\2\u0728\u0726\3\2\2")
+ buf.write("\2\u0729\u072c\3\2\2\2\u072a\u0728\3\2\2\2\u072a\u072b")
+ buf.write("\3\2\2\2\u072b\u00df\3\2\2\2\u072c\u072a\3\2\2\2\u072d")
+ buf.write("\u0730\7\u00fa\2\2\u072e\u0730\5V,\2\u072f\u072d\3\2\2")
+ buf.write("\2\u072f\u072e\3\2\2\2\u0730\u00e1\3\2\2\2\u0731\u0732")
+ buf.write("\7\63\2\2\u0732\u0733\5P)\2\u0733\u0738\7!\2\2\u0734\u0735")
+ buf.write("\7\64\2\2\u0735\u0736\7\b\2\2\u0736\u0737\7\u00fa\2\2")
+ buf.write("\u0737\u0739\7!\2\2\u0738\u0734\3\2\2\2\u0738\u0739\3")
+ buf.write("\2\2\2\u0739\u073f\3\2\2\2\u073a\u073b\7@\2\2\u073b\u073c")
+ buf.write("\7\b\2\2\u073c\u073d\5\u00e4s\2\u073d\u073e\7!\2\2\u073e")
+ buf.write("\u0740\3\2\2\2\u073f\u073a\3\2\2\2\u073f\u0740\3\2\2\2")
+ buf.write("\u0740\u0741\3\2\2\2\u0741\u0742\5\u00b4[\2\u0742\u0743")
+ buf.write("\7\65\2\2\u0743\u0744\7 \2\2\u0744\u00e3\3\2\2\2\u0745")
+ buf.write("\u074a\5\u00e6t\2\u0746\u0747\7(\2\2\u0747\u0749\5\u00e6")
+ buf.write("t\2\u0748\u0746\3\2\2\2\u0749\u074c\3\2\2\2\u074a\u0748")
+ buf.write("\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u00e5\3\2\2\2\u074c")
+ buf.write("\u074a\3\2\2\2\u074d\u0752\7\u00fa\2\2\u074e\u0752\7\u00c0")
+ buf.write("\2\2\u074f\u0752\7\u00c1\2\2\u0750\u0752\5V,\2\u0751\u074d")
+ buf.write("\3\2\2\2\u0751\u074e\3\2\2\2\u0751\u074f\3\2\2\2\u0751")
+ buf.write("\u0750\3\2\2\2\u0752\u00e7\3\2\2\2\u0753\u07ae\7A\2\2")
+ buf.write("\u0754\u0755\5P)\2\u0755\u075b\7!\2\2\u0756\u0757\7@\2")
+ buf.write("\2\u0757\u0758\7\b\2\2\u0758\u0759\5\u00ecw\2\u0759\u075a")
+ buf.write("\7!\2\2\u075a\u075c\3\2\2\2\u075b\u0756\3\2\2\2\u075b")
+ buf.write("\u075c\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u075e\5\u00b4")
+ buf.write("[\2\u075e\u07af\3\2\2\2\u075f\u0760\7C\2\2\u0760\u0761")
+ buf.write("\7\u008f\2\2\u0761\u0762\7\b\2\2\u0762\u0763\7\u00fb\2")
+ buf.write("\2\u0763\u0764\7\34\2\2\u0764\u0765\7\u00fb\2\2\u0765")
+ buf.write("\u0766\7!\2\2\u0766\u0767\7\62\2\2\u0767\u0768\7\b\2\2")
+ buf.write("\u0768\u0769\7\u00ec\2\2\u0769\u076a\7\30\2\2\u076a\u076b")
+ buf.write("\7\u00fa\2\2\u076b\u076c\7\31\2\2\u076c\u076d\7!\2\2\u076d")
+ buf.write("\u076e\7=\2\2\u076e\u076f\7\b\2\2\u076f\u0770\7\u00ec")
+ buf.write("\2\2\u0770\u0771\7\30\2\2\u0771\u0772\7\u00fa\2\2\u0772")
+ buf.write("\u0773\7\31\2\2\u0773\u0774\7!\2\2\u0774\u0775\5\u00ea")
+ buf.write("v\2\u0775\u0776\7D\2\2\u0776\u0777\7\u008f\2\2\u0777\u0778")
+ buf.write("\7\b\2\2\u0778\u0779\7\u00fb\2\2\u0779\u077a\7\34\2\2")
+ buf.write("\u077a\u077b\7\u00fb\2\2\u077b\u077c\7!\2\2\u077c\u077d")
+ buf.write("\7\62\2\2\u077d\u077e\7\b\2\2\u077e\u077f\7\u00ec\2\2")
+ buf.write("\u077f\u0780\7\30\2\2\u0780\u0781\7\u00fa\2\2\u0781\u0782")
+ buf.write("\7\31\2\2\u0782\u0783\7!\2\2\u0783\u0784\7=\2\2\u0784")
+ buf.write("\u0785\7\b\2\2\u0785\u0786\7\u00ec\2\2\u0786\u0787\7\30")
+ buf.write("\2\2\u0787\u0788\7\u00fa\2\2\u0788\u0789\7\31\2\2\u0789")
+ buf.write("\u078a\7!\2\2\u078a\u078b\5\u00eav\2\u078b\u078c\7E\2")
+ buf.write("\2\u078c\u078d\7\u008f\2\2\u078d\u078e\7\b\2\2\u078e\u078f")
+ buf.write("\7\u00fb\2\2\u078f\u0790\7\34\2\2\u0790\u0791\7\u00fb")
+ buf.write("\2\2\u0791\u0792\7!\2\2\u0792\u0793\7\62\2\2\u0793\u0794")
+ buf.write("\7\b\2\2\u0794\u0795\7\u00ec\2\2\u0795\u0796\7\30\2\2")
+ buf.write("\u0796\u0797\7\u00fa\2\2\u0797\u0798\7\31\2\2\u0798\u0799")
+ buf.write("\7!\2\2\u0799\u079a\7=\2\2\u079a\u079b\7\b\2\2\u079b\u079c")
+ buf.write("\7\u00ec\2\2\u079c\u079d\7\30\2\2\u079d\u079e\7\u00fa")
+ buf.write("\2\2\u079e\u079f\7\31\2\2\u079f\u07a0\7!\2\2\u07a0\u07a6")
+ buf.write("\5\u00eav\2\u07a1\u07a2\7@\2\2\u07a2\u07a3\7\b\2\2\u07a3")
+ buf.write("\u07a4\5\u00ecw\2\u07a4\u07a5\7!\2\2\u07a5\u07a7\3\2\2")
+ buf.write("\2\u07a6\u07a1\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07ab")
+ buf.write("\3\2\2\2\u07a8\u07aa\5\u008cG\2\u07a9\u07a8\3\2\2\2\u07aa")
+ buf.write("\u07ad\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07ac\3\2\2\2")
+ buf.write("\u07ac\u07af\3\2\2\2\u07ad\u07ab\3\2\2\2\u07ae\u0754\3")
+ buf.write("\2\2\2\u07ae\u075f\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1")
+ buf.write("\7B\2\2\u07b1\u07b2\7 \2\2\u07b2\u00e9\3\2\2\2\u07b3\u07b4")
+ buf.write("\7`\2\2\u07b4\u07b5\7\b\2\2\u07b5\u07b6\7\u00fa\2\2\u07b6")
+ buf.write("\u07b7\7!\2\2\u07b7\u07b8\7a\2\2\u07b8\u07b9\7\b\2\2\u07b9")
+ buf.write("\u07ba\7\u00fa\2\2\u07ba\u07bf\7!\2\2\u07bb\u07bc\7b\2")
+ buf.write("\2\u07bc\u07bd\7\b\2\2\u07bd\u07be\7\u00fa\2\2\u07be\u07c0")
+ buf.write("\7!\2\2\u07bf\u07bb\3\2\2\2\u07bf\u07c0\3\2\2\2\u07c0")
+ buf.write("\u07c5\3\2\2\2\u07c1\u07c2\7c\2\2\u07c2\u07c3\7\b\2\2")
+ buf.write("\u07c3\u07c4\7\u00fa\2\2\u07c4\u07c6\7!\2\2\u07c5\u07c1")
+ buf.write("\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u00eb\3\2\2\2\u07c7")
+ buf.write("\u07cc\5\u00eex\2\u07c8\u07c9\7(\2\2\u07c9\u07cb\5\u00ee")
+ buf.write("x\2\u07ca\u07c8\3\2\2\2\u07cb\u07ce\3\2\2\2\u07cc\u07ca")
+ buf.write("\3\2\2\2\u07cc\u07cd\3\2\2\2\u07cd\u00ed\3\2\2\2\u07ce")
+ buf.write("\u07cc\3\2\2\2\u07cf\u07d0\t\6\2\2\u07d0\u00ef\3\2\2\2")
+ buf.write("\u07d1\u082c\7F\2\2\u07d2\u07d3\5P)\2\u07d3\u07d9\7!\2")
+ buf.write("\2\u07d4\u07d5\7@\2\2\u07d5\u07d6\7\b\2\2\u07d6\u07d7")
+ buf.write("\5\u00f4{\2\u07d7\u07d8\7!\2\2\u07d8\u07da\3\2\2\2\u07d9")
+ buf.write("\u07d4\3\2\2\2\u07d9\u07da\3\2\2\2\u07da\u07db\3\2\2\2")
+ buf.write("\u07db\u07dc\5\u00b4[\2\u07dc\u082d\3\2\2\2\u07dd\u07de")
+ buf.write("\7H\2\2\u07de\u07df\7\u008f\2\2\u07df\u07e0\7\b\2\2\u07e0")
+ buf.write("\u07e1\7\u00fb\2\2\u07e1\u07e2\7\34\2\2\u07e2\u07e3\7")
+ buf.write("\u00fb\2\2\u07e3\u07e4\7!\2\2\u07e4\u07e5\7\62\2\2\u07e5")
+ buf.write("\u07e6\7\b\2\2\u07e6\u07e7\7\u00ec\2\2\u07e7\u07e8\7\30")
+ buf.write("\2\2\u07e8\u07e9\7\u00fa\2\2\u07e9\u07ea\7\31\2\2\u07ea")
+ buf.write("\u07eb\7!\2\2\u07eb\u07ec\7=\2\2\u07ec\u07ed\7\b\2\2\u07ed")
+ buf.write("\u07ee\7\u00ec\2\2\u07ee\u07ef\7\30\2\2\u07ef\u07f0\7")
+ buf.write("\u00fa\2\2\u07f0\u07f1\7\31\2\2\u07f1\u07f2\7!\2\2\u07f2")
+ buf.write("\u07f3\5\u00f2z\2\u07f3\u07f4\7I\2\2\u07f4\u07f5\7\u008f")
+ buf.write("\2\2\u07f5\u07f6\7\b\2\2\u07f6\u07f7\7\u00fb\2\2\u07f7")
+ buf.write("\u07f8\7\34\2\2\u07f8\u07f9\7\u00fb\2\2\u07f9\u07fa\7")
+ buf.write("!\2\2\u07fa\u07fb\7\62\2\2\u07fb\u07fc\7\b\2\2\u07fc\u07fd")
+ buf.write("\7\u00ec\2\2\u07fd\u07fe\7\30\2\2\u07fe\u07ff\7\u00fa")
+ buf.write("\2\2\u07ff\u0800\7\31\2\2\u0800\u0801\7!\2\2\u0801\u0802")
+ buf.write("\7=\2\2\u0802\u0803\7\b\2\2\u0803\u0804\7\u00ec\2\2\u0804")
+ buf.write("\u0805\7\30\2\2\u0805\u0806\7\u00fa\2\2\u0806\u0807\7")
+ buf.write("\31\2\2\u0807\u0808\7!\2\2\u0808\u0809\5\u00f2z\2\u0809")
+ buf.write("\u080a\7J\2\2\u080a\u080b\7\u008f\2\2\u080b\u080c\7\b")
+ buf.write("\2\2\u080c\u080d\7\u00fb\2\2\u080d\u080e\7\34\2\2\u080e")
+ buf.write("\u080f\7\u00fb\2\2\u080f\u0810\7!\2\2\u0810\u0811\7\62")
+ buf.write("\2\2\u0811\u0812\7\b\2\2\u0812\u0813\7\u00ec\2\2\u0813")
+ buf.write("\u0814\7\30\2\2\u0814\u0815\7\u00fa\2\2\u0815\u0816\7")
+ buf.write("\31\2\2\u0816\u0817\7!\2\2\u0817\u0818\7=\2\2\u0818\u0819")
+ buf.write("\7\b\2\2\u0819\u081a\7\u00ec\2\2\u081a\u081b\7\30\2\2")
+ buf.write("\u081b\u081c\7\u00fa\2\2\u081c\u081d\7\31\2\2\u081d\u081e")
+ buf.write("\7!\2\2\u081e\u0824\5\u00f2z\2\u081f\u0820\7@\2\2\u0820")
+ buf.write("\u0821\7\b\2\2\u0821\u0822\5\u00f4{\2\u0822\u0823\7!\2")
+ buf.write("\2\u0823\u0825\3\2\2\2\u0824\u081f\3\2\2\2\u0824\u0825")
+ buf.write("\3\2\2\2\u0825\u0829\3\2\2\2\u0826\u0828\5\u008cG\2\u0827")
+ buf.write("\u0826\3\2\2\2\u0828\u082b\3\2\2\2\u0829\u0827\3\2\2\2")
+ buf.write("\u0829\u082a\3\2\2\2\u082a\u082d\3\2\2\2\u082b\u0829\3")
+ buf.write("\2\2\2\u082c\u07d2\3\2\2\2\u082c\u07dd\3\2\2\2\u082d\u082e")
+ buf.write("\3\2\2\2\u082e\u082f\7G\2\2\u082f\u0830\7 \2\2\u0830\u00f1")
+ buf.write("\3\2\2\2\u0831\u0832\7`\2\2\u0832\u0833\7\b\2\2\u0833")
+ buf.write("\u0834\7\u00fa\2\2\u0834\u0835\7!\2\2\u0835\u0836\7a\2")
+ buf.write("\2\u0836\u0837\7\b\2\2\u0837\u0838\7\u00fa\2\2\u0838\u083d")
+ buf.write("\7!\2\2\u0839\u083a\7b\2\2\u083a\u083b\7\b\2\2\u083b\u083c")
+ buf.write("\7\u00fa\2\2\u083c\u083e\7!\2\2\u083d\u0839\3\2\2\2\u083d")
+ buf.write("\u083e\3\2\2\2\u083e\u0843\3\2\2\2\u083f\u0840\7c\2\2")
+ buf.write("\u0840\u0841\7\b\2\2\u0841\u0842\7\u00fa\2\2\u0842\u0844")
+ buf.write("\7!\2\2\u0843\u083f\3\2\2\2\u0843\u0844\3\2\2\2\u0844")
+ buf.write("\u00f3\3\2\2\2\u0845\u084a\5\u00f6|\2\u0846\u0847\7(\2")
+ buf.write("\2\u0847\u0849\5\u00f6|\2\u0848\u0846\3\2\2\2\u0849\u084c")
+ buf.write("\3\2\2\2\u084a\u0848\3\2\2\2\u084a\u084b\3\2\2\2\u084b")
+ buf.write("\u00f5\3\2\2\2\u084c\u084a\3\2\2\2\u084d\u084e\t\7\2\2")
+ buf.write("\u084e\u00f7\3\2\2\2\u084f\u0854\5\u0104\u0083\2\u0850")
+ buf.write("\u0854\5\u00fc\177\2\u0851\u0854\5\u00fe\u0080\2\u0852")
+ buf.write("\u0854\5\u010e\u0088\2\u0853\u084f\3\2\2\2\u0853\u0850")
+ buf.write("\3\2\2\2\u0853\u0851\3\2\2\2\u0853\u0852\3\2\2\2\u0854")
+ buf.write("\u00f9\3\2\2\2\u0855\u0856\5\u0104\u0083\2\u0856\u0857")
+ buf.write("\5\u010a\u0086\2\u0857\u0858\5\u010c\u0087\2\u0858\u0859")
+ buf.write("\5\u010e\u0088\2\u0859\u00fb\3\2\2\2\u085a\u085b\5\u010a")
+ buf.write("\u0086\2\u085b\u00fd\3\2\2\2\u085c\u085d\5\u010c\u0087")
+ buf.write("\2\u085d\u00ff\3\2\2\2\u085e\u0865\5p9\2\u085f\u0865\5")
+ buf.write("\u0088E\2\u0860\u0865\5\u00f8}\2\u0861\u0865\5\u0118\u008d")
+ buf.write("\2\u0862\u0865\5\u011c\u008f\2\u0863\u0865\5\u0110\u0089")
+ buf.write("\2\u0864\u085e\3\2\2\2\u0864\u085f\3\2\2\2\u0864\u0860")
+ buf.write("\3\2\2\2\u0864\u0861\3\2\2\2\u0864\u0862\3\2\2\2\u0864")
+ buf.write("\u0863\3\2\2\2\u0865\u0101\3\2\2\2\u0866\u086b\5p9\2\u0867")
+ buf.write("\u086b\5\u0088E\2\u0868\u086b\5\u0118\u008d\2\u0869\u086b")
+ buf.write("\5\u0110\u0089\2\u086a\u0866\3\2\2\2\u086a\u0867\3\2\2")
+ buf.write("\2\u086a\u0868\3\2\2\2\u086a\u0869\3\2\2\2\u086b\u0103")
+ buf.write("\3\2\2\2\u086c\u086d\7l\2\2\u086d\u086e\5\u0124\u0093")
+ buf.write("\2\u086e\u0872\7 \2\2\u086f\u0871\5\u0100\u0081\2\u0870")
+ buf.write("\u086f\3\2\2\2\u0871\u0874\3\2\2\2\u0872\u0870\3\2\2\2")
+ buf.write("\u0872\u0873\3\2\2\2\u0873\u0875\3\2\2\2\u0874\u0872\3")
+ buf.write("\2\2\2\u0875\u0876\7s\2\2\u0876\u0877\7 \2\2\u0877\u0105")
+ buf.write("\3\2\2\2\u0878\u0885\7k\2\2\u0879\u087a\7@\2\2\u087a\u087b")
+ buf.write("\7\b\2\2\u087b\u0880\5\u009eP\2\u087c\u087d\7(\2\2\u087d")
+ buf.write("\u087f\5\u009eP\2\u087e\u087c\3\2\2\2\u087f\u0882\3\2")
+ buf.write("\2\2\u0880\u087e\3\2\2\2\u0880\u0881\3\2\2\2\u0881\u0883")
+ buf.write("\3\2\2\2\u0882\u0880\3\2\2\2\u0883\u0884\7!\2\2\u0884")
+ buf.write("\u0886\3\2\2\2\u0885\u0879\3\2\2\2\u0885\u0886\3\2\2\2")
+ buf.write("\u0886\u0887\3\2\2\2\u0887\u0888\5\u0124\u0093\2\u0888")
+ buf.write("\u0889\7 \2\2\u0889\u0107\3\2\2\2\u088a\u0897\7K\2\2\u088b")
+ buf.write("\u088c\7@\2\2\u088c\u088d\7\b\2\2\u088d\u0892\5\u009e")
+ buf.write("P\2\u088e\u088f\7(\2\2\u088f\u0891\5\u009eP\2\u0890\u088e")
+ buf.write("\3\2\2\2\u0891\u0894\3\2\2\2\u0892\u0890\3\2\2\2\u0892")
+ buf.write("\u0893\3\2\2\2\u0893\u0895\3\2\2\2\u0894\u0892\3\2\2\2")
+ buf.write("\u0895\u0896\7!\2\2\u0896\u0898\3\2\2\2\u0897\u088b\3")
+ buf.write("\2\2\2\u0897\u0898\3\2\2\2\u0898\u0899\3\2\2\2\u0899\u089a")
+ buf.write("\5\u0124\u0093\2\u089a\u089b\7 \2\2\u089b\u0109\3\2\2")
+ buf.write("\2\u089c\u08a9\7k\2\2\u089d\u089e\7@\2\2\u089e\u089f\7")
+ buf.write("\b\2\2\u089f\u08a4\5\u009eP\2\u08a0\u08a1\7(\2\2\u08a1")
+ buf.write("\u08a3\5\u009eP\2\u08a2\u08a0\3\2\2\2\u08a3\u08a6\3\2")
+ buf.write("\2\2\u08a4\u08a2\3\2\2\2\u08a4\u08a5\3\2\2\2\u08a5\u08a7")
+ buf.write("\3\2\2\2\u08a6\u08a4\3\2\2\2\u08a7\u08a8\7!\2\2\u08a8")
+ buf.write("\u08aa\3\2\2\2\u08a9\u089d\3\2\2\2\u08a9\u08aa\3\2\2\2")
+ buf.write("\u08aa\u08ab\3\2\2\2\u08ab\u08ac\5\u0124\u0093\2\u08ac")
+ buf.write("\u08b0\7 \2\2\u08ad\u08af\5\u0100\u0081\2\u08ae\u08ad")
+ buf.write("\3\2\2\2\u08af\u08b2\3\2\2\2\u08b0\u08ae\3\2\2\2\u08b0")
+ buf.write("\u08b1\3\2\2\2\u08b1\u08b3\3\2\2\2\u08b2\u08b0\3\2\2\2")
+ buf.write("\u08b3\u08b4\7s\2\2\u08b4\u08b5\7 \2\2\u08b5\u010b\3\2")
+ buf.write("\2\2\u08b6\u08c3\7K\2\2\u08b7\u08b8\7@\2\2\u08b8\u08b9")
+ buf.write("\7\b\2\2\u08b9\u08be\5\u009eP\2\u08ba\u08bb\7(\2\2\u08bb")
+ buf.write("\u08bd\5\u009eP\2\u08bc\u08ba\3\2\2\2\u08bd\u08c0\3\2")
+ buf.write("\2\2\u08be\u08bc\3\2\2\2\u08be\u08bf\3\2\2\2\u08bf\u08c1")
+ buf.write("\3\2\2\2\u08c0\u08be\3\2\2\2\u08c1\u08c2\7!\2\2\u08c2")
+ buf.write("\u08c4\3\2\2\2\u08c3\u08b7\3\2\2\2\u08c3\u08c4\3\2\2\2")
+ buf.write("\u08c4\u08c5\3\2\2\2\u08c5\u08c6\5\u0124\u0093\2\u08c6")
+ buf.write("\u08ca\7 \2\2\u08c7\u08c9\5\u0100\u0081\2\u08c8\u08c7")
+ buf.write("\3\2\2\2\u08c9\u08cc\3\2\2\2\u08ca\u08c8\3\2\2\2\u08ca")
+ buf.write("\u08cb\3\2\2\2\u08cb\u08cd\3\2\2\2\u08cc\u08ca\3\2\2\2")
+ buf.write("\u08cd\u08ce\7s\2\2\u08ce\u08cf\7 \2\2\u08cf\u010d\3\2")
+ buf.write("\2\2\u08d0\u08d1\7p\2\2\u08d1\u08d2\7\62\2\2\u08d2\u08d3")
+ buf.write("\7\b\2\2\u08d3\u08d4\7\u00ec\2\2\u08d4\u08d5\7\30\2\2")
+ buf.write("\u08d5\u08d6\7\u00fa\2\2\u08d6\u08d7\7\31\2\2\u08d7\u08e4")
+ buf.write("\7!\2\2\u08d8\u08d9\7@\2\2\u08d9\u08da\7\b\2\2\u08da\u08df")
+ buf.write("\5\u009eP\2\u08db\u08dc\7(\2\2\u08dc\u08de\5\u009eP\2")
+ buf.write("\u08dd\u08db\3\2\2\2\u08de\u08e1\3\2\2\2\u08df\u08dd\3")
+ buf.write("\2\2\2\u08df\u08e0\3\2\2\2\u08e0\u08e2\3\2\2\2\u08e1\u08df")
+ buf.write("\3\2\2\2\u08e2\u08e3\7!\2\2\u08e3\u08e5\3\2\2\2\u08e4")
+ buf.write("\u08d8\3\2\2\2\u08e4\u08e5\3\2\2\2\u08e5\u08e6\3\2\2\2")
+ buf.write("\u08e6\u08e7\5\u0124\u0093\2\u08e7\u08e8\7s\2\2\u08e8")
+ buf.write("\u08e9\7 \2\2\u08e9\u010f\3\2\2\2\u08ea\u08ee\5\u0112")
+ buf.write("\u008a\2\u08eb\u08ee\5\u0114\u008b\2\u08ec\u08ee\5\u0116")
+ buf.write("\u008c\2\u08ed\u08ea\3\2\2\2\u08ed\u08eb\3\2\2\2\u08ed")
+ buf.write("\u08ec\3\2\2\2\u08ee\u0111\3\2\2\2\u08ef\u08f0\7m\2\2")
+ buf.write("\u08f0\u08f1\7\u0096\2\2\u08f1\u08f2\7\b\2\2\u08f2\u08f3")
+ buf.write("\7\u00fa\2\2\u08f3\u08f4\7!\2\2\u08f4\u08f5\7t\2\2\u08f5")
+ buf.write("\u08f6\7\b\2\2\u08f6\u08f7\7\u00fa\2\2\u08f7\u08f8\7 ")
+ buf.write("\2\2\u08f8\u0113\3\2\2\2\u08f9\u08fa\7N\2\2\u08fa\u08fb")
+ buf.write("\7=\2\2\u08fb\u08fc\7\b\2\2\u08fc\u08fd\7\u00ec\2\2\u08fd")
+ buf.write("\u08fe\7\30\2\2\u08fe\u08ff\7\u00fa\2\2\u08ff\u0900\7")
+ buf.write("\31\2\2\u0900\u0901\7!\2\2\u0901\u0902\7>\2\2\u0902\u0903")
+ buf.write("\7\b\2\2\u0903\u0904\7\u00ec\2\2\u0904\u0905\7\30\2\2")
+ buf.write("\u0905\u0906\7\u00fa\2\2\u0906\u0907\7\31\2\2\u0907\u090e")
+ buf.write("\7!\2\2\u0908\u0909\7>\2\2\u0909\u090a\7\b\2\2\u090a\u090b")
+ buf.write("\7\u00ec\2\2\u090b\u090c\7\30\2\2\u090c\u090d\7\u00fa")
+ buf.write("\2\2\u090d\u090f\7\31\2\2\u090e\u0908\3\2\2\2\u090e\u090f")
+ buf.write("\3\2\2\2\u090f\u0910\3\2\2\2\u0910\u0911\7 \2\2\u0911")
+ buf.write("\u0115\3\2\2\2\u0912\u0913\t\b\2\2\u0913\u0914\7\u0087")
+ buf.write("\2\2\u0914\u0915\7!\2\2\u0915\u0916\7/\2\2\u0916\u0917")
+ buf.write("\7\b\2\2\u0917\u0918\7\u00fa\2\2\u0918\u0919\7!\2\2\u0919")
+ buf.write("\u091a\7\62\2\2\u091a\u091b\7\b\2\2\u091b\u091c\7\u00ec")
+ buf.write("\2\2\u091c\u091d\7\30\2\2\u091d\u091e\7\u00fa\2\2\u091e")
+ buf.write("\u091f\7\31\2\2\u091f\u0920\7!\2\2\u0920\u0921\7=\2\2")
+ buf.write("\u0921\u0922\7\b\2\2\u0922\u0923\7\u00ec\2\2\u0923\u0924")
+ buf.write("\7\30\2\2\u0924\u0925\7\u00fa\2\2\u0925\u0931\7\31\2\2")
+ buf.write("\u0926\u0927\7!\2\2\u0927\u0928\7@\2\2\u0928\u0929\7\b")
+ buf.write("\2\2\u0929\u092e\5\u009eP\2\u092a\u092b\7(\2\2\u092b\u092d")
+ buf.write("\5\u009eP\2\u092c\u092a\3\2\2\2\u092d\u0930\3\2\2\2\u092e")
+ buf.write("\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0932\3\2\2\2")
+ buf.write("\u0930\u092e\3\2\2\2\u0931\u0926\3\2\2\2\u0931\u0932\3")
+ buf.write("\2\2\2\u0932\u0937\3\2\2\2\u0933\u0934\7!\2\2\u0934\u0935")
+ buf.write("\7t\2\2\u0935\u0936\7\b\2\2\u0936\u0938\7\u00fa\2\2\u0937")
+ buf.write("\u0933\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u0939\3\2\2\2")
+ buf.write("\u0939\u093a\7 \2\2\u093a\u0117\3\2\2\2\u093b\u093c\7")
+ buf.write("L\2\2\u093c\u093d\7\u00fa\2\2\u093d\u093e\7 \2\2\u093e")
+ buf.write("\u0119\3\2\2\2\u093f\u0941\7\u0088\2\2\u0940\u0942\7!")
+ buf.write("\2\2\u0941\u0940\3\2\2\2\u0941\u0942\3\2\2\2\u0942\u0943")
+ buf.write("\3\2\2\2\u0943\u0944\7.\2\2\u0944\u0945\7\b\2\2\u0945")
+ buf.write("\u0946\7\u00ec\2\2\u0946\u0947\7\30\2\2\u0947\u0948\7")
+ buf.write("\u00fa\2\2\u0948\u0949\7\31\2\2\u0949\u0954\7!\2\2\u094a")
+ buf.write("\u094b\7\u008d\2\2\u094b\u094c\7\u00fa\2\2\u094c\u094d")
+ buf.write("\7!\2\2\u094d\u094e\7\u0089\2\2\u094e\u094f\t\t\2\2\u094f")
+ buf.write("\u0955\7 \2\2\u0950\u0951\7M\2\2\u0951\u0952\7\b\2\2\u0952")
+ buf.write("\u0953\7\u00fa\2\2\u0953\u0955\7 \2\2\u0954\u094a\3\2")
+ buf.write("\2\2\u0954\u0950\3\2\2\2\u0955\u011b\3\2\2\2\u0956\u0957")
+ buf.write("\7\u00a7\2\2\u0957\u0958\7[\2\2\u0958\u0959\7\b\2\2\u0959")
+ buf.write("\u09a1\5L\'\2\u095a\u095b\7!\2\2\u095b\u095c\7\u00a9\2")
+ buf.write("\2\u095c\u0999\7\b\2\2\u095d\u0961\7S\2\2\u095e\u095f")
+ buf.write("\7\32\2\2\u095f\u0960\7\u00fa\2\2\u0960\u0962\7\33\2\2")
+ buf.write("\u0961\u095e\3\2\2\2\u0961\u0962\3\2\2\2\u0962\u099a\3")
+ buf.write("\2\2\2\u0963\u0967\7T\2\2\u0964\u0965\7\32\2\2\u0965\u0966")
+ buf.write("\7\u00fa\2\2\u0966\u0968\7\33\2\2\u0967\u0964\3\2\2\2")
+ buf.write("\u0967\u0968\3\2\2\2\u0968\u099a\3\2\2\2\u0969\u096d\7")
+ buf.write("U\2\2\u096a\u096b\7\32\2\2\u096b\u096c\7\u00fa\2\2\u096c")
+ buf.write("\u096e\7\33\2\2\u096d\u096a\3\2\2\2\u096d\u096e\3\2\2")
+ buf.write("\2\u096e\u099a\3\2\2\2\u096f\u0973\7V\2\2\u0970\u0971")
+ buf.write("\7\32\2\2\u0971\u0972\7\u00fa\2\2\u0972\u0974\7\33\2\2")
+ buf.write("\u0973\u0970\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u099a\3")
+ buf.write("\2\2\2\u0975\u0979\7R\2\2\u0976\u0977\7\32\2\2\u0977\u0978")
+ buf.write("\7\u00fa\2\2\u0978\u097a\7\33\2\2\u0979\u0976\3\2\2\2")
+ buf.write("\u0979\u097a\3\2\2\2\u097a\u099a\3\2\2\2\u097b\u097f\7")
+ buf.write("W\2\2\u097c\u097d\7\32\2\2\u097d\u097e\7\u00fa\2\2\u097e")
+ buf.write("\u0980\7\33\2\2\u097f\u097c\3\2\2\2\u097f\u0980\3\2\2")
+ buf.write("\2\u0980\u099a\3\2\2\2\u0981\u0985\7X\2\2\u0982\u0983")
+ buf.write("\7\32\2\2\u0983\u0984\7\u00fa\2\2\u0984\u0986\7\33\2\2")
+ buf.write("\u0985\u0982\3\2\2\2\u0985\u0986\3\2\2\2\u0986\u099a\3")
+ buf.write("\2\2\2\u0987\u098b\7Y\2\2\u0988\u0989\7\32\2\2\u0989\u098a")
+ buf.write("\7\u00fa\2\2\u098a\u098c\7\33\2\2\u098b\u0988\3\2\2\2")
+ buf.write("\u098b\u098c\3\2\2\2\u098c\u099a\3\2\2\2\u098d\u0991\7")
+ buf.write("Z\2\2\u098e\u098f\7\32\2\2\u098f\u0990\7\u00fa\2\2\u0990")
+ buf.write("\u0992\7\33\2\2\u0991\u098e\3\2\2\2\u0991\u0992\3\2\2")
+ buf.write("\2\u0992\u099a\3\2\2\2\u0993\u0997\7\u00fb\2\2\u0994\u0995")
+ buf.write("\7\32\2\2\u0995\u0996\7\u00fa\2\2\u0996\u0998\7\33\2\2")
+ buf.write("\u0997\u0994\3\2\2\2\u0997\u0998\3\2\2\2\u0998\u099a\3")
+ buf.write("\2\2\2\u0999\u095d\3\2\2\2\u0999\u0963\3\2\2\2\u0999\u0969")
+ buf.write("\3\2\2\2\u0999\u096f\3\2\2\2\u0999\u0975\3\2\2\2\u0999")
+ buf.write("\u097b\3\2\2\2\u0999\u0981\3\2\2\2\u0999\u0987\3\2\2\2")
+ buf.write("\u0999\u098d\3\2\2\2\u0999\u0993\3\2\2\2\u099a\u099e\3")
+ buf.write("\2\2\2\u099b\u099d\5\u011e\u0090\2\u099c\u099b\3\2\2\2")
+ buf.write("\u099d\u09a0\3\2\2\2\u099e\u099c\3\2\2\2\u099e\u099f\3")
+ buf.write("\2\2\2\u099f\u09a2\3\2\2\2\u09a0\u099e\3\2\2\2\u09a1\u095a")
+ buf.write("\3\2\2\2\u09a1\u09a2\3\2\2\2\u09a2\u09ab\3\2\2\2\u09a3")
+ buf.write("\u09a7\7!\2\2\u09a4\u09a6\5\u011c\u008f\2\u09a5\u09a4")
+ buf.write("\3\2\2\2\u09a6\u09a9\3\2\2\2\u09a7\u09a5\3\2\2\2\u09a7")
+ buf.write("\u09a8\3\2\2\2\u09a8\u09aa\3\2\2\2\u09a9\u09a7\3\2\2\2")
+ buf.write("\u09aa\u09ac\7\u00a8\2\2\u09ab\u09a3\3\2\2\2\u09ab\u09ac")
+ buf.write("\3\2\2\2\u09ac\u09ad\3\2\2\2\u09ad\u09ae\7 \2\2\u09ae")
+ buf.write("\u011d\3\2\2\2\u09af\u09b0\7!\2\2\u09b0\u09b4\7\u00aa")
+ buf.write("\2\2\u09b1\u09b2\7\32\2\2\u09b2\u09b3\7\u00fa\2\2\u09b3")
+ buf.write("\u09b5\7\33\2\2\u09b4\u09b1\3\2\2\2\u09b4\u09b5\3\2\2")
+ buf.write("\2\u09b5\u09ba\3\2\2\2\u09b6\u09b7\7\34\2\2\u09b7\u09b9")
+ buf.write("\5\u015c\u00af\2\u09b8\u09b6\3\2\2\2\u09b9\u09bc\3\2\2")
+ buf.write("\2\u09ba\u09b8\3\2\2\2\u09ba\u09bb\3\2\2\2\u09bb\u09bd")
+ buf.write("\3\2\2\2\u09bc\u09ba\3\2\2\2\u09bd\u09be\7\b\2\2\u09be")
+ buf.write("\u09bf\7\u00fa\2\2\u09bf\u011f\3\2\2\2\u09c0\u09c1\5\u0122")
+ buf.write("\u0092\2\u09c1\u09c2\7 \2\2\u09c2\u0121\3\2\2\2\u09c3")
+ buf.write("\u09c4\7\u00ab\2\2\u09c4\u0123\3\2\2\2\u09c5\u09ca\5\u0128")
+ buf.write("\u0095\2\u09c6\u09c7\7\u00dc\2\2\u09c7\u09c9\5\u0128\u0095")
+ buf.write("\2\u09c8\u09c6\3\2\2\2\u09c9\u09cc\3\2\2\2\u09ca\u09c8")
+ buf.write("\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb\u0125\3\2\2\2\u09cc")
+ buf.write("\u09ca\3\2\2\2\u09cd\u09d2\5\u0128\u0095\2\u09ce\u09cf")
+ buf.write("\7\u00dc\2\2\u09cf\u09d1\5\u0128\u0095\2\u09d0\u09ce\3")
+ buf.write("\2\2\2\u09d1\u09d4\3\2\2\2\u09d2\u09d0\3\2\2\2\u09d2\u09d3")
+ buf.write("\3\2\2\2\u09d3\u0127\3\2\2\2\u09d4\u09d2\3\2\2\2\u09d5")
+ buf.write("\u09da\5\u012a\u0096\2\u09d6\u09d7\7\u00db\2\2\u09d7\u09d9")
+ buf.write("\5\u012a\u0096\2\u09d8\u09d6\3\2\2\2\u09d9\u09dc\3\2\2")
+ buf.write("\2\u09da\u09d8\3\2\2\2\u09da\u09db\3\2\2\2\u09db\u0129")
+ buf.write("\3\2\2\2\u09dc\u09da\3\2\2\2\u09dd\u09e2\5\u012c\u0097")
+ buf.write("\2\u09de\u09df\7(\2\2\u09df\u09e1\5\u012c\u0097\2\u09e0")
+ buf.write("\u09de\3\2\2\2\u09e1\u09e4\3\2\2\2\u09e2\u09e0\3\2\2\2")
+ buf.write("\u09e2\u09e3\3\2\2\2\u09e3\u012b\3\2\2\2\u09e4\u09e2\3")
+ buf.write("\2\2\2\u09e5\u09ea\5\u012e\u0098\2\u09e6\u09e7\7)\2\2")
+ buf.write("\u09e7\u09e9\5\u012e\u0098\2\u09e8\u09e6\3\2\2\2\u09e9")
+ buf.write("\u09ec\3\2\2\2\u09ea\u09e8\3\2\2\2\u09ea\u09eb\3\2\2\2")
+ buf.write("\u09eb\u012d\3\2\2\2\u09ec\u09ea\3\2\2\2\u09ed\u09f1\5")
+ buf.write("\u0132\u009a\2\u09ee\u09f0\5\u0130\u0099\2\u09ef\u09ee")
+ buf.write("\3\2\2\2\u09f0\u09f3\3\2\2\2\u09f1\u09ef\3\2\2\2\u09f1")
+ buf.write("\u09f2\3\2\2\2\u09f2\u012f\3\2\2\2\u09f3\u09f1\3\2\2\2")
+ buf.write("\u09f4\u09f5\7\"\2\2\u09f5\u09f9\5\u0132\u009a\2\u09f6")
+ buf.write("\u09f7\7#\2\2\u09f7\u09f9\5\u0132\u009a\2\u09f8\u09f4")
+ buf.write("\3\2\2\2\u09f8\u09f6\3\2\2\2\u09f9\u0131\3\2\2\2\u09fa")
+ buf.write("\u09fe\5\u0136\u009c\2\u09fb\u09fd\5\u0134\u009b\2\u09fc")
+ buf.write("\u09fb\3\2\2\2\u09fd\u0a00\3\2\2\2\u09fe\u09fc\3\2\2\2")
+ buf.write("\u09fe\u09ff\3\2\2\2\u09ff\u0133\3\2\2\2\u0a00\u09fe\3")
+ buf.write("\2\2\2\u0a01\u0a02\7%\2\2\u0a02\u0a0a\5\u0136\u009c\2")
+ buf.write("\u0a03\u0a04\7$\2\2\u0a04\u0a0a\5\u0136\u009c\2\u0a05")
+ buf.write("\u0a06\7\'\2\2\u0a06\u0a0a\5\u0136\u009c\2\u0a07\u0a08")
+ buf.write("\7&\2\2\u0a08\u0a0a\5\u0136\u009c\2\u0a09\u0a01\3\2\2")
+ buf.write("\2\u0a09\u0a03\3\2\2\2\u0a09\u0a05\3\2\2\2\u0a09\u0a07")
+ buf.write("\3\2\2\2\u0a0a\u0135\3\2\2\2\u0a0b\u0a0f\5\u013a\u009e")
+ buf.write("\2\u0a0c\u0a0e\5\u0138\u009d\2\u0a0d\u0a0c\3\2\2\2\u0a0e")
+ buf.write("\u0a11\3\2\2\2\u0a0f\u0a0d\3\2\2\2\u0a0f\u0a10\3\2\2\2")
+ buf.write("\u0a10\u0137\3\2\2\2\u0a11\u0a0f\3\2\2\2\u0a12\u0a13\7")
+ buf.write("\f\2\2\u0a13\u0a17\5\u013a\u009e\2\u0a14\u0a15\7\r\2\2")
+ buf.write("\u0a15\u0a17\5\u013a\u009e\2\u0a16\u0a12\3\2\2\2\u0a16")
+ buf.write("\u0a14\3\2\2\2\u0a17\u0139\3\2\2\2\u0a18\u0a1c\5\u013e")
+ buf.write("\u00a0\2\u0a19\u0a1b\5\u013c\u009f\2\u0a1a\u0a19\3\2\2")
+ buf.write("\2\u0a1b\u0a1e\3\2\2\2\u0a1c\u0a1a\3\2\2\2\u0a1c\u0a1d")
+ buf.write("\3\2\2\2\u0a1d\u013b\3\2\2\2\u0a1e\u0a1c\3\2\2\2\u0a1f")
+ buf.write("\u0a20\7\16\2\2\u0a20\u0a24\5\u013e\u00a0\2\u0a21\u0a22")
+ buf.write("\7\35\2\2\u0a22\u0a24\5\u013e\u00a0\2\u0a23\u0a1f\3\2")
+ buf.write("\2\2\u0a23\u0a21\3\2\2\2\u0a24\u013d\3\2\2\2\u0a25\u0a29")
+ buf.write("\5\u0142\u00a2\2\u0a26\u0a28\5\u0140\u00a1\2\u0a27\u0a26")
+ buf.write("\3\2\2\2\u0a28\u0a2b\3\2\2\2\u0a29\u0a27\3\2\2\2\u0a29")
+ buf.write("\u0a2a\3\2\2\2\u0a2a\u013f\3\2\2\2\u0a2b\u0a29\3\2\2\2")
+ buf.write("\u0a2c\u0a2d\7\17\2\2\u0a2d\u0a33\5\u0142\u00a2\2\u0a2e")
+ buf.write("\u0a2f\7\37\2\2\u0a2f\u0a33\5\u0142\u00a2\2\u0a30\u0a31")
+ buf.write("\7\20\2\2\u0a31\u0a33\5\u0142\u00a2\2\u0a32\u0a2c\3\2")
+ buf.write("\2\2\u0a32\u0a2e\3\2\2\2\u0a32\u0a30\3\2\2\2\u0a33\u0141")
+ buf.write("\3\2\2\2\u0a34\u0a35\7\30\2\2\u0a35\u0a36\t\n\2\2\u0a36")
+ buf.write("\u0a38\7\31\2\2\u0a37\u0a34\3\2\2\2\u0a38\u0a3b\3\2\2")
+ buf.write("\2\u0a39\u0a37\3\2\2\2\u0a39\u0a3a\3\2\2\2\u0a3a\u0a3c")
+ buf.write("\3\2\2\2\u0a3b\u0a39\3\2\2\2\u0a3c\u0a3d\5\u0144\u00a3")
+ buf.write("\2\u0a3d\u0143\3\2\2\2\u0a3e\u0a4b\5\u0146\u00a4\2\u0a3f")
+ buf.write("\u0a4b\5\u0148\u00a5\2\u0a40\u0a4b\5\u014a\u00a6\2\u0a41")
+ buf.write("\u0a4b\5\u014c\u00a7\2\u0a42\u0a4b\5\u014e\u00a8\2\u0a43")
+ buf.write("\u0a4b\5\u016c\u00b7\2\u0a44\u0a4b\5\u016e\u00b8\2\u0a45")
+ buf.write("\u0a4b\5\u0184\u00c3\2\u0a46\u0a4b\5\u0194\u00cb\2\u0a47")
+ buf.write("\u0a48\7\u00dd\2\2\u0a48\u0a4b\5\u0144\u00a3\2\u0a49\u0a4b")
+ buf.write("\5\u014a\u00a6\2\u0a4a\u0a3e\3\2\2\2\u0a4a\u0a3f\3\2\2")
+ buf.write("\2\u0a4a\u0a40\3\2\2\2\u0a4a\u0a41\3\2\2\2\u0a4a\u0a42")
+ buf.write("\3\2\2\2\u0a4a\u0a43\3\2\2\2\u0a4a\u0a44\3\2\2\2\u0a4a")
+ buf.write("\u0a45\3\2\2\2\u0a4a\u0a46\3\2\2\2\u0a4a\u0a47\3\2\2\2")
+ buf.write("\u0a4a\u0a49\3\2\2\2\u0a4b\u0145\3\2\2\2\u0a4c\u0a4d\7")
+ buf.write("\u00e7\2\2\u0a4d\u0a4e\7\30\2\2\u0a4e\u0a4f\5\u0126\u0094")
+ buf.write("\2\u0a4f\u0a50\7!\2\2\u0a50\u0a51\5\u0126\u0094\2\u0a51")
+ buf.write("\u0a52\7\31\2\2\u0a52\u0147\3\2\2\2\u0a53\u0a54\7\u00e5")
+ buf.write("\2\2\u0a54\u0a55\7\30\2\2\u0a55\u0a56\5\u0126\u0094\2")
+ buf.write("\u0a56\u0a57\7!\2\2\u0a57\u0a58\5\u0126\u0094\2\u0a58")
+ buf.write("\u0a59\7\31\2\2\u0a59\u0149\3\2\2\2\u0a5a\u0a5b\7\u00e6")
+ buf.write("\2\2\u0a5b\u0a5c\7\30\2\2\u0a5c\u0a5d\5\u0126\u0094\2")
+ buf.write("\u0a5d\u0a5e\7!\2\2\u0a5e\u0a5f\5\u0126\u0094\2\u0a5f")
+ buf.write("\u0a60\7!\2\2\u0a60\u0a61\5L\'\2\u0a61\u0a62\7\31\2\2")
+ buf.write("\u0a62\u014b\3\2\2\2\u0a63\u0a64\7\30\2\2\u0a64\u0a65")
+ buf.write("\5\u0126\u0094\2\u0a65\u0a66\7\31\2\2\u0a66\u014d\3\2")
+ buf.write("\2\2\u0a67\u0a73\5\u0150\u00a9\2\u0a68\u0a73\5\u0152\u00aa")
+ buf.write("\2\u0a69\u0a73\5\u0154\u00ab\2\u0a6a\u0a73\5\u0156\u00ac")
+ buf.write("\2\u0a6b\u0a73\5\u0158\u00ad\2\u0a6c\u0a73\5\u015e\u00b0")
+ buf.write("\2\u0a6d\u0a73\5\u0160\u00b1\2\u0a6e\u0a73\5\u0162\u00b2")
+ buf.write("\2\u0a6f\u0a73\5\u0164\u00b3\2\u0a70\u0a73\5\u0166\u00b4")
+ buf.write("\2\u0a71\u0a73\5\u016a\u00b6\2\u0a72\u0a67\3\2\2\2\u0a72")
+ buf.write("\u0a68\3\2\2\2\u0a72\u0a69\3\2\2\2\u0a72\u0a6a\3\2\2\2")
+ buf.write("\u0a72\u0a6b\3\2\2\2\u0a72\u0a6c\3\2\2\2\u0a72\u0a6d\3")
+ buf.write("\2\2\2\u0a72\u0a6e\3\2\2\2\u0a72\u0a6f\3\2\2\2\u0a72\u0a70")
+ buf.write("\3\2\2\2\u0a72\u0a71\3\2\2\2\u0a73\u014f\3\2\2\2\u0a74")
+ buf.write("\u0a75\7\u00c7\2\2\u0a75\u0151\3\2\2\2\u0a76\u0a77\7\u00c8")
+ buf.write("\2\2\u0a77\u0a78\7\u00c9\2\2\u0a78\u0a79\7\30\2\2\u0a79")
+ buf.write("\u0a7a\7\u00fa\2\2\u0a7a\u0a85\7\31\2\2\u0a7b\u0a7c\7")
+ buf.write("\"\2\2\u0a7c\u0a86\7\u00fa\2\2\u0a7d\u0a7e\7$\2\2\u0a7e")
+ buf.write("\u0a86\7\u00fa\2\2\u0a7f\u0a80\7%\2\2\u0a80\u0a86\7\u00fa")
+ buf.write("\2\2\u0a81\u0a82\7&\2\2\u0a82\u0a86\7\u00fa\2\2\u0a83")
+ buf.write("\u0a84\7\'\2\2\u0a84\u0a86\7\u00fa\2\2\u0a85\u0a7b\3\2")
+ buf.write("\2\2\u0a85\u0a7d\3\2\2\2\u0a85\u0a7f\3\2\2\2\u0a85\u0a81")
+ buf.write("\3\2\2\2\u0a85\u0a83\3\2\2\2\u0a86\u0153\3\2\2\2\u0a87")
+ buf.write("\u0a88\7\u00ca\2\2\u0a88\u0a93\5\u015a\u00ae\2\u0a89\u0a8a")
+ buf.write("\7\"\2\2\u0a8a\u0a94\7\u00fa\2\2\u0a8b\u0a8c\7$\2\2\u0a8c")
+ buf.write("\u0a94\7\u00fa\2\2\u0a8d\u0a8e\7%\2\2\u0a8e\u0a94\7\u00fa")
+ buf.write("\2\2\u0a8f\u0a90\7&\2\2\u0a90\u0a94\7\u00fa\2\2\u0a91")
+ buf.write("\u0a92\7\'\2\2\u0a92\u0a94\7\u00fa\2\2\u0a93\u0a89\3\2")
+ buf.write("\2\2\u0a93\u0a8b\3\2\2\2\u0a93\u0a8d\3\2\2\2\u0a93\u0a8f")
+ buf.write("\3\2\2\2\u0a93\u0a91\3\2\2\2\u0a94\u0155\3\2\2\2\u0a95")
+ buf.write("\u0a96\7\u00cb\2\2\u0a96\u0aa1\5\u015a\u00ae\2\u0a97\u0a98")
+ buf.write("\7\"\2\2\u0a98\u0aa2\5\u015a\u00ae\2\u0a99\u0a9a\7$\2")
+ buf.write("\2\u0a9a\u0aa2\5\u015a\u00ae\2\u0a9b\u0a9c\7%\2\2\u0a9c")
+ buf.write("\u0aa2\5\u015a\u00ae\2\u0a9d\u0a9e\7&\2\2\u0a9e\u0aa2")
+ buf.write("\5\u015a\u00ae\2\u0a9f\u0aa0\7\'\2\2\u0aa0\u0aa2\5\u015a")
+ buf.write("\u00ae\2\u0aa1\u0a97\3\2\2\2\u0aa1\u0a99\3\2\2\2\u0aa1")
+ buf.write("\u0a9b\3\2\2\2\u0aa1\u0a9d\3\2\2\2\u0aa1\u0a9f\3\2\2\2")
+ buf.write("\u0aa2\u0157\3\2\2\2\u0aa3\u0aa4\7\u00cc\2\2\u0aa4\u0aa5")
+ buf.write("\5\u015a\u00ae\2\u0aa5\u0aa7\7\"\2\2\u0aa6\u0aa8\7\u00fa")
+ buf.write("\2\2\u0aa7\u0aa6\3\2\2\2\u0aa8\u0aa9\3\2\2\2\u0aa9\u0aa7")
+ buf.write("\3\2\2\2\u0aa9\u0aaa\3\2\2\2\u0aaa\u0159\3\2\2\2\u0aab")
+ buf.write("\u0aac\7\u00fb\2\2\u0aac\u0aad\7\32\2\2\u0aad\u0aae\7")
+ buf.write("\u00fa\2\2\u0aae\u0ab8\7\33\2\2\u0aaf\u0ab4\7\u00fb\2")
+ buf.write("\2\u0ab0\u0ab1\7\34\2\2\u0ab1\u0ab3\5\u015c\u00af\2\u0ab2")
+ buf.write("\u0ab0\3\2\2\2\u0ab3\u0ab6\3\2\2\2\u0ab4\u0ab2\3\2\2\2")
+ buf.write("\u0ab4\u0ab5\3\2\2\2\u0ab5\u0ab8\3\2\2\2\u0ab6\u0ab4\3")
+ buf.write("\2\2\2\u0ab7\u0aab\3\2\2\2\u0ab7\u0aaf\3\2\2\2\u0ab8\u015b")
+ buf.write("\3\2\2\2\u0ab9\u0abd\7\u00fb\2\2\u0aba\u0abb\7\32\2\2")
+ buf.write("\u0abb\u0abc\7\u00fa\2\2\u0abc\u0abe\7\33\2\2\u0abd\u0aba")
+ buf.write("\3\2\2\2\u0abd\u0abe\3\2\2\2\u0abe\u015d\3\2\2\2\u0abf")
+ buf.write("\u0ac0\7\u00cd\2\2\u0ac0\u0ac1\7\30\2\2\u0ac1\u0ac2\t")
+ buf.write("\13\2\2\u0ac2\u0ac3\7\31\2\2\u0ac3\u015f\3\2\2\2\u0ac4")
+ buf.write("\u0ac5\7\u00ce\2\2\u0ac5\u0ac6\7\30\2\2\u0ac6\u0ac7\7")
+ buf.write("\u00fb\2\2\u0ac7\u0ac8\7\31\2\2\u0ac8\u0161\3\2\2\2\u0ac9")
+ buf.write("\u0aca\7\u00cf\2\2\u0aca\u0ad0\7\30\2\2\u0acb\u0acc\7")
+ buf.write("\u00ec\2\2\u0acc\u0acd\7\30\2\2\u0acd\u0ace\7\u00fa\2")
+ buf.write("\2\u0ace\u0ad1\7\31\2\2\u0acf\u0ad1\7\u00fa\2\2\u0ad0")
+ buf.write("\u0acb\3\2\2\2\u0ad0\u0acf\3\2\2\2\u0ad1\u0ad2\3\2\2\2")
+ buf.write("\u0ad2\u0ad3\7\31\2\2\u0ad3\u0163\3\2\2\2\u0ad4\u0ad5")
+ buf.write("\7\u00d0\2\2\u0ad5\u0165\3\2\2\2\u0ad6\u0ad7\7\u00d1\2")
+ buf.write("\2\u0ad7\u0ad8\7\30\2\2\u0ad8\u0ad9\5L\'\2\u0ad9\u0ada")
+ buf.write("\7\31\2\2\u0ada\u0167\3\2\2\2\u0adb\u0adc\t\f\2\2\u0adc")
+ buf.write("\u0169\3\2\2\2\u0add\u0ade\7\u00d2\2\2\u0ade\u0adf\7\30")
+ buf.write("\2\2\u0adf\u0ae4\5X-\2\u0ae0\u0ae1\7(\2\2\u0ae1\u0ae2")
+ buf.write("\7@\2\2\u0ae2\u0ae3\7\b\2\2\u0ae3\u0ae5\5\u0168\u00b5")
+ buf.write("\2\u0ae4\u0ae0\3\2\2\2\u0ae4\u0ae5\3\2\2\2\u0ae5\u0ae6")
+ buf.write("\3\2\2\2\u0ae6\u0ae7\7\31\2\2\u0ae7\u016b\3\2\2\2\u0ae8")
+ buf.write("\u0ae9\t\r\2\2\u0ae9\u016d\3\2\2\2\u0aea\u0af5\5\u0170")
+ buf.write("\u00b9\2\u0aeb\u0af5\5\u0172\u00ba\2\u0aec\u0af5\5\u0174")
+ buf.write("\u00bb\2\u0aed\u0af5\5\u0176\u00bc\2\u0aee\u0af5\5\u0178")
+ buf.write("\u00bd\2\u0aef\u0af5\5\u017a\u00be\2\u0af0\u0af5\5\u017c")
+ buf.write("\u00bf\2\u0af1\u0af5\5\u017e\u00c0\2\u0af2\u0af5\5\u0180")
+ buf.write("\u00c1\2\u0af3\u0af5\5\u0182\u00c2\2\u0af4\u0aea\3\2\2")
+ buf.write("\2\u0af4\u0aeb\3\2\2\2\u0af4\u0aec\3\2\2\2\u0af4\u0aed")
+ buf.write("\3\2\2\2\u0af4\u0aee\3\2\2\2\u0af4\u0aef\3\2\2\2\u0af4")
+ buf.write("\u0af0\3\2\2\2\u0af4\u0af1\3\2\2\2\u0af4\u0af2\3\2\2\2")
+ buf.write("\u0af4\u0af3\3\2\2\2\u0af5\u016f\3\2\2\2\u0af6\u0af7\7")
+ buf.write("\u00da\2\2\u0af7\u0af8\7\30\2\2\u0af8\u0af9\5\u0126\u0094")
+ buf.write("\2\u0af9\u0afa\7\31\2\2\u0afa\u0171\3\2\2\2\u0afb\u0afc")
+ buf.write("\7\u00df\2\2\u0afc\u0afd\7\30\2\2\u0afd\u0afe\5\u0126")
+ buf.write("\u0094\2\u0afe\u0aff\7\31\2\2\u0aff\u0173\3\2\2\2\u0b00")
+ buf.write("\u0b01\7\u00e8\2\2\u0b01\u0b09\7\30\2\2\u0b02\u0b03\7")
+ buf.write("*\2\2\u0b03\u0b04\7\b\2\2\u0b04\u0b05\7\u00ec\2\2\u0b05")
+ buf.write("\u0b06\7\30\2\2\u0b06\u0b07\7\u00fa\2\2\u0b07\u0b08\7")
+ buf.write("\31\2\2\u0b08\u0b0a\7!\2\2\u0b09\u0b02\3\2\2\2\u0b09\u0b0a")
+ buf.write("\3\2\2\2\u0b0a\u0b10\3\2\2\2\u0b0b\u0b0c\7[\2\2\u0b0c")
+ buf.write("\u0b0d\7\b\2\2\u0b0d\u0b0e\5L\'\2\u0b0e\u0b0f\7!\2\2\u0b0f")
+ buf.write("\u0b11\3\2\2\2\u0b10\u0b0b\3\2\2\2\u0b10\u0b11\3\2\2\2")
+ buf.write("\u0b11\u0b12\3\2\2\2\u0b12\u0b13\5\u0126\u0094\2\u0b13")
+ buf.write("\u0b14\7\31\2\2\u0b14\u0175\3\2\2\2\u0b15\u0b16\7\u00e9")
+ buf.write("\2\2\u0b16\u0b17\7\30\2\2\u0b17\u0b18\5\u0126\u0094\2")
+ buf.write("\u0b18\u0b19\7\31\2\2\u0b19\u0177\3\2\2\2\u0b1a\u0b1b")
+ buf.write("\7\u00e0\2\2\u0b1b\u0b1c\7\30\2\2\u0b1c\u0b1d\5\u0126")
+ buf.write("\u0094\2\u0b1d\u0b1e\7\31\2\2\u0b1e\u0179\3\2\2\2\u0b1f")
+ buf.write("\u0b24\7\u00e1\2\2\u0b20\u0b21\7\21\2\2\u0b21\u0b22\7")
+ buf.write("\b\2\2\u0b22\u0b23\7\u00fa\2\2\u0b23\u0b25\7!\2\2\u0b24")
+ buf.write("\u0b20\3\2\2\2\u0b24\u0b25\3\2\2\2\u0b25\u0b26\3\2\2\2")
+ buf.write("\u0b26\u0b27\7\30\2\2\u0b27\u0b28\5\u0126\u0094\2\u0b28")
+ buf.write("\u0b29\7\31\2\2\u0b29\u017b\3\2\2\2\u0b2a\u0b2b\7\u00e2")
+ buf.write("\2\2\u0b2b\u0b2c\7\30\2\2\u0b2c\u0b2d\5\u0126\u0094\2")
+ buf.write("\u0b2d\u0b2e\7\31\2\2\u0b2e\u017d\3\2\2\2\u0b2f\u0b30")
+ buf.write("\7\u00e3\2\2\u0b30\u0b31\7\30\2\2\u0b31\u0b32\5\u0126")
+ buf.write("\u0094\2\u0b32\u0b33\7\31\2\2\u0b33\u017f\3\2\2\2\u0b34")
+ buf.write("\u0b35\7\u00e4\2\2\u0b35\u0b36\7\30\2\2\u0b36\u0b37\5")
+ buf.write("\u0126\u0094\2\u0b37\u0b38\7\31\2\2\u0b38\u0181\3\2\2")
+ buf.write("\2\u0b39\u0b3a\7\u00de\2\2\u0b3a\u0b3b\7\30\2\2\u0b3b")
+ buf.write("\u0b40\5X-\2\u0b3c\u0b3d\7(\2\2\u0b3d\u0b3e\7@\2\2\u0b3e")
+ buf.write("\u0b3f\7\b\2\2\u0b3f\u0b41\5\u0168\u00b5\2\u0b40\u0b3c")
+ buf.write("\3\2\2\2\u0b40\u0b41\3\2\2\2\u0b41\u0b42\3\2\2\2\u0b42")
+ buf.write("\u0b43\7!\2\2\u0b43\u0b44\5\u0126\u0094\2\u0b44\u0b45")
+ buf.write("\7\31\2\2\u0b45\u0183\3\2\2\2\u0b46\u0b4c\5\u0186\u00c4")
+ buf.write("\2\u0b47\u0b4c\5\u0188\u00c5\2\u0b48\u0b4c\5\u018c\u00c7")
+ buf.write("\2\u0b49\u0b4c\5\u018e\u00c8\2\u0b4a\u0b4c\5\u0190\u00c9")
+ buf.write("\2\u0b4b\u0b46\3\2\2\2\u0b4b\u0b47\3\2\2\2\u0b4b\u0b48")
+ buf.write("\3\2\2\2\u0b4b\u0b49\3\2\2\2\u0b4b\u0b4a\3\2\2\2\u0b4c")
+ buf.write("\u0185\3\2\2\2\u0b4d\u0b4e\7\u00c2\2\2\u0b4e\u0b4f\7\30")
+ buf.write("\2\2\u0b4f\u0b50\5\u0126\u0094\2\u0b50\u0b51\7\22\2\2")
+ buf.write("\u0b51\u0b52\5\u0126\u0094\2\u0b52\u0b53\7\36\2\2\u0b53")
+ buf.write("\u0b54\5\u0126\u0094\2\u0b54\u0b55\7\31\2\2\u0b55\u0187")
+ buf.write("\3\2\2\2\u0b56\u0b57\7\u00c3\2\2\u0b57\u0b58\7\30\2\2")
+ buf.write("\u0b58\u0b5d\5\u018a\u00c6\2\u0b59\u0b5a\7(\2\2\u0b5a")
+ buf.write("\u0b5c\5\u018a\u00c6\2\u0b5b\u0b59\3\2\2\2\u0b5c\u0b5f")
+ buf.write("\3\2\2\2\u0b5d\u0b5b\3\2\2\2\u0b5d\u0b5e\3\2\2\2\u0b5e")
+ buf.write("\u0b60\3\2\2\2\u0b5f\u0b5d\3\2\2\2\u0b60\u0b61\7!\2\2")
+ buf.write("\u0b61\u0b62\5\u0126\u0094\2\u0b62\u0b63\7!\2\2\u0b63")
+ buf.write("\u0b64\5\u0126\u0094\2\u0b64\u0b65\7!\2\2\u0b65\u0b66")
+ buf.write("\5\u0126\u0094\2\u0b66\u0b67\7\31\2\2\u0b67\u0189\3\2")
+ buf.write("\2\2\u0b68\u0b69\t\16\2\2\u0b69\u018b\3\2\2\2\u0b6a\u0b6b")
+ buf.write("\7\u00c4\2\2\u0b6b\u0b6c\7\30\2\2\u0b6c\u0b6d\5\u0126")
+ buf.write("\u0094\2\u0b6d\u0b6e\7!\2\2\u0b6e\u0b6f\5\u0126\u0094")
+ buf.write("\2\u0b6f\u0b70\7!\2\2\u0b70\u0b71\5\u0126\u0094\2\u0b71")
+ buf.write("\u0b72\7\31\2\2\u0b72\u018d\3\2\2\2\u0b73\u0b74\7\u00c5")
+ buf.write("\2\2\u0b74\u0b75\7\30\2\2\u0b75\u0b76\5\u0126\u0094\2")
+ buf.write("\u0b76\u0b77\7!\2\2\u0b77\u0b78\5\u0126\u0094\2\u0b78")
+ buf.write("\u0b79\7!\2\2\u0b79\u0b7a\5\u0126\u0094\2\u0b7a\u0b7b")
+ buf.write("\7\31\2\2\u0b7b\u018f\3\2\2\2\u0b7c\u0b7d\7\u00c6\2\2")
+ buf.write("\u0b7d\u0b7e\7\30\2\2\u0b7e\u0b7f\7@\2\2\u0b7f\u0b80\7")
+ buf.write("\b\2\2\u0b80\u0b85\5\u0192\u00ca\2\u0b81\u0b82\7(\2\2")
+ buf.write("\u0b82\u0b84\5\u0192\u00ca\2\u0b83\u0b81\3\2\2\2\u0b84")
+ buf.write("\u0b87\3\2\2\2\u0b85\u0b83\3\2\2\2\u0b85\u0b86\3\2\2\2")
+ buf.write("\u0b86\u0b88\3\2\2\2\u0b87\u0b85\3\2\2\2\u0b88\u0b89\7")
+ buf.write("!\2\2\u0b89\u0b8a\5\u0126\u0094\2\u0b8a\u0b8b\7!\2\2\u0b8b")
+ buf.write("\u0b8c\5\u0126\u0094\2\u0b8c\u0b8d\7!\2\2\u0b8d\u0b8e")
+ buf.write("\5\u0126\u0094\2\u0b8e\u0b8f\7\31\2\2\u0b8f\u0191\3\2")
+ buf.write("\2\2\u0b90\u0b91\t\17\2\2\u0b91\u0193\3\2\2\2\u0b92\u0b93")
+ buf.write("\7\u00ea\2\2\u0b93\u0b94\7\30\2\2\u0b94\u0b95\5\u0126")
+ buf.write("\u0094\2\u0b95\u0b9d\7\36\2\2\u0b96\u0b97\5\u0124\u0093")
+ buf.write("\2\u0b97\u0b98\7!\2\2\u0b98\u0b99\5\u0124\u0093\2\u0b99")
+ buf.write("\u0b9a\7 \2\2\u0b9a\u0b9c\3\2\2\2\u0b9b\u0b96\3\2\2\2")
+ buf.write("\u0b9c\u0b9f\3\2\2\2\u0b9d\u0b9b\3\2\2\2\u0b9d\u0b9e\3")
+ buf.write("\2\2\2\u0b9e\u0ba0\3\2\2\2\u0b9f\u0b9d\3\2\2\2\u0ba0\u0ba1")
+ buf.write("\7\31\2\2\u0ba1\u0195\3\2\2\2\u00f0\u0199\u019b\u01a5")
+ buf.write("\u01a9\u01ac\u01b4\u01b9\u01bd\u01c0\u01c6\u01cb\u01cf")
+ buf.write("\u01d2\u01d8\u01ea\u01ec\u01f4\u01fd\u0206\u020f\u0218")
+ buf.write("\u0221\u022a\u0233\u023c\u0245\u024b\u0253\u025b\u0263")
+ buf.write("\u0281\u0288\u028f\u0298\u029c\u02a0\u02a7\u02b1\u02be")
+ buf.write("\u02cd\u02e2\u02e8\u0304\u030a\u0313\u0326\u0336\u0341")
+ buf.write("\u0372\u0382\u0389\u038f\u03a7\u03b2\u03b5\u03b8\u03df")
+ buf.write("\u03e3\u03f0\u03f7\u0409\u041e\u0433\u0439\u044f\u045c")
+ buf.write("\u0460\u0465\u046b\u046e\u0472\u0476\u047d\u0497\u04a1")
+ buf.write("\u04a9\u04ad\u04b3\u04b7\u04e5\u04e9\u04f0\u04f6\u04fa")
+ buf.write("\u0503\u0508\u0514\u051f\u052c\u053d\u0542\u0547\u0558")
+ buf.write("\u055d\u0562\u056a\u058a\u058f\u0594\u059e\u05a8\u05b4")
+ buf.write("\u05b9\u05be\u05ca\u05cf\u05d4\u05de\u05e4\u05ff\u0605")
+ buf.write("\u060f\u061d\u062a\u062f\u0633\u063e\u0644\u064f\u0658")
+ buf.write("\u0662\u0674\u0679\u067d\u0688\u068e\u0698\u069f\u06a7")
+ buf.write("\u06ae\u06ba\u06c5\u06c8\u06d3\u06d8\u06e2\u06e8\u06fb")
+ buf.write("\u0701\u070b\u0711\u071f\u072a\u072f\u0738\u073f\u074a")
+ buf.write("\u0751\u075b\u07a6\u07ab\u07ae\u07bf\u07c5\u07cc\u07d9")
+ buf.write("\u0824\u0829\u082c\u083d\u0843\u084a\u0853\u0864\u086a")
+ buf.write("\u0872\u0880\u0885\u0892\u0897\u08a4\u08a9\u08b0\u08be")
+ buf.write("\u08c3\u08ca\u08df\u08e4\u08ed\u090e\u092e\u0931\u0937")
+ buf.write("\u0941\u0954\u0961\u0967\u096d\u0973\u0979\u097f\u0985")
+ buf.write("\u098b\u0991\u0997\u0999\u099e\u09a1\u09a7\u09ab\u09b4")
+ buf.write("\u09ba\u09ca\u09d2\u09da\u09e2\u09ea\u09f1\u09f8\u09fe")
+ buf.write("\u0a09\u0a0f\u0a16\u0a1c\u0a23\u0a29\u0a32\u0a39\u0a4a")
+ buf.write("\u0a72\u0a85\u0a93\u0aa1\u0aa9\u0ab4\u0ab7\u0abd\u0ad0")
+ buf.write("\u0ae4\u0af4\u0b09\u0b10\u0b24\u0b40\u0b4b\u0b5d\u0b85")
+ buf.write("\u0b9d")
+ return buf.getvalue()
+
+
+class VfrSyntaxParser ( Parser ):
+
+ grammarFileName = "VfrSyntax.g4"
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ sharedContextCache = PredictionContextCache()
+
+ literalNames = [ "<INVALID>", "'show'", "'push'", "'pop'", "'#pragma'",
+ "'pack'", "'='", "'IMAGE_TOKEN'", "'HORIZONTAL'", "'MULTI_LINE'",
+ "'<<'", "'>>'", "'+'", "'*'", "'%'", "'format'", "'?'",
+ "'#define'", "'#include'", "'formpkgtype'", "'{'",
+ "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
+ "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'",
+ "'>='", "'>'", "'|'", "'&'", "'devicepath'", "'formset'",
+ "'formsetid'", "'endformset'", "'title'", "'formid'",
+ "'oneof'", "'endoneof'", "'prompt'", "'orderedlist'",
+ "'maxcontainers'", "'endlist'", "'endform'", "'form'",
+ "'formmap'", "'maptitle'", "'mapguid'", "'subtitle'",
+ "'endsubtitle'", "'help'", "'text'", "'option'", "'flags'",
+ "'date'", "'enddate'", "'year'", "'month'", "'day'",
+ "'time'", "'endtime'", "'hour'", "'minute'", "'second'",
+ "'grayoutif'", "'label'", "'timeout'", "'inventory'",
+ "'_NON_NV_DATA_MAP'", "'struct'", "'union'", "'BOOLEAN'",
+ "'UINT64'", "'UINT32'", "'UINT16'", "'UINT8'", "'EFI_STRING_ID'",
+ "'EFI_HII_DATE'", "'EFI_HII_TIME'", "'EFI_HII_REF'",
+ "'guid'", "'checkbox'", "'endcheckbox'", "'numeric'",
+ "'endnumeric'", "'minimum'", "'maximum'", "'step'",
+ "'default'", "'password'", "'endpassword'", "'string'",
+ "'endstring'", "'minsize'", "'maxsize'", "'encoding'",
+ "'suppressif'", "'disableif'", "'hidden'", "'goto'",
+ "'formsetguid'", "'inconsistentif'", "'warningif'",
+ "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'",
+ "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'", "'INTERACTIVE'",
+ "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'",
+ "'LATE_CHECK'", "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'",
+ "'class'", "'subclass'", "'classguid'", "'typedef'",
+ "'restore'", "'save'", "'defaults'", "'banner'", "'align'",
+ "'left'", "'right'", "'center'", "'line'", "'name'",
+ "'varid'", "'question'", "'questionid'", "'image'",
+ "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
+ "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
+ "'attribute'", "'varstore'", "'efivarstore'", "'varsize'",
+ "'namevaluevarstore'", "'action'", "'config'", "'endaction'",
+ "'refresh'", "'interval'", "'varstoredevice'", "'guidop'",
+ "'endguidop'", "'datatype'", "'data'", "'modal'", "'NON_DEVICE'",
+ "'DISK_DEVICE'", "'VIDEO_DEVICE'", "'NETWORK_DEVICE'",
+ "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'",
+ "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'",
+ "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'",
+ "'DAY_SUPPRESS'", "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'",
+ "'SECOND_SUPPRESS'", "'STORAGE_NORMAL'", "'STORAGE_TIME'",
+ "'STORAGE_WAKEUP'", "'UNIQUE'", "'NOEMPTY'", "'cond'",
+ "'find'", "'mid'", "'token'", "'span'", "'dup'", "'vareqval'",
+ "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
+ "'questionref'", "'ruleref'", "'stringref'", "'pushthis'",
+ "'security'", "'get'", "'TRUE'", "'FALSE'", "'ONE'",
+ "'ONES'", "'ZERO'", "'UNDEFINED'", "'VERSION'", "'length'",
+ "'AND'", "'OR'", "'NOT'", "'set'", "'~'", "'boolval'",
+ "'stringval'", "'unintval'", "'toupper'", "'tolower'",
+ "'match'", "'match2'", "'catenate'", "'questionrefval'",
+ "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
+ "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'", "'NUMERIC_SIZE_1'",
+ "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
+ "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'",
+ "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'",
+ "'FIRST_NON_MATCH'" ]
+
+ symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "Define", "Include", "FormPkgType", "OpenBrace",
+ "CloseBrace", "OpenParen", "CloseParen", "OpenBracket",
+ "CloseBracket", "Dot", "Negative", "Colon", "Slash",
+ "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
+ "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
+ "DevicePath", "FormSet", "FormSetId", "EndFormSet",
+ "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
+ "OrderedList", "MaxContainers", "EndList", "EndForm",
+ "Form", "FormMap", "MapTitle", "MapGuid", "Subtitle",
+ "EndSubtitle", "Help", "Text", "Option", "FLAGS",
+ "Date", "EndDate", "Year", "Month", "Day", "Time",
+ "EndTime", "Hour", "Minute", "Second", "GrayOutIf",
+ "Label", "Timeout", "Inventory", "NonNvDataMap", "Struct",
+ "Union", "Boolean", "Uint64", "Uint32", "Uint16",
+ "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
+ "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox",
+ "Numeric", "EndNumeric", "Minimum", "Maximum", "Step",
+ "Default", "Password", "EndPassword", "String", "EndString",
+ "MinSize", "MaxSize", "Encoding", "SuppressIf", "DisableIf",
+ "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
+ "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
+ "ManufacturingFlag", "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag",
+ "InteractiveFlag", "NVAccessFlag", "ResetRequiredFlag",
+ "ReconnectRequiredFlag", "LateCheckFlag", "ReadOnlyFlag",
+ "OptionOnlyFlag", "RestStyleFlag", "Class", "Subclass",
+ "ClassGuid", "TypeDef", "Restore", "Save", "Defaults",
+ "Banner", "Align", "Left", "Right", "Center", "Line",
+ "Name", "VarId", "Question", "QuestionId", "Image",
+ "Locked", "Rule", "EndRule", "Value", "Read", "Write",
+ "ResetButton", "EndResetButton", "DefaultStore", "Attribute",
+ "Varstore", "Efivarstore", "VarSize", "NameValueVarStore",
+ "Action", "Config", "EndAction", "Refresh", "Interval",
+ "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType",
+ "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
+ "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
+ "ClassOnBoardDevice", "ClassOtherDevice", "SubclassSetupApplication",
+ "SubclassGeneralApplication", "SubclassFrontPage",
+ "SubclassSingleUse", "YearSupppressFlag", "MonthSuppressFlag",
+ "DaySuppressFlag", "HourSupppressFlag", "MinuteSuppressFlag",
+ "SecondSuppressFlag", "StorageNormalFlag", "StorageTimeFlag",
+ "StorageWakeUpFlag", "UniQueFlag", "NoEmptyFlag",
+ "Cond", "Find", "Mid", "Tok", "Span", "Dup", "VarEqVal",
+ "Var", "IdEqVal", "IdEqId", "IdEqValList", "QuestionRef",
+ "RuleRef", "StringRef", "PushThis", "Security", "Get",
+ "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
+ "Undefined", "Version", "Length", "AND", "OR", "NOT",
+ "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
+ "ToUpper", "ToLower", "Match", "Match2", "Catenate",
+ "QuestionRefVal", "StringRefVal", "Map", "RefreshGuid",
+ "StringToken", "OptionDefault", "OptionDefaultMfg",
+ "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour",
+ "NumericSizeEight", "DisPlayIntDec", "DisPlayUIntDec",
+ "DisPlayUIntHex", "Insensitive", "Sensitive", "LastNonMatch",
+ "FirstNonMatch", "Number", "StringIdentifier", "ComplexDefine",
+ "LineDefinition", "IncludeDefinition", "Whitespace",
+ "Newline", "LineComment", "Extern" ]
+
+ RULE_vfrProgram = 0
+ RULE_pragmaPackShowDef = 1
+ RULE_pragmaPackStackDef = 2
+ RULE_pragmaPackNumber = 3
+ RULE_vfrPragmaPackDefinition = 4
+ RULE_vfrDataStructDefinition = 5
+ RULE_vfrDataUnionDefinition = 6
+ RULE_vfrDataStructFields = 7
+ RULE_dataStructField64 = 8
+ RULE_dataStructField32 = 9
+ RULE_dataStructField16 = 10
+ RULE_dataStructField8 = 11
+ RULE_dataStructFieldBool = 12
+ RULE_dataStructFieldString = 13
+ RULE_dataStructFieldDate = 14
+ RULE_dataStructFieldTime = 15
+ RULE_dataStructFieldRef = 16
+ RULE_dataStructFieldUser = 17
+ RULE_dataStructBitField64 = 18
+ RULE_dataStructBitField32 = 19
+ RULE_dataStructBitField16 = 20
+ RULE_dataStructBitField8 = 21
+ RULE_vfrFormSetDefinition = 22
+ RULE_classguidDefinition = 23
+ RULE_classDefinition = 24
+ RULE_validClassNames = 25
+ RULE_subclassDefinition = 26
+ RULE_vfrFormSetList = 27
+ RULE_vfrFormSet = 28
+ RULE_vfrStatementDefaultStore = 29
+ RULE_vfrStatementVarStoreLinear = 30
+ RULE_vfrStatementVarStoreEfi = 31
+ RULE_vfrVarStoreEfiAttr = 32
+ RULE_vfrStatementVarStoreNameValue = 33
+ RULE_vfrStatementDisableIfFormSet = 34
+ RULE_vfrStatementSuppressIfFormSet = 35
+ RULE_guidSubDefinition = 36
+ RULE_guidDefinition = 37
+ RULE_getStringId = 38
+ RULE_vfrQuestionHeader = 39
+ RULE_vfrQuestionBaseInfo = 40
+ RULE_vfrStatementHeader = 41
+ RULE_questionheaderFlagsField = 42
+ RULE_vfrStorageVarId = 43
+ RULE_vfrConstantValueField = 44
+ RULE_vfrImageTag = 45
+ RULE_vfrLockedTag = 46
+ RULE_vfrStatementStatTag = 47
+ RULE_vfrStatementStatTagList = 48
+ RULE_vfrFormDefinition = 49
+ RULE_vfrForm = 50
+ RULE_vfrFormMapDefinition = 51
+ RULE_vfrStatementImage = 52
+ RULE_vfrStatementLocked = 53
+ RULE_vfrStatementRules = 54
+ RULE_vfrStatementStat = 55
+ RULE_vfrStatementSubTitle = 56
+ RULE_vfrStatementSubTitleComponent = 57
+ RULE_vfrSubtitleFlags = 58
+ RULE_subtitleFlagsField = 59
+ RULE_vfrStatementStaticText = 60
+ RULE_staticTextFlagsField = 61
+ RULE_vfrStatementCrossReference = 62
+ RULE_vfrStatementGoto = 63
+ RULE_vfrGotoFlags = 64
+ RULE_gotoFlagsField = 65
+ RULE_vfrStatementResetButton = 66
+ RULE_vfrStatementQuestions = 67
+ RULE_vfrStatementQuestionTag = 68
+ RULE_vfrStatementInconsistentIf = 69
+ RULE_vfrStatementNoSubmitIf = 70
+ RULE_vfrStatementDisableIfQuest = 71
+ RULE_vfrStatementRefresh = 72
+ RULE_vfrStatementVarstoreDevice = 73
+ RULE_vfrStatementRefreshEvent = 74
+ RULE_vfrStatementWarningIf = 75
+ RULE_vfrStatementQuestionTagList = 76
+ RULE_vfrStatementQuestionOptionTag = 77
+ RULE_flagsField = 78
+ RULE_vfrStatementSuppressIfQuest = 79
+ RULE_vfrStatementGrayOutIfQuest = 80
+ RULE_vfrStatementDefault = 81
+ RULE_vfrStatementValue = 82
+ RULE_vfrStatementOptions = 83
+ RULE_vfrStatementOneOfOption = 84
+ RULE_vfrOneOfOptionFlags = 85
+ RULE_oneofoptionFlagsField = 86
+ RULE_vfrStatementRead = 87
+ RULE_vfrStatementWrite = 88
+ RULE_vfrStatementQuestionOptionList = 89
+ RULE_vfrStatementQuestionOption = 90
+ RULE_vfrStatementBooleanType = 91
+ RULE_vfrStatementCheckBox = 92
+ RULE_vfrCheckBoxFlags = 93
+ RULE_checkboxFlagsField = 94
+ RULE_vfrStatementAction = 95
+ RULE_vfrActionFlags = 96
+ RULE_actionFlagsField = 97
+ RULE_vfrStatementNumericType = 98
+ RULE_vfrStatementNumeric = 99
+ RULE_vfrSetMinMaxStep = 100
+ RULE_vfrNumericFlags = 101
+ RULE_numericFlagsField = 102
+ RULE_vfrStatementOneOf = 103
+ RULE_vfrOneofFlagsField = 104
+ RULE_vfrStatementStringType = 105
+ RULE_vfrStatementString = 106
+ RULE_vfrStringFlagsField = 107
+ RULE_stringFlagsField = 108
+ RULE_vfrStatementPassword = 109
+ RULE_vfrPasswordFlagsField = 110
+ RULE_passwordFlagsField = 111
+ RULE_vfrStatementOrderedList = 112
+ RULE_vfrOrderedListFlags = 113
+ RULE_orderedlistFlagsField = 114
+ RULE_vfrStatementDate = 115
+ RULE_minMaxDateStepDefault = 116
+ RULE_vfrDateFlags = 117
+ RULE_dateFlagsField = 118
+ RULE_vfrStatementTime = 119
+ RULE_minMaxTimeStepDefault = 120
+ RULE_vfrTimeFlags = 121
+ RULE_timeFlagsField = 122
+ RULE_vfrStatementConditional = 123
+ RULE_vfrStatementConditionalNew = 124
+ RULE_vfrStatementSuppressIfStat = 125
+ RULE_vfrStatementGrayOutIfStat = 126
+ RULE_vfrStatementStatList = 127
+ RULE_vfrStatementStatListOld = 128
+ RULE_vfrStatementDisableIfStat = 129
+ RULE_vfrStatementgrayoutIfSuppressIf = 130
+ RULE_vfrStatementsuppressIfGrayOutIf = 131
+ RULE_vfrStatementSuppressIfStatNew = 132
+ RULE_vfrStatementGrayOutIfStatNew = 133
+ RULE_vfrStatementInconsistentIfStat = 134
+ RULE_vfrStatementInvalid = 135
+ RULE_vfrStatementInvalidHidden = 136
+ RULE_vfrStatementInvalidInventory = 137
+ RULE_vfrStatementInvalidSaveRestoreDefaults = 138
+ RULE_vfrStatementLabel = 139
+ RULE_vfrStatementBanner = 140
+ RULE_vfrStatementExtension = 141
+ RULE_vfrExtensionData = 142
+ RULE_vfrStatementModal = 143
+ RULE_vfrModalTag = 144
+ RULE_vfrStatementExpression = 145
+ RULE_vfrStatementExpressionSub = 146
+ RULE_andTerm = 147
+ RULE_bitwiseorTerm = 148
+ RULE_bitwiseandTerm = 149
+ RULE_equalTerm = 150
+ RULE_equalTermSupplementary = 151
+ RULE_compareTerm = 152
+ RULE_compareTermSupplementary = 153
+ RULE_shiftTerm = 154
+ RULE_shiftTermSupplementary = 155
+ RULE_addMinusTerm = 156
+ RULE_addMinusTermSupplementary = 157
+ RULE_multdivmodTerm = 158
+ RULE_multdivmodTermSupplementary = 159
+ RULE_castTerm = 160
+ RULE_atomTerm = 161
+ RULE_vfrExpressionCatenate = 162
+ RULE_vfrExpressionMatch = 163
+ RULE_vfrExpressionMatch2 = 164
+ RULE_vfrExpressionParen = 165
+ RULE_vfrExpressionBuildInFunction = 166
+ RULE_dupExp = 167
+ RULE_vareqvalExp = 168
+ RULE_ideqvalExp = 169
+ RULE_ideqidExp = 170
+ RULE_ideqvallistExp = 171
+ RULE_vfrQuestionDataFieldName = 172
+ RULE_arrayName = 173
+ RULE_questionref1Exp = 174
+ RULE_rulerefExp = 175
+ RULE_stringref1Exp = 176
+ RULE_pushthisExp = 177
+ RULE_securityExp = 178
+ RULE_numericVarStoreType = 179
+ RULE_getExp = 180
+ RULE_vfrExpressionConstant = 181
+ RULE_vfrExpressionUnaryOp = 182
+ RULE_lengthExp = 183
+ RULE_bitwisenotExp = 184
+ RULE_question23refExp = 185
+ RULE_stringref2Exp = 186
+ RULE_toboolExp = 187
+ RULE_tostringExp = 188
+ RULE_unintExp = 189
+ RULE_toupperExp = 190
+ RULE_tolwerExp = 191
+ RULE_setExp = 192
+ RULE_vfrExpressionTernaryOp = 193
+ RULE_conditionalExp = 194
+ RULE_findExp = 195
+ RULE_findFormat = 196
+ RULE_midExp = 197
+ RULE_tokenExp = 198
+ RULE_spanExp = 199
+ RULE_spanFlags = 200
+ RULE_vfrExpressionMap = 201
+
+ ruleNames = [ "vfrProgram", "pragmaPackShowDef", "pragmaPackStackDef",
+ "pragmaPackNumber", "vfrPragmaPackDefinition", "vfrDataStructDefinition",
+ "vfrDataUnionDefinition", "vfrDataStructFields", "dataStructField64",
+ "dataStructField32", "dataStructField16", "dataStructField8",
+ "dataStructFieldBool", "dataStructFieldString", "dataStructFieldDate",
+ "dataStructFieldTime", "dataStructFieldRef", "dataStructFieldUser",
+ "dataStructBitField64", "dataStructBitField32", "dataStructBitField16",
+ "dataStructBitField8", "vfrFormSetDefinition", "classguidDefinition",
+ "classDefinition", "validClassNames", "subclassDefinition",
+ "vfrFormSetList", "vfrFormSet", "vfrStatementDefaultStore",
+ "vfrStatementVarStoreLinear", "vfrStatementVarStoreEfi",
+ "vfrVarStoreEfiAttr", "vfrStatementVarStoreNameValue",
+ "vfrStatementDisableIfFormSet", "vfrStatementSuppressIfFormSet",
+ "guidSubDefinition", "guidDefinition", "getStringId",
+ "vfrQuestionHeader", "vfrQuestionBaseInfo", "vfrStatementHeader",
+ "questionheaderFlagsField", "vfrStorageVarId", "vfrConstantValueField",
+ "vfrImageTag", "vfrLockedTag", "vfrStatementStatTag",
+ "vfrStatementStatTagList", "vfrFormDefinition", "vfrForm",
+ "vfrFormMapDefinition", "vfrStatementImage", "vfrStatementLocked",
+ "vfrStatementRules", "vfrStatementStat", "vfrStatementSubTitle",
+ "vfrStatementSubTitleComponent", "vfrSubtitleFlags",
+ "subtitleFlagsField", "vfrStatementStaticText", "staticTextFlagsField",
+ "vfrStatementCrossReference", "vfrStatementGoto", "vfrGotoFlags",
+ "gotoFlagsField", "vfrStatementResetButton", "vfrStatementQuestions",
+ "vfrStatementQuestionTag", "vfrStatementInconsistentIf",
+ "vfrStatementNoSubmitIf", "vfrStatementDisableIfQuest",
+ "vfrStatementRefresh", "vfrStatementVarstoreDevice",
+ "vfrStatementRefreshEvent", "vfrStatementWarningIf",
+ "vfrStatementQuestionTagList", "vfrStatementQuestionOptionTag",
+ "flagsField", "vfrStatementSuppressIfQuest", "vfrStatementGrayOutIfQuest",
+ "vfrStatementDefault", "vfrStatementValue", "vfrStatementOptions",
+ "vfrStatementOneOfOption", "vfrOneOfOptionFlags", "oneofoptionFlagsField",
+ "vfrStatementRead", "vfrStatementWrite", "vfrStatementQuestionOptionList",
+ "vfrStatementQuestionOption", "vfrStatementBooleanType",
+ "vfrStatementCheckBox", "vfrCheckBoxFlags", "checkboxFlagsField",
+ "vfrStatementAction", "vfrActionFlags", "actionFlagsField",
+ "vfrStatementNumericType", "vfrStatementNumeric", "vfrSetMinMaxStep",
+ "vfrNumericFlags", "numericFlagsField", "vfrStatementOneOf",
+ "vfrOneofFlagsField", "vfrStatementStringType", "vfrStatementString",
+ "vfrStringFlagsField", "stringFlagsField", "vfrStatementPassword",
+ "vfrPasswordFlagsField", "passwordFlagsField", "vfrStatementOrderedList",
+ "vfrOrderedListFlags", "orderedlistFlagsField", "vfrStatementDate",
+ "minMaxDateStepDefault", "vfrDateFlags", "dateFlagsField",
+ "vfrStatementTime", "minMaxTimeStepDefault", "vfrTimeFlags",
+ "timeFlagsField", "vfrStatementConditional", "vfrStatementConditionalNew",
+ "vfrStatementSuppressIfStat", "vfrStatementGrayOutIfStat",
+ "vfrStatementStatList", "vfrStatementStatListOld", "vfrStatementDisableIfStat",
+ "vfrStatementgrayoutIfSuppressIf", "vfrStatementsuppressIfGrayOutIf",
+ "vfrStatementSuppressIfStatNew", "vfrStatementGrayOutIfStatNew",
+ "vfrStatementInconsistentIfStat", "vfrStatementInvalid",
+ "vfrStatementInvalidHidden", "vfrStatementInvalidInventory",
+ "vfrStatementInvalidSaveRestoreDefaults", "vfrStatementLabel",
+ "vfrStatementBanner", "vfrStatementExtension", "vfrExtensionData",
+ "vfrStatementModal", "vfrModalTag", "vfrStatementExpression",
+ "vfrStatementExpressionSub", "andTerm", "bitwiseorTerm",
+ "bitwiseandTerm", "equalTerm", "equalTermSupplementary",
+ "compareTerm", "compareTermSupplementary", "shiftTerm",
+ "shiftTermSupplementary", "addMinusTerm", "addMinusTermSupplementary",
+ "multdivmodTerm", "multdivmodTermSupplementary", "castTerm",
+ "atomTerm", "vfrExpressionCatenate", "vfrExpressionMatch",
+ "vfrExpressionMatch2", "vfrExpressionParen", "vfrExpressionBuildInFunction",
+ "dupExp", "vareqvalExp", "ideqvalExp", "ideqidExp", "ideqvallistExp",
+ "vfrQuestionDataFieldName", "arrayName", "questionref1Exp",
+ "rulerefExp", "stringref1Exp", "pushthisExp", "securityExp",
+ "numericVarStoreType", "getExp", "vfrExpressionConstant",
+ "vfrExpressionUnaryOp", "lengthExp", "bitwisenotExp",
+ "question23refExp", "stringref2Exp", "toboolExp", "tostringExp",
+ "unintExp", "toupperExp", "tolwerExp", "setExp", "vfrExpressionTernaryOp",
+ "conditionalExp", "findExp", "findFormat", "midExp",
+ "tokenExp", "spanExp", "spanFlags", "vfrExpressionMap" ]
+
+ EOF = Token.EOF
+ T__0=1
+ T__1=2
+ T__2=3
+ T__3=4
+ T__4=5
+ T__5=6
+ T__6=7
+ T__7=8
+ T__8=9
+ T__9=10
+ T__10=11
+ T__11=12
+ T__12=13
+ T__13=14
+ T__14=15
+ T__15=16
+ Define=17
+ Include=18
+ FormPkgType=19
+ OpenBrace=20
+ CloseBrace=21
+ OpenParen=22
+ CloseParen=23
+ OpenBracket=24
+ CloseBracket=25
+ Dot=26
+ Negative=27
+ Colon=28
+ Slash=29
+ Semicolon=30
+ Comma=31
+ Equal=32
+ NotEqual=33
+ LessEqual=34
+ Less=35
+ GreaterEqual=36
+ Greater=37
+ BitWiseOr=38
+ BitWiseAnd=39
+ DevicePath=40
+ FormSet=41
+ FormSetId=42
+ EndFormSet=43
+ Title=44
+ FormId=45
+ OneOf=46
+ EndOneOf=47
+ Prompt=48
+ OrderedList=49
+ MaxContainers=50
+ EndList=51
+ EndForm=52
+ Form=53
+ FormMap=54
+ MapTitle=55
+ MapGuid=56
+ Subtitle=57
+ EndSubtitle=58
+ Help=59
+ Text=60
+ Option=61
+ FLAGS=62
+ Date=63
+ EndDate=64
+ Year=65
+ Month=66
+ Day=67
+ Time=68
+ EndTime=69
+ Hour=70
+ Minute=71
+ Second=72
+ GrayOutIf=73
+ Label=74
+ Timeout=75
+ Inventory=76
+ NonNvDataMap=77
+ Struct=78
+ Union=79
+ Boolean=80
+ Uint64=81
+ Uint32=82
+ Uint16=83
+ Uint8=84
+ EFI_STRING_ID=85
+ EFI_HII_DATE=86
+ EFI_HII_TIME=87
+ EFI_HII_REF=88
+ Uuid=89
+ CheckBox=90
+ EndCheckBox=91
+ Numeric=92
+ EndNumeric=93
+ Minimum=94
+ Maximum=95
+ Step=96
+ Default=97
+ Password=98
+ EndPassword=99
+ String=100
+ EndString=101
+ MinSize=102
+ MaxSize=103
+ Encoding=104
+ SuppressIf=105
+ DisableIf=106
+ Hidden=107
+ Goto=108
+ FormSetGuid=109
+ InconsistentIf=110
+ WarningIf=111
+ NoSubmitIf=112
+ EndIf=113
+ Key=114
+ DefaultFlag=115
+ ManufacturingFlag=116
+ CheckBoxDefaultFlag=117
+ CheckBoxDefaultMfgFlag=118
+ InteractiveFlag=119
+ NVAccessFlag=120
+ ResetRequiredFlag=121
+ ReconnectRequiredFlag=122
+ LateCheckFlag=123
+ ReadOnlyFlag=124
+ OptionOnlyFlag=125
+ RestStyleFlag=126
+ Class=127
+ Subclass=128
+ ClassGuid=129
+ TypeDef=130
+ Restore=131
+ Save=132
+ Defaults=133
+ Banner=134
+ Align=135
+ Left=136
+ Right=137
+ Center=138
+ Line=139
+ Name=140
+ VarId=141
+ Question=142
+ QuestionId=143
+ Image=144
+ Locked=145
+ Rule=146
+ EndRule=147
+ Value=148
+ Read=149
+ Write=150
+ ResetButton=151
+ EndResetButton=152
+ DefaultStore=153
+ Attribute=154
+ Varstore=155
+ Efivarstore=156
+ VarSize=157
+ NameValueVarStore=158
+ Action=159
+ Config=160
+ EndAction=161
+ Refresh=162
+ Interval=163
+ VarstoreDevice=164
+ GuidOp=165
+ EndGuidOp=166
+ DataType=167
+ Data=168
+ Modal=169
+ ClassNonDevice=170
+ ClassDiskDevice=171
+ ClassVideoDevice=172
+ ClassNetworkDevice=173
+ ClassInputDevice=174
+ ClassOnBoardDevice=175
+ ClassOtherDevice=176
+ SubclassSetupApplication=177
+ SubclassGeneralApplication=178
+ SubclassFrontPage=179
+ SubclassSingleUse=180
+ YearSupppressFlag=181
+ MonthSuppressFlag=182
+ DaySuppressFlag=183
+ HourSupppressFlag=184
+ MinuteSuppressFlag=185
+ SecondSuppressFlag=186
+ StorageNormalFlag=187
+ StorageTimeFlag=188
+ StorageWakeUpFlag=189
+ UniQueFlag=190
+ NoEmptyFlag=191
+ Cond=192
+ Find=193
+ Mid=194
+ Tok=195
+ Span=196
+ Dup=197
+ VarEqVal=198
+ Var=199
+ IdEqVal=200
+ IdEqId=201
+ IdEqValList=202
+ QuestionRef=203
+ RuleRef=204
+ StringRef=205
+ PushThis=206
+ Security=207
+ Get=208
+ TrueSymbol=209
+ FalseSymbol=210
+ One=211
+ Ones=212
+ Zero=213
+ Undefined=214
+ Version=215
+ Length=216
+ AND=217
+ OR=218
+ NOT=219
+ Set=220
+ BitWiseNot=221
+ BoolVal=222
+ StringVal=223
+ UnIntVal=224
+ ToUpper=225
+ ToLower=226
+ Match=227
+ Match2=228
+ Catenate=229
+ QuestionRefVal=230
+ StringRefVal=231
+ Map=232
+ RefreshGuid=233
+ StringToken=234
+ OptionDefault=235
+ OptionDefaultMfg=236
+ NumericSizeOne=237
+ NumericSizeTwo=238
+ NumericSizeFour=239
+ NumericSizeEight=240
+ DisPlayIntDec=241
+ DisPlayUIntDec=242
+ DisPlayUIntHex=243
+ Insensitive=244
+ Sensitive=245
+ LastNonMatch=246
+ FirstNonMatch=247
+ Number=248
+ StringIdentifier=249
+ ComplexDefine=250
+ LineDefinition=251
+ IncludeDefinition=252
+ Whitespace=253
+ Newline=254
+ LineComment=255
+ Extern=256
+
+ def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+ super().__init__(input, output)
+ self.checkVersion("4.7.2")
+ self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+ self._predicates = None
+
+
+
+
+ class VfrProgramContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def vfrFormSetDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetDefinitionContext,0)
+
+
+ def vfrPragmaPackDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrPragmaPackDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrPragmaPackDefinitionContext,i)
+
+
+ def vfrDataStructDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrDataStructDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructDefinitionContext,i)
+
+
+ def vfrDataUnionDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrDataUnionDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataUnionDefinitionContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrProgram
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrProgram" ):
+ return visitor.visitVfrProgram(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrProgram(self):
+
+ localctx = VfrSyntaxParser.VfrProgramContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 0, self.RULE_vfrProgram)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 409
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.T__3 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & ((1 << (VfrSyntaxParser.Struct - 78)) | (1 << (VfrSyntaxParser.Union - 78)) | (1 << (VfrSyntaxParser.TypeDef - 78)))) != 0):
+ self.state = 407
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
+ if la_ == 1:
+ self.state = 404
+ self.vfrPragmaPackDefinition()
+ pass
+
+ elif la_ == 2:
+ self.state = 405
+ self.vfrDataStructDefinition()
+ pass
+
+ elif la_ == 3:
+ self.state = 406
+ self.vfrDataUnionDefinition()
+ pass
+
+
+ self.state = 411
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 412
+ self.vfrFormSetDefinition()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PragmaPackShowDefContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pragmaPackShowDef
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPragmaPackShowDef" ):
+ return visitor.visitPragmaPackShowDef(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pragmaPackShowDef(self):
+
+ localctx = VfrSyntaxParser.PragmaPackShowDefContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 2, self.RULE_pragmaPackShowDef)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 414
+ self.match(VfrSyntaxParser.T__0)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PragmaPackStackDefContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pragmaPackStackDef
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPragmaPackStackDef" ):
+ return visitor.visitPragmaPackStackDef(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pragmaPackStackDef(self):
+
+ localctx = VfrSyntaxParser.PragmaPackStackDefContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 4, self.RULE_pragmaPackStackDef)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 416
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.T__1 or _la==VfrSyntaxParser.T__2):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ self.state = 419
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
+ if la_ == 1:
+ self.state = 417
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 418
+ self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 423
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 421
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 422
+ self.match(VfrSyntaxParser.Number)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PragmaPackNumberContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pragmaPackNumber
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPragmaPackNumber" ):
+ return visitor.visitPragmaPackNumber(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pragmaPackNumber(self):
+
+ localctx = VfrSyntaxParser.PragmaPackNumberContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 6, self.RULE_pragmaPackNumber)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 426
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Number:
+ self.state = 425
+ self.match(VfrSyntaxParser.Number)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrPragmaPackDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def pragmaPackShowDef(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackShowDefContext,0)
+
+
+ def pragmaPackStackDef(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackStackDefContext,0)
+
+
+ def pragmaPackNumber(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackNumberContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrPragmaPackDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrPragmaPackDefinition" ):
+ return visitor.visitVfrPragmaPackDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrPragmaPackDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrPragmaPackDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 8, self.RULE_vfrPragmaPackDefinition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 428
+ self.match(VfrSyntaxParser.T__3)
+ self.state = 429
+ self.match(VfrSyntaxParser.T__4)
+ self.state = 430
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 434
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
+ if la_ == 1:
+ self.state = 431
+ self.pragmaPackShowDef()
+
+ elif la_ == 2:
+ self.state = 432
+ self.pragmaPackStackDef()
+
+ elif la_ == 3:
+ self.state = 433
+ self.pragmaPackNumber()
+
+
+ self.state = 436
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDataStructDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.N1 = None # Token
+ self.N2 = None # Token
+
+ def Struct(self):
+ return self.getToken(VfrSyntaxParser.Struct, 0)
+
+ def OpenBrace(self):
+ return self.getToken(VfrSyntaxParser.OpenBrace, 0)
+
+ def vfrDataStructFields(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
+
+
+ def CloseBrace(self):
+ return self.getToken(VfrSyntaxParser.CloseBrace, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def TypeDef(self):
+ return self.getToken(VfrSyntaxParser.TypeDef, 0)
+
+ def NonNvDataMap(self):
+ return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDataStructDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDataStructDefinition" ):
+ return visitor.visitVfrDataStructDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDataStructDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrDataStructDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 10, self.RULE_vfrDataStructDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 439
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.TypeDef:
+ self.state = 438
+ self.match(VfrSyntaxParser.TypeDef)
+
+
+ self.state = 441
+ self.match(VfrSyntaxParser.Struct)
+ self.state = 443
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.NonNvDataMap:
+ self.state = 442
+ self.match(VfrSyntaxParser.NonNvDataMap)
+
+
+ self.state = 446
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 445
+ localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 448
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 449
+ self.vfrDataStructFields(False)
+ self.state = 450
+ self.match(VfrSyntaxParser.CloseBrace)
+ self.state = 452
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 451
+ localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 454
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDataUnionDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.N1 = None # Token
+ self.N2 = None # Token
+
+ def Union(self):
+ return self.getToken(VfrSyntaxParser.Union, 0)
+
+ def OpenBrace(self):
+ return self.getToken(VfrSyntaxParser.OpenBrace, 0)
+
+ def vfrDataStructFields(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
+
+
+ def CloseBrace(self):
+ return self.getToken(VfrSyntaxParser.CloseBrace, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def TypeDef(self):
+ return self.getToken(VfrSyntaxParser.TypeDef, 0)
+
+ def NonNvDataMap(self):
+ return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDataUnionDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDataUnionDefinition" ):
+ return visitor.visitVfrDataUnionDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDataUnionDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrDataUnionDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 12, self.RULE_vfrDataUnionDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 457
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.TypeDef:
+ self.state = 456
+ self.match(VfrSyntaxParser.TypeDef)
+
+
+ self.state = 459
+ self.match(VfrSyntaxParser.Union)
+ self.state = 461
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.NonNvDataMap:
+ self.state = 460
+ self.match(VfrSyntaxParser.NonNvDataMap)
+
+
+ self.state = 464
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 463
+ localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 466
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 467
+ self.vfrDataStructFields(True)
+ self.state = 468
+ self.match(VfrSyntaxParser.CloseBrace)
+ self.state = 470
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 469
+ localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 472
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDataStructFieldsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.FieldInUnion = FieldInUnion
+
+ def dataStructField64(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField64Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField64Context,i)
+
+
+ def dataStructField32(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField32Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField32Context,i)
+
+
+ def dataStructField16(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField16Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField16Context,i)
+
+
+ def dataStructField8(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField8Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField8Context,i)
+
+
+ def dataStructFieldBool(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldBoolContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldBoolContext,i)
+
+
+ def dataStructFieldString(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldStringContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldStringContext,i)
+
+
+ def dataStructFieldDate(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldDateContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldDateContext,i)
+
+
+ def dataStructFieldTime(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldTimeContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldTimeContext,i)
+
+
+ def dataStructFieldRef(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldRefContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldRefContext,i)
+
+
+ def dataStructFieldUser(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldUserContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldUserContext,i)
+
+
+ def dataStructBitField64(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField64Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField64Context,i)
+
+
+ def dataStructBitField32(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField32Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField32Context,i)
+
+
+ def dataStructBitField16(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField16Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField16Context,i)
+
+
+ def dataStructBitField8(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField8Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField8Context,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDataStructFields
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDataStructFields" ):
+ return visitor.visitVfrDataStructFields(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDataStructFields(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.VfrDataStructFieldsContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 14, self.RULE_vfrDataStructFields)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 490
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (VfrSyntaxParser.Boolean - 80)) | (1 << (VfrSyntaxParser.Uint64 - 80)) | (1 << (VfrSyntaxParser.Uint32 - 80)) | (1 << (VfrSyntaxParser.Uint16 - 80)) | (1 << (VfrSyntaxParser.Uint8 - 80)) | (1 << (VfrSyntaxParser.EFI_STRING_ID - 80)) | (1 << (VfrSyntaxParser.EFI_HII_DATE - 80)) | (1 << (VfrSyntaxParser.EFI_HII_TIME - 80)) | (1 << (VfrSyntaxParser.EFI_HII_REF - 80)))) != 0) or _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 488
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
+ if la_ == 1:
+ self.state = 474
+ self.dataStructField64(FieldInUnion)
+ pass
+
+ elif la_ == 2:
+ self.state = 475
+ self.dataStructField32(FieldInUnion)
+ pass
+
+ elif la_ == 3:
+ self.state = 476
+ self.dataStructField16(FieldInUnion)
+ pass
+
+ elif la_ == 4:
+ self.state = 477
+ self.dataStructField8(FieldInUnion)
+ pass
+
+ elif la_ == 5:
+ self.state = 478
+ self.dataStructFieldBool(FieldInUnion)
+ pass
+
+ elif la_ == 6:
+ self.state = 479
+ self.dataStructFieldString(FieldInUnion)
+ pass
+
+ elif la_ == 7:
+ self.state = 480
+ self.dataStructFieldDate(FieldInUnion)
+ pass
+
+ elif la_ == 8:
+ self.state = 481
+ self.dataStructFieldTime(FieldInUnion)
+ pass
+
+ elif la_ == 9:
+ self.state = 482
+ self.dataStructFieldRef(FieldInUnion)
+ pass
+
+ elif la_ == 10:
+ self.state = 483
+ self.dataStructFieldUser(FieldInUnion)
+ pass
+
+ elif la_ == 11:
+ self.state = 484
+ self.dataStructBitField64(FieldInUnion)
+ pass
+
+ elif la_ == 12:
+ self.state = 485
+ self.dataStructBitField32(FieldInUnion)
+ pass
+
+ elif la_ == 13:
+ self.state = 486
+ self.dataStructBitField16(FieldInUnion)
+ pass
+
+ elif la_ == 14:
+ self.state = 487
+ self.dataStructBitField8(FieldInUnion)
+ pass
+
+
+ self.state = 492
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField64Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField64
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField64" ):
+ return visitor.visitDataStructField64(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField64(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField64Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 16, self.RULE_dataStructField64)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 493
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 494
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 498
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 495
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 496
+ self.match(VfrSyntaxParser.Number)
+ self.state = 497
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 500
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField32Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField32
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField32" ):
+ return visitor.visitDataStructField32(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField32(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField32Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 18, self.RULE_dataStructField32)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 502
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 503
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 507
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 504
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 505
+ self.match(VfrSyntaxParser.Number)
+ self.state = 506
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 509
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField16Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField16
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField16" ):
+ return visitor.visitDataStructField16(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField16(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField16Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 20, self.RULE_dataStructField16)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 511
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 512
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 516
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 513
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 514
+ self.match(VfrSyntaxParser.Number)
+ self.state = 515
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 518
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField8Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField8
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField8" ):
+ return visitor.visitDataStructField8(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField8(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField8Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 22, self.RULE_dataStructField8)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 520
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 521
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 525
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 522
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 523
+ self.match(VfrSyntaxParser.Number)
+ self.state = 524
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 527
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldBoolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Boolean(self):
+ return self.getToken(VfrSyntaxParser.Boolean, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldBool
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldBool" ):
+ return visitor.visitDataStructFieldBool(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldBool(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldBoolContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 24, self.RULE_dataStructFieldBool)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 529
+ self.match(VfrSyntaxParser.Boolean)
+ self.state = 530
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 534
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 531
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 532
+ self.match(VfrSyntaxParser.Number)
+ self.state = 533
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 536
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldStringContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_STRING_ID(self):
+ return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldString
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldString" ):
+ return visitor.visitDataStructFieldString(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldString(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldStringContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 26, self.RULE_dataStructFieldString)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 538
+ self.match(VfrSyntaxParser.EFI_STRING_ID)
+ self.state = 539
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 543
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 540
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 541
+ self.match(VfrSyntaxParser.Number)
+ self.state = 542
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 545
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldDateContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldDate
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldDate" ):
+ return visitor.visitDataStructFieldDate(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldDate(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldDateContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 28, self.RULE_dataStructFieldDate)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 547
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 548
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 552
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 549
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 550
+ self.match(VfrSyntaxParser.Number)
+ self.state = 551
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 554
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldTimeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldTime
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldTime" ):
+ return visitor.visitDataStructFieldTime(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldTime(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldTimeContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 30, self.RULE_dataStructFieldTime)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 556
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 557
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 561
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 558
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 559
+ self.match(VfrSyntaxParser.Number)
+ self.state = 560
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 563
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldRefContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldRef
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldRef" ):
+ return visitor.visitDataStructFieldRef(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldRef(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldRefContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 32, self.RULE_dataStructFieldRef)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 565
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 566
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 570
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 567
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 568
+ self.match(VfrSyntaxParser.Number)
+ self.state = 569
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 572
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldUserContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.T = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldUser
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldUser" ):
+ return visitor.visitDataStructFieldUser(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldUser(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldUserContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 34, self.RULE_dataStructFieldUser)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 574
+ localctx.T = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 575
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 579
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 576
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 577
+ self.match(VfrSyntaxParser.Number)
+ self.state = 578
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 581
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField64Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField64
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField64" ):
+ return visitor.visitDataStructBitField64(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField64(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField64Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 36, self.RULE_dataStructBitField64)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 583
+ localctx.D = self.match(VfrSyntaxParser.Uint64)
+ self.state = 585
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 584
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 587
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 588
+ self.match(VfrSyntaxParser.Number)
+ self.state = 589
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField32Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField32
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField32" ):
+ return visitor.visitDataStructBitField32(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField32(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField32Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 38, self.RULE_dataStructBitField32)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 591
+ localctx.D = self.match(VfrSyntaxParser.Uint32)
+ self.state = 593
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 592
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 595
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 596
+ self.match(VfrSyntaxParser.Number)
+ self.state = 597
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField16Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField16
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField16" ):
+ return visitor.visitDataStructBitField16(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField16(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField16Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 40, self.RULE_dataStructBitField16)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 599
+ localctx.D = self.match(VfrSyntaxParser.Uint16)
+ self.state = 601
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 600
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 603
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 604
+ self.match(VfrSyntaxParser.Number)
+ self.state = 605
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField8Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField8
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField8" ):
+ return visitor.visitDataStructBitField8(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField8(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField8Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 42, self.RULE_dataStructBitField8)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 607
+ localctx.D = self.match(VfrSyntaxParser.Uint8)
+ self.state = 609
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 608
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 611
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 612
+ self.match(VfrSyntaxParser.Number)
+ self.state = 613
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormSetDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_FORM_SET_OP)
+
+ def FormSet(self):
+ return self.getToken(VfrSyntaxParser.FormSet, 0)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Title(self):
+ return self.getToken(VfrSyntaxParser.Title, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def vfrFormSetList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
+
+
+ def EndFormSet(self):
+ return self.getToken(VfrSyntaxParser.EndFormSet, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def ClassGuid(self):
+ return self.getToken(VfrSyntaxParser.ClassGuid, 0)
+
+ def classguidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ClassguidDefinitionContext,0)
+
+
+ def Class(self):
+ return self.getToken(VfrSyntaxParser.Class, 0)
+
+ def classDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ClassDefinitionContext,0)
+
+
+ def Subclass(self):
+ return self.getToken(VfrSyntaxParser.Subclass, 0)
+
+ def subclassDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SubclassDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormSetDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormSetDefinition" ):
+ return visitor.visitVfrFormSetDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormSetDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrFormSetDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 44, self.RULE_vfrFormSetDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 615
+ self.match(VfrSyntaxParser.FormSet)
+ self.state = 616
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 617
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 618
+ self.guidDefinition()
+ self.state = 619
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 620
+ self.match(VfrSyntaxParser.Title)
+ self.state = 621
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 622
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 623
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 624
+ self.match(VfrSyntaxParser.Number)
+ self.state = 625
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 626
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 627
+ self.match(VfrSyntaxParser.Help)
+ self.state = 628
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 629
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 630
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 631
+ self.match(VfrSyntaxParser.Number)
+ self.state = 632
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 633
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 639
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.ClassGuid:
+ self.state = 634
+ self.match(VfrSyntaxParser.ClassGuid)
+ self.state = 635
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 636
+ self.classguidDefinition(localctx.Node)
+ self.state = 637
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 646
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Class:
+ self.state = 641
+ self.match(VfrSyntaxParser.Class)
+ self.state = 642
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 643
+ self.classDefinition()
+ self.state = 644
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 653
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Subclass:
+ self.state = 648
+ self.match(VfrSyntaxParser.Subclass)
+ self.state = 649
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 650
+ self.subclassDefinition()
+ self.state = 651
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 655
+ self.vfrFormSetList(localctx.Node)
+ self.state = 656
+ self.match(VfrSyntaxParser.EndFormSet)
+ self.state = 657
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ClassguidDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.GuidList = []
+ self.Node = Node
+
+ def guidDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_classguidDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitClassguidDefinition" ):
+ return visitor.visitClassguidDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def classguidDefinition(self, Node):
+
+ localctx = VfrSyntaxParser.ClassguidDefinitionContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 46, self.RULE_classguidDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 659
+ self.guidDefinition()
+ self.state = 662
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
+ if la_ == 1:
+ self.state = 660
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 661
+ self.guidDefinition()
+
+
+ self.state = 666
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
+ if la_ == 1:
+ self.state = 664
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 665
+ self.guidDefinition()
+
+
+ self.state = 670
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 668
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 669
+ self.guidDefinition()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ClassDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_GUID_OP)
+
+ def validClassNames(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ValidClassNamesContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ValidClassNamesContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_classDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitClassDefinition" ):
+ return visitor.visitClassDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def classDefinition(self):
+
+ localctx = VfrSyntaxParser.ClassDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 48, self.RULE_classDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 672
+ self.validClassNames()
+ self.state = 677
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 673
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 674
+ self.validClassNames()
+ self.state = 679
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ValidClassNamesContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ClassName = 0
+
+ def ClassNonDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassNonDevice, 0)
+
+ def ClassDiskDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassDiskDevice, 0)
+
+ def ClassVideoDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassVideoDevice, 0)
+
+ def ClassNetworkDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassNetworkDevice, 0)
+
+ def ClassInputDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassInputDevice, 0)
+
+ def ClassOnBoardDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassOnBoardDevice, 0)
+
+ def ClassOtherDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassOtherDevice, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_validClassNames
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitValidClassNames" ):
+ return visitor.visitValidClassNames(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def validClassNames(self):
+
+ localctx = VfrSyntaxParser.ValidClassNamesContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 50, self.RULE_validClassNames)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 680
+ _la = self._input.LA(1)
+ if not(((((_la - 170)) & ~0x3f) == 0 and ((1 << (_la - 170)) & ((1 << (VfrSyntaxParser.ClassNonDevice - 170)) | (1 << (VfrSyntaxParser.ClassDiskDevice - 170)) | (1 << (VfrSyntaxParser.ClassVideoDevice - 170)) | (1 << (VfrSyntaxParser.ClassNetworkDevice - 170)) | (1 << (VfrSyntaxParser.ClassInputDevice - 170)) | (1 << (VfrSyntaxParser.ClassOnBoardDevice - 170)) | (1 << (VfrSyntaxParser.ClassOtherDevice - 170)))) != 0) or _la==VfrSyntaxParser.Number):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SubclassDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_GUID_OP)
+
+ def SubclassSetupApplication(self):
+ return self.getToken(VfrSyntaxParser.SubclassSetupApplication, 0)
+
+ def SubclassGeneralApplication(self):
+ return self.getToken(VfrSyntaxParser.SubclassGeneralApplication, 0)
+
+ def SubclassFrontPage(self):
+ return self.getToken(VfrSyntaxParser.SubclassFrontPage, 0)
+
+ def SubclassSingleUse(self):
+ return self.getToken(VfrSyntaxParser.SubclassSingleUse, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_subclassDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSubclassDefinition" ):
+ return visitor.visitSubclassDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def subclassDefinition(self):
+
+ localctx = VfrSyntaxParser.SubclassDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 52, self.RULE_subclassDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 682
+ _la = self._input.LA(1)
+ if not(((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (VfrSyntaxParser.SubclassSetupApplication - 177)) | (1 << (VfrSyntaxParser.SubclassGeneralApplication - 177)) | (1 << (VfrSyntaxParser.SubclassFrontPage - 177)) | (1 << (VfrSyntaxParser.SubclassSingleUse - 177)))) != 0) or _la==VfrSyntaxParser.Number):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormSetListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrFormSet(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormSetContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormSetList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormSetList" ):
+ return visitor.visitVfrFormSetList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormSetList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrFormSetListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 54, self.RULE_vfrFormSetList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 687
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Form or _la==VfrSyntaxParser.FormMap or ((((_la - 105)) & ~0x3f) == 0 and ((1 << (_la - 105)) & ((1 << (VfrSyntaxParser.SuppressIf - 105)) | (1 << (VfrSyntaxParser.DisableIf - 105)) | (1 << (VfrSyntaxParser.Image - 105)) | (1 << (VfrSyntaxParser.DefaultStore - 105)) | (1 << (VfrSyntaxParser.Varstore - 105)) | (1 << (VfrSyntaxParser.Efivarstore - 105)) | (1 << (VfrSyntaxParser.NameValueVarStore - 105)) | (1 << (VfrSyntaxParser.GuidOp - 105)))) != 0):
+ self.state = 684
+ self.vfrFormSet()
+ self.state = 689
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormSetContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrFormDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormDefinitionContext,0)
+
+
+ def vfrFormMapDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormMapDefinitionContext,0)
+
+
+ def vfrStatementImage(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
+
+
+ def vfrStatementVarStoreLinear(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreLinearContext,0)
+
+
+ def vfrStatementVarStoreEfi(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreEfiContext,0)
+
+
+ def vfrStatementVarStoreNameValue(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreNameValueContext,0)
+
+
+ def vfrStatementDefaultStore(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultStoreContext,0)
+
+
+ def vfrStatementDisableIfFormSet(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfFormSetContext,0)
+
+
+ def vfrStatementSuppressIfFormSet(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfFormSetContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormSet
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormSet" ):
+ return visitor.visitVfrFormSet(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormSet(self):
+
+ localctx = VfrSyntaxParser.VfrFormSetContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 56, self.RULE_vfrFormSet)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 700
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Form]:
+ self.state = 690
+ self.vfrFormDefinition()
+ pass
+ elif token in [VfrSyntaxParser.FormMap]:
+ self.state = 691
+ self.vfrFormMapDefinition()
+ pass
+ elif token in [VfrSyntaxParser.Image]:
+ self.state = 692
+ self.vfrStatementImage()
+ pass
+ elif token in [VfrSyntaxParser.Varstore]:
+ self.state = 693
+ self.vfrStatementVarStoreLinear()
+ pass
+ elif token in [VfrSyntaxParser.Efivarstore]:
+ self.state = 694
+ self.vfrStatementVarStoreEfi()
+ pass
+ elif token in [VfrSyntaxParser.NameValueVarStore]:
+ self.state = 695
+ self.vfrStatementVarStoreNameValue()
+ pass
+ elif token in [VfrSyntaxParser.DefaultStore]:
+ self.state = 696
+ self.vfrStatementDefaultStore()
+ pass
+ elif token in [VfrSyntaxParser.DisableIf]:
+ self.state = 697
+ self.vfrStatementDisableIfFormSet()
+ pass
+ elif token in [VfrSyntaxParser.SuppressIf]:
+ self.state = 698
+ self.vfrStatementSuppressIfFormSet()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.state = 699
+ self.vfrStatementExtension()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDefaultStoreContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)
+ self.N = None # Token
+ self.S = None # Token
+ self.A = None # Token
+
+ def DefaultStore(self):
+ return self.getToken(VfrSyntaxParser.DefaultStore, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Attribute(self):
+ return self.getToken(VfrSyntaxParser.Attribute, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDefaultStore
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDefaultStore" ):
+ return visitor.visitVfrStatementDefaultStore(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDefaultStore(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDefaultStoreContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 58, self.RULE_vfrStatementDefaultStore)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 702
+ self.match(VfrSyntaxParser.DefaultStore)
+ self.state = 703
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 704
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 705
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 706
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 707
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 708
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 709
+ localctx.S = self.match(VfrSyntaxParser.Number)
+ self.state = 710
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 715
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 711
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 712
+ self.match(VfrSyntaxParser.Attribute)
+ self.state = 713
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 714
+ localctx.A = self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 717
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarStoreLinearContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_VARSTORE_OP)
+ self.TN = None # Token
+ self.ID = None # Token
+ self.SN = None # Token
+
+ def Varstore(self):
+ return self.getToken(VfrSyntaxParser.Varstore, 0)
+
+ def Name(self):
+ return self.getToken(VfrSyntaxParser.Name, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarStoreLinear
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarStoreLinear" ):
+ return visitor.visitVfrStatementVarStoreLinear(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarStoreLinear(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarStoreLinearContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 60, self.RULE_vfrStatementVarStoreLinear)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 719
+ self.match(VfrSyntaxParser.Varstore)
+ self.state = 736
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 720
+ localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 721
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint8]:
+ self.state = 722
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 723
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint16]:
+ self.state = 724
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 725
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint32]:
+ self.state = 726
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 727
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint64]:
+ self.state = 728
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 729
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_DATE]:
+ self.state = 730
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 731
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_TIME]:
+ self.state = 732
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 733
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_REF]:
+ self.state = 734
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 735
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 742
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 738
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 739
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 740
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 741
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 744
+ self.match(VfrSyntaxParser.Name)
+ self.state = 745
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 746
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 747
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 748
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 749
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 750
+ self.guidDefinition()
+ self.state = 751
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarStoreEfiContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)
+ self.TN = None # Token
+ self.ID = None # Token
+ self.SN = None # Token
+ self.VN = None # Token
+ self.N = None # Token
+
+ def Efivarstore(self):
+ return self.getToken(VfrSyntaxParser.Efivarstore, 0)
+
+ def Attribute(self):
+ return self.getToken(VfrSyntaxParser.Attribute, 0)
+
+ def vfrVarStoreEfiAttr(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrVarStoreEfiAttrContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrVarStoreEfiAttrContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def Name(self):
+ return self.getToken(VfrSyntaxParser.Name, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def VarSize(self):
+ return self.getToken(VfrSyntaxParser.VarSize, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarStoreEfi
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarStoreEfi" ):
+ return visitor.visitVfrStatementVarStoreEfi(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarStoreEfi(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarStoreEfiContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 62, self.RULE_vfrStatementVarStoreEfi)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 753
+ self.match(VfrSyntaxParser.Efivarstore)
+ self.state = 770
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 754
+ localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 755
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint8]:
+ self.state = 756
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 757
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint16]:
+ self.state = 758
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 759
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint32]:
+ self.state = 760
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 761
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint64]:
+ self.state = 762
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 763
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_DATE]:
+ self.state = 764
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 765
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_TIME]:
+ self.state = 766
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 767
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_REF]:
+ self.state = 768
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 769
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 776
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 772
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 773
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 774
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 775
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 778
+ self.match(VfrSyntaxParser.Attribute)
+ self.state = 779
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 780
+ self.vfrVarStoreEfiAttr()
+ self.state = 785
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 781
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 782
+ self.vfrVarStoreEfiAttr()
+ self.state = 787
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 788
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 804
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
+ if la_ == 1:
+ self.state = 789
+ self.match(VfrSyntaxParser.Name)
+ self.state = 790
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 791
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 792
+ self.match(VfrSyntaxParser.Comma)
+ pass
+
+ elif la_ == 2:
+ self.state = 793
+ self.match(VfrSyntaxParser.Name)
+ self.state = 794
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 795
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 796
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 797
+ localctx.VN = self.match(VfrSyntaxParser.Number)
+ self.state = 798
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 799
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 800
+ self.match(VfrSyntaxParser.VarSize)
+ self.state = 801
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 802
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 803
+ self.match(VfrSyntaxParser.Comma)
+ pass
+
+
+ self.state = 806
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 807
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 808
+ self.guidDefinition()
+ self.state = 809
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrVarStoreEfiAttrContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Attr = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrVarStoreEfiAttr
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrVarStoreEfiAttr" ):
+ return visitor.visitVfrVarStoreEfiAttr(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrVarStoreEfiAttr(self):
+
+ localctx = VfrSyntaxParser.VfrVarStoreEfiAttrContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 64, self.RULE_vfrVarStoreEfiAttr)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 811
+ self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarStoreNameValueContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)
+ self.SN = None # Token
+ self.ID = None # Token
+
+ def NameValueVarStore(self):
+ return self.getToken(VfrSyntaxParser.NameValueVarStore, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def Name(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Name)
+ else:
+ return self.getToken(VfrSyntaxParser.Name, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarStoreNameValue
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarStoreNameValue" ):
+ return visitor.visitVfrStatementVarStoreNameValue(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarStoreNameValue(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarStoreNameValueContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 66, self.RULE_vfrStatementVarStoreNameValue)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 813
+ self.match(VfrSyntaxParser.NameValueVarStore)
+ self.state = 814
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 815
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 820
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 816
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 817
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 818
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 819
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 829
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while True:
+ self.state = 822
+ self.match(VfrSyntaxParser.Name)
+ self.state = 823
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 824
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 825
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 826
+ self.match(VfrSyntaxParser.Number)
+ self.state = 827
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 828
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 831
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if not (_la==VfrSyntaxParser.Name):
+ break
+
+ self.state = 833
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 834
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 835
+ self.guidDefinition()
+ self.state = 836
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDisableIfFormSetContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_DISABLE_IF_OP)
+
+ def DisableIf(self):
+ return self.getToken(VfrSyntaxParser.DisableIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrFormSetList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDisableIfFormSet
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDisableIfFormSet" ):
+ return visitor.visitVfrStatementDisableIfFormSet(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDisableIfFormSet(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDisableIfFormSetContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 68, self.RULE_vfrStatementDisableIfFormSet)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 838
+ self.match(VfrSyntaxParser.DisableIf)
+ self.state = 839
+ self.vfrStatementExpression()
+ self.state = 840
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 841
+ self.vfrFormSetList(localctx.Node)
+ self.state = 842
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 843
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfFormSetContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrFormSetList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfFormSet
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfFormSet" ):
+ return visitor.visitVfrStatementSuppressIfFormSet(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfFormSet(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfFormSetContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 70, self.RULE_vfrStatementSuppressIfFormSet)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 845
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 846
+ self.vfrStatementExpression()
+ self.state = 847
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 848
+ self.vfrFormSetList(localctx.Node)
+ self.state = 849
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 850
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GuidSubDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Guid=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Guid = None
+ self.Guid = Guid
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_guidSubDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGuidSubDefinition" ):
+ return visitor.visitGuidSubDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def guidSubDefinition(self, Guid):
+
+ localctx = VfrSyntaxParser.GuidSubDefinitionContext(self, self._ctx, self.state, Guid)
+ self.enterRule(localctx, 72, self.RULE_guidSubDefinition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 852
+ self.match(VfrSyntaxParser.Number)
+ self.state = 853
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 854
+ self.match(VfrSyntaxParser.Number)
+ self.state = 855
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 856
+ self.match(VfrSyntaxParser.Number)
+ self.state = 857
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 858
+ self.match(VfrSyntaxParser.Number)
+ self.state = 859
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 860
+ self.match(VfrSyntaxParser.Number)
+ self.state = 861
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 862
+ self.match(VfrSyntaxParser.Number)
+ self.state = 863
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 864
+ self.match(VfrSyntaxParser.Number)
+ self.state = 865
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 866
+ self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GuidDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode()
+ self.Guid = EFI_GUID()
+
+ def OpenBrace(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenBrace)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenBrace, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def CloseBrace(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseBrace)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseBrace, i)
+
+ def guidSubDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidSubDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_guidDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGuidDefinition" ):
+ return visitor.visitGuidDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def guidDefinition(self):
+
+ localctx = VfrSyntaxParser.GuidDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 74, self.RULE_guidDefinition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 868
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 869
+ self.match(VfrSyntaxParser.Number)
+ self.state = 870
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 871
+ self.match(VfrSyntaxParser.Number)
+ self.state = 872
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 873
+ self.match(VfrSyntaxParser.Number)
+ self.state = 874
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 880
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.OpenBrace]:
+ self.state = 875
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 876
+ self.guidSubDefinition(localctx.Guid)
+ self.state = 877
+ self.match(VfrSyntaxParser.CloseBrace)
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 879
+ self.guidSubDefinition(localctx.Guid)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 882
+ self.match(VfrSyntaxParser.CloseBrace)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GetStringIdContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.StringId = ''
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_getStringId
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGetStringId" ):
+ return visitor.visitGetStringId(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def getStringId(self):
+
+ localctx = VfrSyntaxParser.GetStringIdContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 76, self.RULE_getStringId)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 884
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 885
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 886
+ self.match(VfrSyntaxParser.Number)
+ self.state = 887
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrQuestionHeaderContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, OpObj=None, QType=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.OpObj = None
+ self.QType = None
+ self.OpObj = OpObj
+ self.QType = QType
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrQuestionHeader
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionHeader" ):
+ return visitor.visitVfrQuestionHeader(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrQuestionHeader(self, OpObj, QType):
+
+ localctx = VfrSyntaxParser.VfrQuestionHeaderContext(self, self._ctx, self.state, OpObj, QType)
+ self.enterRule(localctx, 78, self.RULE_vfrQuestionHeader)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 889
+ self.vfrQuestionBaseInfo(OpObj, QType)
+ self.state = 890
+ self.vfrStatementHeader(OpObj)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrQuestionBaseInfoContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, OpObj=None, QType=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.OpObj = None
+ self.QType = None
+ self.BaseInfo = EFI_VARSTORE_INFO()
+ self.QId = EFI_QUESTION_ID_INVALID
+ self.CheckFlag = True
+ self.QN = None # Token
+ self.ID = None # Token
+ self.OpObj = OpObj
+ self.QType = QType
+
+ def Name(self):
+ return self.getToken(VfrSyntaxParser.Name, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def vfrStorageVarId(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
+
+
+ def QuestionId(self):
+ return self.getToken(VfrSyntaxParser.QuestionId, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrQuestionBaseInfo
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionBaseInfo" ):
+ return visitor.visitVfrQuestionBaseInfo(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrQuestionBaseInfo(self, OpObj, QType):
+
+ localctx = VfrSyntaxParser.VfrQuestionBaseInfoContext(self, self._ctx, self.state, OpObj, QType)
+ self.enterRule(localctx, 80, self.RULE_vfrQuestionBaseInfo)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 896
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Name:
+ self.state = 892
+ self.match(VfrSyntaxParser.Name)
+ self.state = 893
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 894
+ localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 895
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 903
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 898
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 899
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 900
+ self.vfrStorageVarId(localctx.BaseInfo, localctx.CheckFlag)
+ self.state = 901
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 909
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.QuestionId:
+ self.state = 905
+ self.match(VfrSyntaxParser.QuestionId)
+ self.state = 906
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 907
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 908
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementHeaderContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, OpObj=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.OpObj = None
+ self.OpObj = OpObj
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementHeader
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementHeader" ):
+ return visitor.visitVfrStatementHeader(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementHeader(self, OpObj):
+
+ localctx = VfrSyntaxParser.VfrStatementHeaderContext(self, self._ctx, self.state, OpObj)
+ self.enterRule(localctx, 82, self.RULE_vfrStatementHeader)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 911
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 912
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 913
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 914
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 915
+ self.match(VfrSyntaxParser.Number)
+ self.state = 916
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 917
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 918
+ self.match(VfrSyntaxParser.Help)
+ self.state = 919
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 920
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 921
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 922
+ self.match(VfrSyntaxParser.Number)
+ self.state = 923
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class QuestionheaderFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.QHFlag = 0
+ self.O = None # Token
+ self.N = None # Token
+ self.L = None # Token
+
+ def ReadOnlyFlag(self):
+ return self.getToken(VfrSyntaxParser.ReadOnlyFlag, 0)
+
+ def InteractiveFlag(self):
+ return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
+
+ def ResetRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
+
+ def RestStyleFlag(self):
+ return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
+
+ def ReconnectRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
+
+ def OptionOnlyFlag(self):
+ return self.getToken(VfrSyntaxParser.OptionOnlyFlag, 0)
+
+ def NVAccessFlag(self):
+ return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
+
+ def LateCheckFlag(self):
+ return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_questionheaderFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitQuestionheaderFlagsField" ):
+ return visitor.visitQuestionheaderFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def questionheaderFlagsField(self):
+
+ localctx = VfrSyntaxParser.QuestionheaderFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 84, self.RULE_questionheaderFlagsField)
+ try:
+ self.state = 933
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.ReadOnlyFlag]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 925
+ self.match(VfrSyntaxParser.ReadOnlyFlag)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 926
+ self.match(VfrSyntaxParser.InteractiveFlag)
+ pass
+ elif token in [VfrSyntaxParser.ResetRequiredFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 927
+ self.match(VfrSyntaxParser.ResetRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 928
+ self.match(VfrSyntaxParser.RestStyleFlag)
+ pass
+ elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 929
+ self.match(VfrSyntaxParser.ReconnectRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.OptionOnlyFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 930
+ localctx.O = self.match(VfrSyntaxParser.OptionOnlyFlag)
+ pass
+ elif token in [VfrSyntaxParser.NVAccessFlag]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 931
+ localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
+ pass
+ elif token in [VfrSyntaxParser.LateCheckFlag]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 932
+ localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStorageVarIdContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, BaseInfo=None, CheckFlag=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.BaseInfo = None
+ self.CheckFlag = None
+ self.VarIdStr = ''
+ self.BaseInfo = BaseInfo
+ self.CheckFlag = CheckFlag
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStorageVarId
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.BaseInfo = ctx.BaseInfo
+ self.CheckFlag = ctx.CheckFlag
+ self.VarIdStr = ctx.VarIdStr
+
+
+
+ class VfrStorageVarIdRule1Context(VfrStorageVarIdContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrStorageVarIdContext
+ super().__init__(parser)
+ self.SN1 = None # Token
+ self.I = None # Token
+ self.copyFrom(ctx)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStorageVarIdRule1" ):
+ return visitor.visitVfrStorageVarIdRule1(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class VfrStorageVarIdRule2Context(VfrStorageVarIdContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrStorageVarIdContext
+ super().__init__(parser)
+ self.SN2 = None # Token
+ self.copyFrom(ctx)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+ def arrayName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStorageVarIdRule2" ):
+ return visitor.visitVfrStorageVarIdRule2(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def vfrStorageVarId(self, BaseInfo, CheckFlag):
+
+ localctx = VfrSyntaxParser.VfrStorageVarIdContext(self, self._ctx, self.state, BaseInfo, CheckFlag)
+ self.enterRule(localctx, 86, self.RULE_vfrStorageVarId)
+ self._la = 0 # Token type
+ try:
+ self.state = 947
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
+ if la_ == 1:
+ localctx = VfrSyntaxParser.VfrStorageVarIdRule1Context(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 935
+ localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 936
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 937
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 938
+ self.match(VfrSyntaxParser.CloseBracket)
+ pass
+
+ elif la_ == 2:
+ localctx = VfrSyntaxParser.VfrStorageVarIdRule2Context(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 939
+ localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 944
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Dot:
+ self.state = 940
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 941
+ self.arrayName()
+ self.state = 946
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrConstantValueFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Value = EFI_IFR_TYPE_VALUE()
+ self.ValueList = []
+ self.ListType = False
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Negative(self):
+ return self.getToken(VfrSyntaxParser.Negative, 0)
+
+ def TrueSymbol(self):
+ return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
+
+ def FalseSymbol(self):
+ return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
+
+ def One(self):
+ return self.getToken(VfrSyntaxParser.One, 0)
+
+ def Ones(self):
+ return self.getToken(VfrSyntaxParser.Ones, 0)
+
+ def Zero(self):
+ return self.getToken(VfrSyntaxParser.Zero, 0)
+
+ def Colon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Colon)
+ else:
+ return self.getToken(VfrSyntaxParser.Colon, i)
+
+ def Slash(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Slash)
+ else:
+ return self.getToken(VfrSyntaxParser.Slash, i)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def OpenBrace(self):
+ return self.getToken(VfrSyntaxParser.OpenBrace, 0)
+
+ def CloseBrace(self):
+ return self.getToken(VfrSyntaxParser.CloseBrace, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrConstantValueField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrConstantValueField" ):
+ return visitor.visitVfrConstantValueField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrConstantValueField(self):
+
+ localctx = VfrSyntaxParser.VfrConstantValueFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 88, self.RULE_vfrConstantValueField)
+ self._la = 0 # Token type
+ try:
+ self.state = 993
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 950
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Negative:
+ self.state = 949
+ self.match(VfrSyntaxParser.Negative)
+
+
+ self.state = 952
+ self.match(VfrSyntaxParser.Number)
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 953
+ self.match(VfrSyntaxParser.TrueSymbol)
+ pass
+
+ elif la_ == 3:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 954
+ self.match(VfrSyntaxParser.FalseSymbol)
+ pass
+
+ elif la_ == 4:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 955
+ self.match(VfrSyntaxParser.One)
+ pass
+
+ elif la_ == 5:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 956
+ self.match(VfrSyntaxParser.Ones)
+ pass
+
+ elif la_ == 6:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 957
+ self.match(VfrSyntaxParser.Zero)
+ pass
+
+ elif la_ == 7:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 958
+ self.match(VfrSyntaxParser.Number)
+ self.state = 959
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 960
+ self.match(VfrSyntaxParser.Number)
+ self.state = 961
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 962
+ self.match(VfrSyntaxParser.Number)
+ pass
+
+ elif la_ == 8:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 963
+ self.match(VfrSyntaxParser.Number)
+ self.state = 964
+ self.match(VfrSyntaxParser.Slash)
+ self.state = 965
+ self.match(VfrSyntaxParser.Number)
+ self.state = 966
+ self.match(VfrSyntaxParser.Slash)
+ self.state = 967
+ self.match(VfrSyntaxParser.Number)
+ pass
+
+ elif la_ == 9:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 968
+ self.match(VfrSyntaxParser.Number)
+ self.state = 969
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 970
+ self.match(VfrSyntaxParser.Number)
+ self.state = 971
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 972
+ self.guidDefinition()
+ self.state = 973
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 974
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 975
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 976
+ self.match(VfrSyntaxParser.Number)
+ self.state = 977
+ self.match(VfrSyntaxParser.CloseParen)
+ pass
+
+ elif la_ == 10:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 979
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 980
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 981
+ self.match(VfrSyntaxParser.Number)
+ self.state = 982
+ self.match(VfrSyntaxParser.CloseParen)
+ pass
+
+ elif la_ == 11:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 983
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 984
+ self.match(VfrSyntaxParser.Number)
+ self.state = 989
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Comma:
+ self.state = 985
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 986
+ self.match(VfrSyntaxParser.Number)
+ self.state = 991
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 992
+ self.match(VfrSyntaxParser.CloseBrace)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrImageTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_IMAGE_OP)
+
+ def Image(self):
+ return self.getToken(VfrSyntaxParser.Image, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrImageTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrImageTag" ):
+ return visitor.visitVfrImageTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrImageTag(self):
+
+ localctx = VfrSyntaxParser.VfrImageTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 90, self.RULE_vfrImageTag)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 995
+ self.match(VfrSyntaxParser.Image)
+ self.state = 996
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 997
+ self.match(VfrSyntaxParser.T__6)
+ self.state = 998
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 999
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1000
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrLockedTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_LOCKED_OP)
+
+ def Locked(self):
+ return self.getToken(VfrSyntaxParser.Locked, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrLockedTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrLockedTag" ):
+ return visitor.visitVfrLockedTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrLockedTag(self):
+
+ localctx = VfrSyntaxParser.VfrLockedTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 92, self.RULE_vfrLockedTag)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1002
+ self.match(VfrSyntaxParser.Locked)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrImageTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
+
+
+ def vfrLockedTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatTag" ):
+ return visitor.visitVfrStatementStatTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatTag(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 94, self.RULE_vfrStatementStatTag)
+ try:
+ self.state = 1006
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Image]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1004
+ self.vfrImageTag()
+ pass
+ elif token in [VfrSyntaxParser.Locked]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1005
+ self.vfrLockedTag()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatTagListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrStatementStatTag(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatTagContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatTagList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatTagList" ):
+ return visitor.visitVfrStatementStatTagList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatTagList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementStatTagListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 96, self.RULE_vfrStatementStatTagList)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1008
+ self.vfrStatementStatTag()
+ self.state = 1013
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,59,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 1009
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1010
+ self.vfrStatementStatTag()
+ self.state = 1015
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,59,self._ctx)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_FORM_OP)
+
+ def Form(self):
+ return self.getToken(VfrSyntaxParser.Form, 0)
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Title(self):
+ return self.getToken(VfrSyntaxParser.Title, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndForm(self):
+ return self.getToken(VfrSyntaxParser.EndForm, 0)
+
+ def vfrForm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormDefinition" ):
+ return visitor.visitVfrFormDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrFormDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 98, self.RULE_vfrFormDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1016
+ self.match(VfrSyntaxParser.Form)
+ self.state = 1017
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1018
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1019
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1020
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1021
+ self.match(VfrSyntaxParser.Title)
+ self.state = 1022
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1023
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1024
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1025
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1026
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1027
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1031
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 46)) & ~0x3f) == 0 and ((1 << (_la - 46)) & ((1 << (VfrSyntaxParser.OneOf - 46)) | (1 << (VfrSyntaxParser.OrderedList - 46)) | (1 << (VfrSyntaxParser.Subtitle - 46)) | (1 << (VfrSyntaxParser.Text - 46)) | (1 << (VfrSyntaxParser.Date - 46)) | (1 << (VfrSyntaxParser.Time - 46)) | (1 << (VfrSyntaxParser.GrayOutIf - 46)) | (1 << (VfrSyntaxParser.Label - 46)) | (1 << (VfrSyntaxParser.Inventory - 46)) | (1 << (VfrSyntaxParser.CheckBox - 46)) | (1 << (VfrSyntaxParser.Numeric - 46)) | (1 << (VfrSyntaxParser.Default - 46)) | (1 << (VfrSyntaxParser.Password - 46)) | (1 << (VfrSyntaxParser.String - 46)) | (1 << (VfrSyntaxParser.SuppressIf - 46)) | (1 << (VfrSyntaxParser.DisableIf - 46)) | (1 << (VfrSyntaxParser.Hidden - 46)) | (1 << (VfrSyntaxParser.Goto - 46)))) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (VfrSyntaxParser.InconsistentIf - 110)) | (1 << (VfrSyntaxParser.Restore - 110)) | (1 << (VfrSyntaxParser.Save - 110)) | (1 << (VfrSyntaxParser.Banner - 110)) | (1 << (VfrSyntaxParser.Image - 110)) | (1 << (VfrSyntaxParser.Locked - 110)) | (1 << (VfrSyntaxParser.Rule - 110)) | (1 << (VfrSyntaxParser.ResetButton - 110)) | (1 << (VfrSyntaxParser.Action - 110)) | (1 << (VfrSyntaxParser.GuidOp - 110)) | (1 << (VfrSyntaxParser.Modal - 110)))) != 0) or _la==VfrSyntaxParser.RefreshGuid:
+ self.state = 1028
+ self.vfrForm()
+ self.state = 1033
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1034
+ self.match(VfrSyntaxParser.EndForm)
+ self.state = 1035
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementImage(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
+
+
+ def vfrStatementLocked(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLockedContext,0)
+
+
+ def vfrStatementRules(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRulesContext,0)
+
+
+ def vfrStatementDefault(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
+
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def vfrStatementConditional(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
+
+
+ def vfrStatementLabel(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
+
+
+ def vfrStatementBanner(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBannerContext,0)
+
+
+ def vfrStatementInvalid(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def vfrStatementModal(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementModalContext,0)
+
+
+ def vfrStatementRefreshEvent(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrForm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrForm" ):
+ return visitor.visitVfrForm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrForm(self):
+
+ localctx = VfrSyntaxParser.VfrFormContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 100, self.RULE_vfrForm)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1052
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Image]:
+ self.state = 1037
+ self.vfrStatementImage()
+ pass
+ elif token in [VfrSyntaxParser.Locked]:
+ self.state = 1038
+ self.vfrStatementLocked()
+ pass
+ elif token in [VfrSyntaxParser.Rule]:
+ self.state = 1039
+ self.vfrStatementRules()
+ pass
+ elif token in [VfrSyntaxParser.Default]:
+ self.state = 1040
+ self.vfrStatementDefault()
+ pass
+ elif token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text, VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ self.state = 1041
+ self.vfrStatementStat()
+ pass
+ elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.OrderedList, VfrSyntaxParser.Date, VfrSyntaxParser.Time, VfrSyntaxParser.CheckBox, VfrSyntaxParser.Numeric, VfrSyntaxParser.Password, VfrSyntaxParser.String, VfrSyntaxParser.Action]:
+ self.state = 1042
+ self.vfrStatementQuestions()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf, VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
+ self.state = 1043
+ self.vfrStatementConditional()
+ pass
+ elif token in [VfrSyntaxParser.Label]:
+ self.state = 1044
+ self.vfrStatementLabel()
+ pass
+ elif token in [VfrSyntaxParser.Banner]:
+ self.state = 1045
+ self.vfrStatementBanner()
+ pass
+ elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden, VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.state = 1046
+ self.vfrStatementInvalid()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.state = 1047
+ self.vfrStatementExtension()
+ pass
+ elif token in [VfrSyntaxParser.Modal]:
+ self.state = 1048
+ self.vfrStatementModal()
+ pass
+ elif token in [VfrSyntaxParser.RefreshGuid]:
+ self.state = 1049
+ self.vfrStatementRefreshEvent()
+ self.state = 1050
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormMapDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_FORM_MAP_OP)
+ self.S1 = None # Token
+
+ def FormMap(self):
+ return self.getToken(VfrSyntaxParser.FormMap, 0)
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def EndForm(self):
+ return self.getToken(VfrSyntaxParser.EndForm, 0)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def MapTitle(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.MapTitle)
+ else:
+ return self.getToken(VfrSyntaxParser.MapTitle, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def MapGuid(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.MapGuid)
+ else:
+ return self.getToken(VfrSyntaxParser.MapGuid, i)
+
+ def guidDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
+
+
+ def vfrForm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormMapDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormMapDefinition" ):
+ return visitor.visitVfrFormMapDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormMapDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrFormMapDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 102, self.RULE_vfrFormMapDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1054
+ self.match(VfrSyntaxParser.FormMap)
+ self.state = 1055
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1056
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1057
+ localctx.S1 = self.match(VfrSyntaxParser.Number)
+ self.state = 1058
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1073
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.MapTitle:
+ self.state = 1059
+ self.match(VfrSyntaxParser.MapTitle)
+ self.state = 1060
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1061
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1062
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1063
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1064
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1065
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1066
+ self.match(VfrSyntaxParser.MapGuid)
+ self.state = 1067
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1068
+ self.guidDefinition()
+ self.state = 1069
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1075
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1079
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 46)) & ~0x3f) == 0 and ((1 << (_la - 46)) & ((1 << (VfrSyntaxParser.OneOf - 46)) | (1 << (VfrSyntaxParser.OrderedList - 46)) | (1 << (VfrSyntaxParser.Subtitle - 46)) | (1 << (VfrSyntaxParser.Text - 46)) | (1 << (VfrSyntaxParser.Date - 46)) | (1 << (VfrSyntaxParser.Time - 46)) | (1 << (VfrSyntaxParser.GrayOutIf - 46)) | (1 << (VfrSyntaxParser.Label - 46)) | (1 << (VfrSyntaxParser.Inventory - 46)) | (1 << (VfrSyntaxParser.CheckBox - 46)) | (1 << (VfrSyntaxParser.Numeric - 46)) | (1 << (VfrSyntaxParser.Default - 46)) | (1 << (VfrSyntaxParser.Password - 46)) | (1 << (VfrSyntaxParser.String - 46)) | (1 << (VfrSyntaxParser.SuppressIf - 46)) | (1 << (VfrSyntaxParser.DisableIf - 46)) | (1 << (VfrSyntaxParser.Hidden - 46)) | (1 << (VfrSyntaxParser.Goto - 46)))) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (VfrSyntaxParser.InconsistentIf - 110)) | (1 << (VfrSyntaxParser.Restore - 110)) | (1 << (VfrSyntaxParser.Save - 110)) | (1 << (VfrSyntaxParser.Banner - 110)) | (1 << (VfrSyntaxParser.Image - 110)) | (1 << (VfrSyntaxParser.Locked - 110)) | (1 << (VfrSyntaxParser.Rule - 110)) | (1 << (VfrSyntaxParser.ResetButton - 110)) | (1 << (VfrSyntaxParser.Action - 110)) | (1 << (VfrSyntaxParser.GuidOp - 110)) | (1 << (VfrSyntaxParser.Modal - 110)))) != 0) or _la==VfrSyntaxParser.RefreshGuid:
+ self.state = 1076
+ self.vfrForm()
+ self.state = 1081
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1082
+ self.match(VfrSyntaxParser.EndForm)
+ self.state = 1083
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementImageContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrImageTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementImage
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementImage" ):
+ return visitor.visitVfrStatementImage(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementImage(self):
+
+ localctx = VfrSyntaxParser.VfrStatementImageContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 104, self.RULE_vfrStatementImage)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1085
+ self.vfrImageTag()
+ self.state = 1086
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementLockedContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrLockedTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementLocked
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementLocked" ):
+ return visitor.visitVfrStatementLocked(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementLocked(self):
+
+ localctx = VfrSyntaxParser.VfrStatementLockedContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 106, self.RULE_vfrStatementLocked)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1088
+ self.vfrLockedTag()
+ self.state = 1089
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementRulesContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_RULE_OP)
+
+ def Rule(self):
+ return self.getToken(VfrSyntaxParser.Rule, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndRule(self):
+ return self.getToken(VfrSyntaxParser.EndRule, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRules
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRules" ):
+ return visitor.visitVfrStatementRules(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRules(self):
+
+ localctx = VfrSyntaxParser.VfrStatementRulesContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 108, self.RULE_vfrStatementRules)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1091
+ self.match(VfrSyntaxParser.Rule)
+ self.state = 1092
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1093
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1094
+ self.vfrStatementExpression()
+ self.state = 1095
+ self.match(VfrSyntaxParser.EndRule)
+ self.state = 1096
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementSubTitle(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleContext,0)
+
+
+ def vfrStatementStaticText(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStaticTextContext,0)
+
+
+ def vfrStatementCrossReference(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCrossReferenceContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStat" ):
+ return visitor.visitVfrStatementStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 110, self.RULE_vfrStatementStat)
+ try:
+ self.state = 1101
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Subtitle]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1098
+ self.vfrStatementSubTitle()
+ pass
+ elif token in [VfrSyntaxParser.Text]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1099
+ self.vfrStatementStaticText()
+ pass
+ elif token in [VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1100
+ self.vfrStatementCrossReference()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSubTitleContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_SUBTITLE_OP)
+ self.OpObj = CIfrSubtitle()
+
+ def Subtitle(self):
+ return self.getToken(VfrSyntaxParser.Subtitle, 0)
+
+ def Text(self):
+ return self.getToken(VfrSyntaxParser.Text, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def EndSubtitle(self):
+ return self.getToken(VfrSyntaxParser.EndSubtitle, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def vfrSubtitleFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrSubtitleFlagsContext,0)
+
+
+ def vfrStatementStatTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
+
+
+ def vfrStatementSubTitleComponent(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementSubTitleComponentContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleComponentContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSubTitle
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSubTitle" ):
+ return visitor.visitVfrStatementSubTitle(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSubTitle(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSubTitleContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 112, self.RULE_vfrStatementSubTitle)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1103
+ self.match(VfrSyntaxParser.Subtitle)
+ self.state = 1104
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1105
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1106
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1107
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1108
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1109
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1114
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
+ if la_ == 1:
+ self.state = 1110
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1111
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1112
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1113
+ self.vfrSubtitleFlags()
+
+
+ self.state = 1136
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
+ if la_ == 1:
+ self.state = 1118
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1116
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1117
+ self.vfrStatementStatTagList(localctx.Node)
+
+
+ self.state = 1120
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+
+ elif la_ == 2:
+ self.state = 1123
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
+ if la_ == 1:
+ self.state = 1121
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1122
+ self.vfrStatementStatTagList(localctx.Node)
+
+
+ self.state = 1132
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1125
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1129
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 46)) & ~0x3f) == 0 and ((1 << (_la - 46)) & ((1 << (VfrSyntaxParser.OneOf - 46)) | (1 << (VfrSyntaxParser.OrderedList - 46)) | (1 << (VfrSyntaxParser.Subtitle - 46)) | (1 << (VfrSyntaxParser.Text - 46)) | (1 << (VfrSyntaxParser.Date - 46)) | (1 << (VfrSyntaxParser.Time - 46)) | (1 << (VfrSyntaxParser.CheckBox - 46)) | (1 << (VfrSyntaxParser.Numeric - 46)) | (1 << (VfrSyntaxParser.Password - 46)) | (1 << (VfrSyntaxParser.String - 46)) | (1 << (VfrSyntaxParser.Goto - 46)))) != 0) or _la==VfrSyntaxParser.ResetButton or _la==VfrSyntaxParser.Action:
+ self.state = 1126
+ self.vfrStatementSubTitleComponent()
+ self.state = 1131
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+
+
+ self.state = 1134
+ self.match(VfrSyntaxParser.EndSubtitle)
+ self.state = 1135
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSubTitleComponentContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSubTitleComponent
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSubTitleComponent" ):
+ return visitor.visitVfrStatementSubTitleComponent(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSubTitleComponent(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSubTitleComponentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 114, self.RULE_vfrStatementSubTitleComponent)
+ try:
+ self.state = 1140
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text, VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1138
+ self.vfrStatementStat()
+ pass
+ elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.OrderedList, VfrSyntaxParser.Date, VfrSyntaxParser.Time, VfrSyntaxParser.CheckBox, VfrSyntaxParser.Numeric, VfrSyntaxParser.Password, VfrSyntaxParser.String, VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1139
+ self.vfrStatementQuestions()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrSubtitleFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.SubFlags = 0
+
+ def subtitleFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.SubtitleFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.SubtitleFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrSubtitleFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrSubtitleFlags" ):
+ return visitor.visitVfrSubtitleFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrSubtitleFlags(self):
+
+ localctx = VfrSyntaxParser.VfrSubtitleFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 116, self.RULE_vfrSubtitleFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1142
+ self.subtitleFlagsField()
+ self.state = 1147
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1143
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1144
+ self.subtitleFlagsField()
+ self.state = 1149
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SubtitleFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_subtitleFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSubtitleFlagsField" ):
+ return visitor.visitSubtitleFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def subtitleFlagsField(self):
+
+ localctx = VfrSyntaxParser.SubtitleFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 118, self.RULE_subtitleFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1150
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.T__7 or _la==VfrSyntaxParser.Number):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStaticTextContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_TEXT_OP)
+ self.S1 = None # Token
+ self.S2 = None # Token
+ self.S3 = None # Token
+ self.F = None # Token
+ self.S4 = None # Token
+
+ def Text(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Text)
+ else:
+ return self.getToken(VfrSyntaxParser.Text, i)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def staticTextFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.StaticTextFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.StaticTextFlagsFieldContext,i)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def vfrStatementStatTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStaticText
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStaticText" ):
+ return visitor.visitVfrStatementStaticText(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStaticText(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStaticTextContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 120, self.RULE_vfrStatementStaticText)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1152
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1153
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1154
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1155
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1156
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1157
+ localctx.S1 = self.match(VfrSyntaxParser.Number)
+ self.state = 1158
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1159
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1160
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1161
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1162
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1163
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1164
+ localctx.S2 = self.match(VfrSyntaxParser.Number)
+ self.state = 1165
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1173
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
+ if la_ == 1:
+ self.state = 1166
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1167
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1168
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1169
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1170
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1171
+ localctx.S3 = self.match(VfrSyntaxParser.Number)
+ self.state = 1172
+ self.match(VfrSyntaxParser.CloseParen)
+
+
+ self.state = 1191
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
+ if la_ == 1:
+ self.state = 1175
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1176
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1177
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1178
+ self.staticTextFlagsField()
+ self.state = 1183
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1179
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1180
+ self.staticTextFlagsField()
+ self.state = 1185
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1186
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1187
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1188
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1189
+ localctx.S4 = self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 1195
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1193
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1194
+ self.vfrStatementStatTagList(localctx.Node)
+
+
+ self.state = 1197
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class StaticTextFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_staticTextFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStaticTextFlagsField" ):
+ return visitor.visitStaticTextFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def staticTextFlagsField(self):
+
+ localctx = VfrSyntaxParser.StaticTextFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 122, self.RULE_staticTextFlagsField)
+ try:
+ self.state = 1201
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1199
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1200
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementCrossReferenceContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementGoto(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGotoContext,0)
+
+
+ def vfrStatementResetButton(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementResetButtonContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementCrossReference
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementCrossReference" ):
+ return visitor.visitVfrStatementCrossReference(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementCrossReference(self):
+
+ localctx = VfrSyntaxParser.VfrStatementCrossReferenceContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 124, self.RULE_vfrStatementCrossReference)
+ try:
+ self.state = 1205
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Goto]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1203
+ self.vfrStatementGoto()
+ pass
+ elif token in [VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1204
+ self.vfrStatementResetButton()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGotoContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_REF_OP)
+ self.OpObj = None
+ self.OHObj = None
+ self.QType = EFI_QUESION_TYPE.QUESTION_REF
+ self.QN = None # Token
+
+ def Goto(self):
+ return self.getToken(VfrSyntaxParser.Goto, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def vfrGotoFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrGotoFlagsContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def DevicePath(self):
+ return self.getToken(VfrSyntaxParser.DevicePath, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def FormSetGuid(self):
+ return self.getToken(VfrSyntaxParser.FormSetGuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Question(self):
+ return self.getToken(VfrSyntaxParser.Question, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGoto
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGoto" ):
+ return visitor.visitVfrStatementGoto(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGoto(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGotoContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 126, self.RULE_vfrStatementGoto)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1207
+ self.match(VfrSyntaxParser.Goto)
+ self.state = 1255
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.DevicePath]:
+ self.state = 1208
+ self.match(VfrSyntaxParser.DevicePath)
+ self.state = 1209
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1210
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1211
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1212
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1213
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1214
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1215
+ self.match(VfrSyntaxParser.FormSetGuid)
+ self.state = 1216
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1217
+ self.guidDefinition()
+ self.state = 1218
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1219
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1220
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1221
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1222
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1223
+ self.match(VfrSyntaxParser.Question)
+ self.state = 1224
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1225
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1226
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.FormSetGuid]:
+ self.state = 1228
+ self.match(VfrSyntaxParser.FormSetGuid)
+ self.state = 1229
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1230
+ self.guidDefinition()
+ self.state = 1231
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1232
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1233
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1234
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1235
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1236
+ self.match(VfrSyntaxParser.Question)
+ self.state = 1237
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1238
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1239
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.FormId]:
+ self.state = 1241
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1242
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1243
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1244
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1245
+ self.match(VfrSyntaxParser.Question)
+ self.state = 1246
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1251
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 1247
+ localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1248
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 1249
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1250
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 1253
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1254
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Prompt, VfrSyntaxParser.Name, VfrSyntaxParser.VarId, VfrSyntaxParser.QuestionId]:
+ pass
+ else:
+ pass
+ self.state = 1257
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 1262
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
+ if la_ == 1:
+ self.state = 1258
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1259
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1260
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1261
+ self.vfrGotoFlags(localctx.OpObj)
+
+
+ self.state = 1268
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
+ if la_ == 1:
+ self.state = 1264
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1265
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1266
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1267
+ self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 1272
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1270
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1271
+ self.vfrStatementQuestionOptionList(localctx.Node)
+
+
+ self.state = 1274
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrGotoFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Obj=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Obj = None
+ self.GotoFlags = 0
+ self.Obj = Obj
+
+ def gotoFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.GotoFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.GotoFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrGotoFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrGotoFlags" ):
+ return visitor.visitVfrGotoFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrGotoFlags(self, Obj):
+
+ localctx = VfrSyntaxParser.VfrGotoFlagsContext(self, self._ctx, self.state, Obj)
+ self.enterRule(localctx, 128, self.RULE_vfrGotoFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1276
+ self.gotoFlagsField()
+ self.state = 1281
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1277
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1278
+ self.gotoFlagsField()
+ self.state = 1283
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GotoFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_gotoFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGotoFlagsField" ):
+ return visitor.visitGotoFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def gotoFlagsField(self):
+
+ localctx = VfrSyntaxParser.GotoFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 130, self.RULE_gotoFlagsField)
+ try:
+ self.state = 1286
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1284
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1285
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementResetButtonContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_RESET_BUTTON_OP)
+ self.OpObj = CIfrResetButton()
+ self.N = None # Token
+
+ def ResetButton(self):
+ return self.getToken(VfrSyntaxParser.ResetButton, 0)
+
+ def DefaultStore(self):
+ return self.getToken(VfrSyntaxParser.DefaultStore, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def EndResetButton(self):
+ return self.getToken(VfrSyntaxParser.EndResetButton, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def vfrStatementStatTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementResetButton
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementResetButton" ):
+ return visitor.visitVfrStatementResetButton(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementResetButton(self):
+
+ localctx = VfrSyntaxParser.VfrStatementResetButtonContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 132, self.RULE_vfrStatementResetButton)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1288
+ self.match(VfrSyntaxParser.ResetButton)
+ self.state = 1289
+ self.match(VfrSyntaxParser.DefaultStore)
+ self.state = 1290
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1291
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1292
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1293
+ self.vfrStatementHeader(localctx.OpObj)
+ self.state = 1294
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1298
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Image or _la==VfrSyntaxParser.Locked:
+ self.state = 1295
+ self.vfrStatementStatTagList(localctx.Node)
+ self.state = 1296
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1300
+ self.match(VfrSyntaxParser.EndResetButton)
+ self.state = 1301
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementBooleanType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBooleanTypeContext,0)
+
+
+ def vfrStatementDate(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDateContext,0)
+
+
+ def vfrStatementNumericType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericTypeContext,0)
+
+
+ def vfrStatementStringType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringTypeContext,0)
+
+
+ def vfrStatementOrderedList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOrderedListContext,0)
+
+
+ def vfrStatementTime(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementTimeContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestions
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestions" ):
+ return visitor.visitVfrStatementQuestions(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestions(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 134, self.RULE_vfrStatementQuestions)
+ try:
+ self.state = 1309
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.CheckBox, VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1303
+ self.vfrStatementBooleanType()
+ pass
+ elif token in [VfrSyntaxParser.Date]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1304
+ self.vfrStatementDate()
+ pass
+ elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.Numeric]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1305
+ self.vfrStatementNumericType()
+ pass
+ elif token in [VfrSyntaxParser.Password, VfrSyntaxParser.String]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1306
+ self.vfrStatementStringType()
+ pass
+ elif token in [VfrSyntaxParser.OrderedList]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1307
+ self.vfrStatementOrderedList()
+ pass
+ elif token in [VfrSyntaxParser.Time]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1308
+ self.vfrStatementTime()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementStatTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,0)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementInconsistentIf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,0)
+
+
+ def vfrStatementNoSubmitIf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNoSubmitIfContext,0)
+
+
+ def vfrStatementDisableIfQuest(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfQuestContext,0)
+
+
+ def vfrStatementRefresh(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshContext,0)
+
+
+ def vfrStatementVarstoreDevice(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarstoreDeviceContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def vfrStatementRefreshEvent(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0)
+
+
+ def vfrStatementWarningIf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWarningIfContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionTag" ):
+ return visitor.visitVfrStatementQuestionTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionTag(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 136, self.RULE_vfrStatementQuestionTag)
+ try:
+ self.state = 1322
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Image, VfrSyntaxParser.Locked]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1311
+ self.vfrStatementStatTag()
+ self.state = 1312
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.InconsistentIf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1314
+ self.vfrStatementInconsistentIf()
+ pass
+ elif token in [VfrSyntaxParser.NoSubmitIf]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1315
+ self.vfrStatementNoSubmitIf()
+ pass
+ elif token in [VfrSyntaxParser.DisableIf]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1316
+ self.vfrStatementDisableIfQuest()
+ pass
+ elif token in [VfrSyntaxParser.Refresh]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1317
+ self.vfrStatementRefresh()
+ pass
+ elif token in [VfrSyntaxParser.VarstoreDevice]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1318
+ self.vfrStatementVarstoreDevice()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1319
+ self.vfrStatementExtension()
+ pass
+ elif token in [VfrSyntaxParser.RefreshGuid]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1320
+ self.vfrStatementRefreshEvent()
+ pass
+ elif token in [VfrSyntaxParser.WarningIf]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 1321
+ self.vfrStatementWarningIf()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInconsistentIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
+
+ def InconsistentIf(self):
+ return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInconsistentIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInconsistentIf" ):
+ return visitor.visitVfrStatementInconsistentIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInconsistentIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInconsistentIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 138, self.RULE_vfrStatementInconsistentIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1324
+ self.match(VfrSyntaxParser.InconsistentIf)
+ self.state = 1325
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1326
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1327
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1328
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1329
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1330
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1331
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1344
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1332
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1333
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1334
+ self.flagsField()
+ self.state = 1339
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1335
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1336
+ self.flagsField()
+ self.state = 1341
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1342
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1346
+ self.vfrStatementExpression()
+ self.state = 1347
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1349
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
+ if la_ == 1:
+ self.state = 1348
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementNoSubmitIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)
+
+ def NoSubmitIf(self):
+ return self.getToken(VfrSyntaxParser.NoSubmitIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementNoSubmitIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementNoSubmitIf" ):
+ return visitor.visitVfrStatementNoSubmitIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementNoSubmitIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementNoSubmitIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 140, self.RULE_vfrStatementNoSubmitIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1351
+ self.match(VfrSyntaxParser.NoSubmitIf)
+ self.state = 1352
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1353
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1354
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1355
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1356
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1357
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1358
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1371
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1359
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1360
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1361
+ self.flagsField()
+ self.state = 1366
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1362
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1363
+ self.flagsField()
+ self.state = 1368
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1369
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1373
+ self.vfrStatementExpression()
+ self.state = 1374
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1376
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
+ if la_ == 1:
+ self.state = 1375
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDisableIfQuestContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_DISABLE_IF_OP)
+
+ def DisableIf(self):
+ return self.getToken(VfrSyntaxParser.DisableIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDisableIfQuest
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDisableIfQuest" ):
+ return visitor.visitVfrStatementDisableIfQuest(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDisableIfQuest(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDisableIfQuestContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 142, self.RULE_vfrStatementDisableIfQuest)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1378
+ self.match(VfrSyntaxParser.DisableIf)
+ self.state = 1379
+ self.vfrStatementExpression()
+ self.state = 1380
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1381
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1382
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1384
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
+ if la_ == 1:
+ self.state = 1383
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementRefreshContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_REFRESH_OP)
+
+ def Refresh(self):
+ return self.getToken(VfrSyntaxParser.Refresh, 0)
+
+ def Interval(self):
+ return self.getToken(VfrSyntaxParser.Interval, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRefresh
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRefresh" ):
+ return visitor.visitVfrStatementRefresh(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRefresh(self):
+
+ localctx = VfrSyntaxParser.VfrStatementRefreshContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 144, self.RULE_vfrStatementRefresh)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1386
+ self.match(VfrSyntaxParser.Refresh)
+ self.state = 1387
+ self.match(VfrSyntaxParser.Interval)
+ self.state = 1388
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1389
+ self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarstoreDeviceContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)
+
+ def VarstoreDevice(self):
+ return self.getToken(VfrSyntaxParser.VarstoreDevice, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarstoreDevice
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarstoreDevice" ):
+ return visitor.visitVfrStatementVarstoreDevice(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarstoreDevice(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarstoreDeviceContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 146, self.RULE_vfrStatementVarstoreDevice)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1391
+ self.match(VfrSyntaxParser.VarstoreDevice)
+ self.state = 1392
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1393
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1394
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1395
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1396
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1397
+ self.match(VfrSyntaxParser.Comma)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementRefreshEventContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_REFRESH_ID_OP)
+
+ def RefreshGuid(self):
+ return self.getToken(VfrSyntaxParser.RefreshGuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRefreshEvent
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRefreshEvent" ):
+ return visitor.visitVfrStatementRefreshEvent(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRefreshEvent(self):
+
+ localctx = VfrSyntaxParser.VfrStatementRefreshEventContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 148, self.RULE_vfrStatementRefreshEvent)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1399
+ self.match(VfrSyntaxParser.RefreshGuid)
+ self.state = 1400
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1401
+ self.guidDefinition()
+ self.state = 1402
+ self.match(VfrSyntaxParser.Comma)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementWarningIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_WARNING_IF_OP)
+
+ def WarningIf(self):
+ return self.getToken(VfrSyntaxParser.WarningIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def Timeout(self):
+ return self.getToken(VfrSyntaxParser.Timeout, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementWarningIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementWarningIf" ):
+ return visitor.visitVfrStatementWarningIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementWarningIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementWarningIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 150, self.RULE_vfrStatementWarningIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1404
+ self.match(VfrSyntaxParser.WarningIf)
+ self.state = 1405
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1406
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1407
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1408
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1409
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1410
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1411
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1416
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Timeout:
+ self.state = 1412
+ self.match(VfrSyntaxParser.Timeout)
+ self.state = 1413
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1414
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1415
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1418
+ self.vfrStatementExpression()
+ self.state = 1419
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1421
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
+ if la_ == 1:
+ self.state = 1420
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionTagListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrStatementQuestionTag(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionTagContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionTagList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionTagList" ):
+ return visitor.visitVfrStatementQuestionTagList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionTagList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionTagListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 152, self.RULE_vfrStatementQuestionTagList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1426
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 106)) & ~0x3f) == 0 and ((1 << (_la - 106)) & ((1 << (VfrSyntaxParser.DisableIf - 106)) | (1 << (VfrSyntaxParser.InconsistentIf - 106)) | (1 << (VfrSyntaxParser.WarningIf - 106)) | (1 << (VfrSyntaxParser.NoSubmitIf - 106)) | (1 << (VfrSyntaxParser.Image - 106)) | (1 << (VfrSyntaxParser.Locked - 106)) | (1 << (VfrSyntaxParser.Refresh - 106)) | (1 << (VfrSyntaxParser.VarstoreDevice - 106)) | (1 << (VfrSyntaxParser.GuidOp - 106)))) != 0) or _la==VfrSyntaxParser.RefreshGuid:
+ self.state = 1423
+ self.vfrStatementQuestionTag()
+ self.state = 1428
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionOptionTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementSuppressIfQuest(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfQuestContext,0)
+
+
+ def vfrStatementGrayOutIfQuest(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfQuestContext,0)
+
+
+ def vfrStatementValue(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
+
+
+ def vfrStatementDefault(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
+
+
+ def vfrStatementOptions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOptionsContext,0)
+
+
+ def vfrStatementRead(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementReadContext,0)
+
+
+ def vfrStatementWrite(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWriteContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionOptionTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionOptionTag" ):
+ return visitor.visitVfrStatementQuestionOptionTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionOptionTag(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionOptionTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 154, self.RULE_vfrStatementQuestionOptionTag)
+ try:
+ self.state = 1436
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.SuppressIf]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1429
+ self.vfrStatementSuppressIfQuest()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1430
+ self.vfrStatementGrayOutIfQuest()
+ pass
+ elif token in [VfrSyntaxParser.Value]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1431
+ self.vfrStatementValue()
+ pass
+ elif token in [VfrSyntaxParser.Default]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1432
+ self.vfrStatementDefault()
+ pass
+ elif token in [VfrSyntaxParser.Option]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1433
+ self.vfrStatementOptions()
+ pass
+ elif token in [VfrSyntaxParser.Read]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1434
+ self.vfrStatementRead()
+ pass
+ elif token in [VfrSyntaxParser.Write]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1435
+ self.vfrStatementWrite()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.N = None # Token
+ self.L = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def InteractiveFlag(self):
+ return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
+
+ def ManufacturingFlag(self):
+ return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
+
+ def DefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
+
+ def ResetRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
+
+ def ReconnectRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
+
+ def NVAccessFlag(self):
+ return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
+
+ def LateCheckFlag(self):
+ return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_flagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFlagsField" ):
+ return visitor.visitFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def flagsField(self):
+
+ localctx = VfrSyntaxParser.FlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 156, self.RULE_flagsField)
+ try:
+ self.state = 1446
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1438
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1439
+ self.match(VfrSyntaxParser.InteractiveFlag)
+ pass
+ elif token in [VfrSyntaxParser.ManufacturingFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1440
+ self.match(VfrSyntaxParser.ManufacturingFlag)
+ pass
+ elif token in [VfrSyntaxParser.DefaultFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1441
+ self.match(VfrSyntaxParser.DefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.ResetRequiredFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1442
+ self.match(VfrSyntaxParser.ResetRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1443
+ self.match(VfrSyntaxParser.ReconnectRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.NVAccessFlag]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1444
+ localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
+ pass
+ elif token in [VfrSyntaxParser.LateCheckFlag]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1445
+ localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfQuestContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfQuest
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfQuest" ):
+ return visitor.visitVfrStatementSuppressIfQuest(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfQuest(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfQuestContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 158, self.RULE_vfrStatementSuppressIfQuest)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1448
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 1449
+ self.vfrStatementExpression()
+ self.state = 1450
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1463
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1451
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1452
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1453
+ self.flagsField()
+ self.state = 1458
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1454
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1455
+ self.flagsField()
+ self.state = 1460
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1461
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1465
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1466
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1468
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
+ if la_ == 1:
+ self.state = 1467
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGrayOutIfQuestContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def GrayOutIf(self):
+ return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGrayOutIfQuest
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGrayOutIfQuest" ):
+ return visitor.visitVfrStatementGrayOutIfQuest(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGrayOutIfQuest(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGrayOutIfQuestContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 160, self.RULE_vfrStatementGrayOutIfQuest)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1470
+ self.match(VfrSyntaxParser.GrayOutIf)
+ self.state = 1471
+ self.vfrStatementExpression()
+ self.state = 1472
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1485
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1473
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1474
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1475
+ self.flagsField()
+ self.state = 1480
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1476
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1477
+ self.flagsField()
+ self.state = 1482
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1483
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1487
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1488
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1490
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
+ if la_ == 1:
+ self.state = 1489
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDefaultContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_DEFAULT_OP)
+ self.D = None # Token
+ self.SN = None # Token
+
+ def Default(self):
+ return self.getToken(VfrSyntaxParser.Default, 0)
+
+ def vfrStatementValue(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrConstantValueField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
+
+
+ def DefaultStore(self):
+ return self.getToken(VfrSyntaxParser.DefaultStore, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDefault
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDefault" ):
+ return visitor.visitVfrStatementDefault(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDefault(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDefaultContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 162, self.RULE_vfrStatementDefault)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1492
+ localctx.D = self.match(VfrSyntaxParser.Default)
+
+ self.state = 1500
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Value]:
+ self.state = 1493
+ self.vfrStatementValue()
+ self.state = 1494
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.T__5]:
+ self.state = 1496
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1497
+ self.vfrConstantValueField()
+ self.state = 1498
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 1506
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.DefaultStore:
+ self.state = 1502
+ self.match(VfrSyntaxParser.DefaultStore)
+ self.state = 1503
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1504
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1505
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementValueContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_VALUE_OP)
+
+ def Value(self):
+ return self.getToken(VfrSyntaxParser.Value, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementValue
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementValue" ):
+ return visitor.visitVfrStatementValue(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementValue(self):
+
+ localctx = VfrSyntaxParser.VfrStatementValueContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 164, self.RULE_vfrStatementValue)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1508
+ self.match(VfrSyntaxParser.Value)
+ self.state = 1509
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1510
+ self.vfrStatementExpression()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOptionsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementOneOfOption(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfOptionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOptions
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOptions" ):
+ return visitor.visitVfrStatementOptions(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOptions(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOptionsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 166, self.RULE_vfrStatementOptions)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1512
+ self.vfrStatementOneOfOption()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOneOfOptionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_ONE_OF_OPTION_OP)
+ self.F = None # Token
+ self.KN = None # Token
+
+ def Option(self):
+ return self.getToken(VfrSyntaxParser.Option, 0)
+
+ def Text(self):
+ return self.getToken(VfrSyntaxParser.Text, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Value(self):
+ return self.getToken(VfrSyntaxParser.Value, 0)
+
+ def vfrConstantValueField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
+
+
+ def vfrOneOfOptionFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrOneOfOptionFlagsContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def vfrImageTag(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrImageTagContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOneOfOption
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOneOfOption" ):
+ return visitor.visitVfrStatementOneOfOption(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOneOfOption(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOneOfOptionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 168, self.RULE_vfrStatementOneOfOption)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1514
+ self.match(VfrSyntaxParser.Option)
+ self.state = 1515
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1516
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1517
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1518
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1519
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1520
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1521
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1522
+ self.match(VfrSyntaxParser.Value)
+ self.state = 1523
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1524
+ self.vfrConstantValueField()
+ self.state = 1525
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1526
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1527
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1528
+ self.vfrOneOfOptionFlags()
+ self.state = 1533
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
+ if la_ == 1:
+ self.state = 1529
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1530
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1531
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1532
+ localctx.KN = self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 1539
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Comma:
+ self.state = 1535
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1536
+ self.vfrImageTag()
+ self.state = 1541
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1542
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrOneOfOptionFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def oneofoptionFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.OneofoptionFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.OneofoptionFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrOneOfOptionFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrOneOfOptionFlags" ):
+ return visitor.visitVfrOneOfOptionFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrOneOfOptionFlags(self):
+
+ localctx = VfrSyntaxParser.VfrOneOfOptionFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 170, self.RULE_vfrOneOfOptionFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1544
+ self.oneofoptionFlagsField()
+ self.state = 1549
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1545
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1546
+ self.oneofoptionFlagsField()
+ self.state = 1551
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class OneofoptionFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.LFlag = 0
+ self.A = None # Token
+ self.L = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def OptionDefault(self):
+ return self.getToken(VfrSyntaxParser.OptionDefault, 0)
+
+ def OptionDefaultMfg(self):
+ return self.getToken(VfrSyntaxParser.OptionDefaultMfg, 0)
+
+ def InteractiveFlag(self):
+ return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
+
+ def ResetRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
+
+ def RestStyleFlag(self):
+ return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
+
+ def ReconnectRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
+
+ def ManufacturingFlag(self):
+ return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
+
+ def DefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
+
+ def NVAccessFlag(self):
+ return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
+
+ def LateCheckFlag(self):
+ return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_oneofoptionFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitOneofoptionFlagsField" ):
+ return visitor.visitOneofoptionFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def oneofoptionFlagsField(self):
+
+ localctx = VfrSyntaxParser.OneofoptionFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 172, self.RULE_oneofoptionFlagsField)
+ try:
+ self.state = 1563
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1552
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.OptionDefault]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1553
+ self.match(VfrSyntaxParser.OptionDefault)
+ pass
+ elif token in [VfrSyntaxParser.OptionDefaultMfg]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1554
+ self.match(VfrSyntaxParser.OptionDefaultMfg)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1555
+ self.match(VfrSyntaxParser.InteractiveFlag)
+ pass
+ elif token in [VfrSyntaxParser.ResetRequiredFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1556
+ self.match(VfrSyntaxParser.ResetRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1557
+ self.match(VfrSyntaxParser.RestStyleFlag)
+ pass
+ elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1558
+ self.match(VfrSyntaxParser.ReconnectRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.ManufacturingFlag]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1559
+ self.match(VfrSyntaxParser.ManufacturingFlag)
+ pass
+ elif token in [VfrSyntaxParser.DefaultFlag]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 1560
+ self.match(VfrSyntaxParser.DefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.NVAccessFlag]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 1561
+ localctx.A = self.match(VfrSyntaxParser.NVAccessFlag)
+ pass
+ elif token in [VfrSyntaxParser.LateCheckFlag]:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 1562
+ localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementReadContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_READ_OP)
+
+ def Read(self):
+ return self.getToken(VfrSyntaxParser.Read, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRead
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRead" ):
+ return visitor.visitVfrStatementRead(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRead(self):
+
+ localctx = VfrSyntaxParser.VfrStatementReadContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 174, self.RULE_vfrStatementRead)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1565
+ self.match(VfrSyntaxParser.Read)
+ self.state = 1566
+ self.vfrStatementExpression()
+ self.state = 1567
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementWriteContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_WRITE_OP)
+
+ def Write(self):
+ return self.getToken(VfrSyntaxParser.Write, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementWrite
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementWrite" ):
+ return visitor.visitVfrStatementWrite(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementWrite(self):
+
+ localctx = VfrSyntaxParser.VfrStatementWriteContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 176, self.RULE_vfrStatementWrite)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1569
+ self.match(VfrSyntaxParser.Write)
+ self.state = 1570
+ self.vfrStatementExpression()
+ self.state = 1571
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionOptionListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrStatementQuestionOption(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionOptionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionOptionList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionOptionList" ):
+ return visitor.visitVfrStatementQuestionOptionList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionOptionList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionOptionListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 178, self.RULE_vfrStatementQuestionOptionList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1576
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (VfrSyntaxParser.Option - 61)) | (1 << (VfrSyntaxParser.GrayOutIf - 61)) | (1 << (VfrSyntaxParser.Default - 61)) | (1 << (VfrSyntaxParser.SuppressIf - 61)) | (1 << (VfrSyntaxParser.DisableIf - 61)) | (1 << (VfrSyntaxParser.InconsistentIf - 61)) | (1 << (VfrSyntaxParser.WarningIf - 61)) | (1 << (VfrSyntaxParser.NoSubmitIf - 61)))) != 0) or ((((_la - 144)) & ~0x3f) == 0 and ((1 << (_la - 144)) & ((1 << (VfrSyntaxParser.Image - 144)) | (1 << (VfrSyntaxParser.Locked - 144)) | (1 << (VfrSyntaxParser.Value - 144)) | (1 << (VfrSyntaxParser.Read - 144)) | (1 << (VfrSyntaxParser.Write - 144)) | (1 << (VfrSyntaxParser.Refresh - 144)) | (1 << (VfrSyntaxParser.VarstoreDevice - 144)) | (1 << (VfrSyntaxParser.GuidOp - 144)))) != 0) or _la==VfrSyntaxParser.RefreshGuid:
+ self.state = 1573
+ self.vfrStatementQuestionOption()
+ self.state = 1578
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionOptionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementQuestionTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,0)
+
+
+ def vfrStatementQuestionOptionTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionTagContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionOption
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionOption" ):
+ return visitor.visitVfrStatementQuestionOption(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionOption(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionOptionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 180, self.RULE_vfrStatementQuestionOption)
+ try:
+ self.state = 1581
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf, VfrSyntaxParser.WarningIf, VfrSyntaxParser.NoSubmitIf, VfrSyntaxParser.Image, VfrSyntaxParser.Locked, VfrSyntaxParser.Refresh, VfrSyntaxParser.VarstoreDevice, VfrSyntaxParser.GuidOp, VfrSyntaxParser.RefreshGuid]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1579
+ self.vfrStatementQuestionTag()
+ pass
+ elif token in [VfrSyntaxParser.Option, VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.Default, VfrSyntaxParser.SuppressIf, VfrSyntaxParser.Value, VfrSyntaxParser.Read, VfrSyntaxParser.Write]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1580
+ self.vfrStatementQuestionOptionTag()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementBooleanTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementCheckBox(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCheckBoxContext,0)
+
+
+ def vfrStatementAction(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementActionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementBooleanType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementBooleanType" ):
+ return visitor.visitVfrStatementBooleanType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementBooleanType(self):
+
+ localctx = VfrSyntaxParser.VfrStatementBooleanTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 182, self.RULE_vfrStatementBooleanType)
+ try:
+ self.state = 1585
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.CheckBox]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1583
+ self.vfrStatementCheckBox()
+ pass
+ elif token in [VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1584
+ self.vfrStatementAction()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementCheckBoxContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_CHECKBOX_OP)
+ self.OpObj = CIfrCheckBox()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.L = None # Token
+ self.F = None # Token
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndCheckBox(self):
+ return self.getToken(VfrSyntaxParser.EndCheckBox, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def CheckBox(self):
+ return self.getToken(VfrSyntaxParser.CheckBox, 0)
+
+ def vfrCheckBoxFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrCheckBoxFlagsContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementCheckBox
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementCheckBox" ):
+ return visitor.visitVfrStatementCheckBox(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementCheckBox(self):
+
+ localctx = VfrSyntaxParser.VfrStatementCheckBoxContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 184, self.RULE_vfrStatementCheckBox)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1587
+ localctx.L = self.match(VfrSyntaxParser.CheckBox)
+ self.state = 1588
+ self.vfrQuestionBaseInfo(localctx.OpObj, localctx.QType)
+ self.state = 1589
+ self.vfrStatementHeader(localctx.OpObj)
+ self.state = 1590
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1596
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1591
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1592
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1593
+ self.vfrCheckBoxFlags()
+ self.state = 1594
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1602
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1598
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1599
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1600
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1601
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1604
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1605
+ self.match(VfrSyntaxParser.EndCheckBox)
+ self.state = 1606
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrCheckBoxFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlags = 0
+ self.HFlags = 0
+
+ def checkboxFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.CheckboxFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.CheckboxFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrCheckBoxFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrCheckBoxFlags" ):
+ return visitor.visitVfrCheckBoxFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrCheckBoxFlags(self):
+
+ localctx = VfrSyntaxParser.VfrCheckBoxFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 186, self.RULE_vfrCheckBoxFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1608
+ self.checkboxFlagsField()
+ self.state = 1613
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1609
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1610
+ self.checkboxFlagsField()
+ self.state = 1615
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CheckboxFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlag = 0
+ self.HFlag = 0
+ self.D = None # Token
+ self.M = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def DefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
+
+ def ManufacturingFlag(self):
+ return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
+
+ def CheckBoxDefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.CheckBoxDefaultFlag, 0)
+
+ def CheckBoxDefaultMfgFlag(self):
+ return self.getToken(VfrSyntaxParser.CheckBoxDefaultMfgFlag, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_checkboxFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCheckboxFlagsField" ):
+ return visitor.visitCheckboxFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def checkboxFlagsField(self):
+
+ localctx = VfrSyntaxParser.CheckboxFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 188, self.RULE_checkboxFlagsField)
+ try:
+ self.state = 1622
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1616
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.DefaultFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1617
+ localctx.D = self.match(VfrSyntaxParser.DefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.ManufacturingFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1618
+ localctx.M = self.match(VfrSyntaxParser.ManufacturingFlag)
+ pass
+ elif token in [VfrSyntaxParser.CheckBoxDefaultFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1619
+ self.match(VfrSyntaxParser.CheckBoxDefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.CheckBoxDefaultMfgFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1620
+ self.match(VfrSyntaxParser.CheckBoxDefaultMfgFlag)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1621
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementActionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_ACTION_OP)
+ self.OpObj = CIfrAction()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+
+ def Action(self):
+ return self.getToken(VfrSyntaxParser.Action, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Config(self):
+ return self.getToken(VfrSyntaxParser.Config, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def vfrStatementQuestionTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagListContext,0)
+
+
+ def EndAction(self):
+ return self.getToken(VfrSyntaxParser.EndAction, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def vfrActionFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrActionFlagsContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementAction
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementAction" ):
+ return visitor.visitVfrStatementAction(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementAction(self):
+
+ localctx = VfrSyntaxParser.VfrStatementActionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 190, self.RULE_vfrStatementAction)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1624
+ self.match(VfrSyntaxParser.Action)
+ self.state = 1625
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 1626
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1632
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1627
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1628
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1629
+ self.vfrActionFlags()
+ self.state = 1630
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1634
+ self.match(VfrSyntaxParser.Config)
+ self.state = 1635
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1636
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1637
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1638
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1639
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1640
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1641
+ self.vfrStatementQuestionTagList(localctx.Node)
+ self.state = 1642
+ self.match(VfrSyntaxParser.EndAction)
+ self.state = 1643
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrActionFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+
+ def actionFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ActionFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ActionFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrActionFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrActionFlags" ):
+ return visitor.visitVfrActionFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrActionFlags(self):
+
+ localctx = VfrSyntaxParser.VfrActionFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 192, self.RULE_vfrActionFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1645
+ self.actionFlagsField()
+ self.state = 1650
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1646
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1647
+ self.actionFlagsField()
+ self.state = 1652
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ActionFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_actionFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitActionFlagsField" ):
+ return visitor.visitActionFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def actionFlagsField(self):
+
+ localctx = VfrSyntaxParser.ActionFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 194, self.RULE_actionFlagsField)
+ try:
+ self.state = 1655
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1653
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1654
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementNumericTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementNumeric(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericContext,0)
+
+
+ def vfrStatementOneOf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementNumericType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementNumericType" ):
+ return visitor.visitVfrStatementNumericType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementNumericType(self):
+
+ localctx = VfrSyntaxParser.VfrStatementNumericTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 196, self.RULE_vfrStatementNumericType)
+ try:
+ self.state = 1659
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Numeric]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1657
+ self.vfrStatementNumeric()
+ pass
+ elif token in [VfrSyntaxParser.OneOf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1658
+ self.vfrStatementOneOf()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementNumericContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_NUMERIC_OP)
+ self.OpObj = CIfrNumeric()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+
+ def Numeric(self):
+ return self.getToken(VfrSyntaxParser.Numeric, 0)
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrSetMinMaxStep(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
+
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndNumeric(self):
+ return self.getToken(VfrSyntaxParser.EndNumeric, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrNumericFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrNumericFlagsContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementNumeric
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementNumeric" ):
+ return visitor.visitVfrStatementNumeric(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementNumeric(self):
+
+ localctx = VfrSyntaxParser.VfrStatementNumericContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 198, self.RULE_vfrStatementNumeric)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1661
+ self.match(VfrSyntaxParser.Numeric)
+ self.state = 1662
+ self.vfrQuestionBaseInfo(localctx.OpObj, localctx.QType)
+ self.state = 1663
+ self.vfrStatementHeader(localctx.OpObj)
+ self.state = 1664
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1670
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1665
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1666
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1667
+ self.vfrNumericFlags()
+ self.state = 1668
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1676
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1672
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1673
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1674
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1675
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1678
+ self.vfrSetMinMaxStep(localctx.OpObj)
+ self.state = 1679
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1680
+ self.match(VfrSyntaxParser.EndNumeric)
+ self.state = 1681
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrSetMinMaxStepContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, OpObj=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.OpObj = None
+ self.N1 = None # Token
+ self.I = None # Token
+ self.N2 = None # Token
+ self.A = None # Token
+ self.S = None # Token
+ self.OpObj = OpObj
+
+ def Minimum(self):
+ return self.getToken(VfrSyntaxParser.Minimum, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Maximum(self):
+ return self.getToken(VfrSyntaxParser.Maximum, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Step(self):
+ return self.getToken(VfrSyntaxParser.Step, 0)
+
+ def Negative(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Negative)
+ else:
+ return self.getToken(VfrSyntaxParser.Negative, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrSetMinMaxStep
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrSetMinMaxStep" ):
+ return visitor.visitVfrSetMinMaxStep(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrSetMinMaxStep(self, OpObj):
+
+ localctx = VfrSyntaxParser.VfrSetMinMaxStepContext(self, self._ctx, self.state, OpObj)
+ self.enterRule(localctx, 200, self.RULE_vfrSetMinMaxStep)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1683
+ self.match(VfrSyntaxParser.Minimum)
+ self.state = 1684
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1686
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Negative:
+ self.state = 1685
+ localctx.N1 = self.match(VfrSyntaxParser.Negative)
+
+
+ self.state = 1688
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 1689
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1690
+ self.match(VfrSyntaxParser.Maximum)
+ self.state = 1691
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1693
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Negative:
+ self.state = 1692
+ localctx.N2 = self.match(VfrSyntaxParser.Negative)
+
+
+ self.state = 1695
+ localctx.A = self.match(VfrSyntaxParser.Number)
+ self.state = 1696
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1701
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Step:
+ self.state = 1697
+ self.match(VfrSyntaxParser.Step)
+ self.state = 1698
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1699
+ localctx.S = self.match(VfrSyntaxParser.Number)
+ self.state = 1700
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrNumericFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+ self.IsDisplaySpecified = False
+
+ def numericFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrNumericFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrNumericFlags" ):
+ return visitor.visitVfrNumericFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrNumericFlags(self):
+
+ localctx = VfrSyntaxParser.VfrNumericFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 202, self.RULE_vfrNumericFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1703
+ self.numericFlagsField()
+ self.state = 1708
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1704
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1705
+ self.numericFlagsField()
+ self.state = 1710
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class NumericFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.IsSetType = False
+ self.IsDisplaySpecified = False
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def NumericSizeOne(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
+
+ def NumericSizeTwo(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
+
+ def NumericSizeFour(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
+
+ def NumericSizeEight(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
+
+ def DisPlayIntDec(self):
+ return self.getToken(VfrSyntaxParser.DisPlayIntDec, 0)
+
+ def DisPlayUIntDec(self):
+ return self.getToken(VfrSyntaxParser.DisPlayUIntDec, 0)
+
+ def DisPlayUIntHex(self):
+ return self.getToken(VfrSyntaxParser.DisPlayUIntHex, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_numericFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitNumericFlagsField" ):
+ return visitor.visitNumericFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def numericFlagsField(self):
+
+ localctx = VfrSyntaxParser.NumericFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 204, self.RULE_numericFlagsField)
+ try:
+ self.state = 1720
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1711
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeOne]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1712
+ self.match(VfrSyntaxParser.NumericSizeOne)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeTwo]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1713
+ self.match(VfrSyntaxParser.NumericSizeTwo)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeFour]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1714
+ self.match(VfrSyntaxParser.NumericSizeFour)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeEight]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1715
+ self.match(VfrSyntaxParser.NumericSizeEight)
+ pass
+ elif token in [VfrSyntaxParser.DisPlayIntDec]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1716
+ self.match(VfrSyntaxParser.DisPlayIntDec)
+ pass
+ elif token in [VfrSyntaxParser.DisPlayUIntDec]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1717
+ self.match(VfrSyntaxParser.DisPlayUIntDec)
+ pass
+ elif token in [VfrSyntaxParser.DisPlayUIntHex]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1718
+ self.match(VfrSyntaxParser.DisPlayUIntHex)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 1719
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOneOfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_ONE_OF_OP)
+ self.OpObj = CIfrOneOf()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+
+ def OneOf(self):
+ return self.getToken(VfrSyntaxParser.OneOf, 0)
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndOneOf(self):
+ return self.getToken(VfrSyntaxParser.EndOneOf, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrOneofFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrOneofFlagsFieldContext,0)
+
+
+ def vfrSetMinMaxStep(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOneOf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOneOf" ):
+ return visitor.visitVfrStatementOneOf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOneOf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOneOfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 206, self.RULE_vfrStatementOneOf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1722
+ self.match(VfrSyntaxParser.OneOf)
+ self.state = 1723
+ self.vfrQuestionBaseInfo(localctx.OpObj, localctx.QType)
+ self.state = 1724
+ self.vfrStatementHeader(localctx.OpObj)
+ self.state = 1725
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1731
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1726
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1727
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1728
+ self.vfrOneofFlagsField()
+ self.state = 1729
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1734
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Minimum:
+ self.state = 1733
+ self.vfrSetMinMaxStep(localctx.OpObj)
+
+
+ self.state = 1736
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1737
+ self.match(VfrSyntaxParser.EndOneOf)
+ self.state = 1738
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrOneofFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def numericFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrOneofFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrOneofFlagsField" ):
+ return visitor.visitVfrOneofFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrOneofFlagsField(self):
+
+ localctx = VfrSyntaxParser.VfrOneofFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 208, self.RULE_vfrOneofFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1740
+ self.numericFlagsField()
+ self.state = 1745
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1741
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1742
+ self.numericFlagsField()
+ self.state = 1747
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStringTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementString(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringContext,0)
+
+
+ def vfrStatementPassword(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementPasswordContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStringType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStringType" ):
+ return visitor.visitVfrStatementStringType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStringType(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStringTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 210, self.RULE_vfrStatementStringType)
+ try:
+ self.state = 1750
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.String]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1748
+ self.vfrStatementString()
+ pass
+ elif token in [VfrSyntaxParser.Password]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1749
+ self.vfrStatementPassword()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStringContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_STRING_OP)
+ self.OpObj = CIfrString()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+ self.Min = None # Token
+ self.Max = None # Token
+
+ def String(self):
+ return self.getToken(VfrSyntaxParser.String, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndString(self):
+ return self.getToken(VfrSyntaxParser.EndString, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def MinSize(self):
+ return self.getToken(VfrSyntaxParser.MinSize, 0)
+
+ def MaxSize(self):
+ return self.getToken(VfrSyntaxParser.MaxSize, 0)
+
+ def vfrStringFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStringFlagsFieldContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementString
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementString" ):
+ return visitor.visitVfrStatementString(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementString(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStringContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 212, self.RULE_vfrStatementString)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1752
+ self.match(VfrSyntaxParser.String)
+ self.state = 1753
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 1754
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1760
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1755
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1756
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1757
+ self.vfrStringFlagsField()
+ self.state = 1758
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1766
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1762
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1763
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1764
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1765
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1768
+ localctx.Min = self.match(VfrSyntaxParser.MinSize)
+ self.state = 1769
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1770
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1771
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1772
+ localctx.Max = self.match(VfrSyntaxParser.MaxSize)
+ self.state = 1773
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1774
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1775
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1776
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1777
+ self.match(VfrSyntaxParser.EndString)
+ self.state = 1778
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStringFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def stringFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.StringFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.StringFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStringFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStringFlagsField" ):
+ return visitor.visitVfrStringFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStringFlagsField(self):
+
+ localctx = VfrSyntaxParser.VfrStringFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 214, self.RULE_vfrStringFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1780
+ self.stringFlagsField()
+ self.state = 1785
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1781
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1782
+ self.stringFlagsField()
+ self.state = 1787
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class StringFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.LFlag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_stringFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStringFlagsField" ):
+ return visitor.visitStringFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def stringFlagsField(self):
+
+ localctx = VfrSyntaxParser.StringFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 216, self.RULE_stringFlagsField)
+ try:
+ self.state = 1791
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1788
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.T__8]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1789
+ self.match(VfrSyntaxParser.T__8)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1790
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementPasswordContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_PASSWORD_OP)
+ self.OpObj = CIfrPassword()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+ self.Min = None # Token
+ self.Max = None # Token
+
+ def Password(self):
+ return self.getToken(VfrSyntaxParser.Password, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndPassword(self):
+ return self.getToken(VfrSyntaxParser.EndPassword, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def MinSize(self):
+ return self.getToken(VfrSyntaxParser.MinSize, 0)
+
+ def MaxSize(self):
+ return self.getToken(VfrSyntaxParser.MaxSize, 0)
+
+ def vfrPasswordFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrPasswordFlagsFieldContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Encoding(self):
+ return self.getToken(VfrSyntaxParser.Encoding, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementPassword
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementPassword" ):
+ return visitor.visitVfrStatementPassword(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementPassword(self):
+
+ localctx = VfrSyntaxParser.VfrStatementPasswordContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 218, self.RULE_vfrStatementPassword)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1793
+ self.match(VfrSyntaxParser.Password)
+ self.state = 1794
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 1795
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1801
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1796
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1797
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1798
+ self.vfrPasswordFlagsField()
+ self.state = 1799
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1807
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1803
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1804
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1805
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1806
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1809
+ localctx.Min = self.match(VfrSyntaxParser.MinSize)
+ self.state = 1810
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1811
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1812
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1813
+ localctx.Max = self.match(VfrSyntaxParser.MaxSize)
+ self.state = 1814
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1815
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1816
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1821
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Encoding:
+ self.state = 1817
+ self.match(VfrSyntaxParser.Encoding)
+ self.state = 1818
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1819
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1820
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1823
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1824
+ self.match(VfrSyntaxParser.EndPassword)
+ self.state = 1825
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrPasswordFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+
+ def passwordFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.PasswordFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.PasswordFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrPasswordFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrPasswordFlagsField" ):
+ return visitor.visitVfrPasswordFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrPasswordFlagsField(self):
+
+ localctx = VfrSyntaxParser.VfrPasswordFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 220, self.RULE_vfrPasswordFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1827
+ self.passwordFlagsField()
+ self.state = 1832
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1828
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1829
+ self.passwordFlagsField()
+ self.state = 1834
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PasswordFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_passwordFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPasswordFlagsField" ):
+ return visitor.visitPasswordFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def passwordFlagsField(self):
+
+ localctx = VfrSyntaxParser.PasswordFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 222, self.RULE_passwordFlagsField)
+ try:
+ self.state = 1837
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1835
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1836
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOrderedListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_ORDERED_LIST_OP)
+ self.OpObj = CIfrOrderedList()
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.M = None # Token
+ self.F = None # Token
+
+ def OrderedList(self):
+ return self.getToken(VfrSyntaxParser.OrderedList, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndList(self):
+ return self.getToken(VfrSyntaxParser.EndList, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def vfrOrderedListFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrOrderedListFlagsContext,0)
+
+
+ def MaxContainers(self):
+ return self.getToken(VfrSyntaxParser.MaxContainers, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOrderedList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOrderedList" ):
+ return visitor.visitVfrStatementOrderedList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOrderedList(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOrderedListContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 224, self.RULE_vfrStatementOrderedList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1839
+ self.match(VfrSyntaxParser.OrderedList)
+ self.state = 1840
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 1841
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1846
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.MaxContainers:
+ self.state = 1842
+ localctx.M = self.match(VfrSyntaxParser.MaxContainers)
+ self.state = 1843
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1844
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1845
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1853
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1848
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1849
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1850
+ self.vfrOrderedListFlags()
+ self.state = 1851
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1855
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1856
+ self.match(VfrSyntaxParser.EndList)
+ self.state = 1857
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrOrderedListFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def orderedlistFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.OrderedlistFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.OrderedlistFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrOrderedListFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrOrderedListFlags" ):
+ return visitor.visitVfrOrderedListFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrOrderedListFlags(self):
+
+ localctx = VfrSyntaxParser.VfrOrderedListFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 226, self.RULE_vfrOrderedListFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1859
+ self.orderedlistFlagsField()
+ self.state = 1864
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1860
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1861
+ self.orderedlistFlagsField()
+ self.state = 1866
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class OrderedlistFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.LFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def UniQueFlag(self):
+ return self.getToken(VfrSyntaxParser.UniQueFlag, 0)
+
+ def NoEmptyFlag(self):
+ return self.getToken(VfrSyntaxParser.NoEmptyFlag, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_orderedlistFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitOrderedlistFlagsField" ):
+ return visitor.visitOrderedlistFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def orderedlistFlagsField(self):
+
+ localctx = VfrSyntaxParser.OrderedlistFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 228, self.RULE_orderedlistFlagsField)
+ try:
+ self.state = 1871
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1867
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.UniQueFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1868
+ self.match(VfrSyntaxParser.UniQueFlag)
+ pass
+ elif token in [VfrSyntaxParser.NoEmptyFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1869
+ self.match(VfrSyntaxParser.NoEmptyFlag)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag, VfrSyntaxParser.NVAccessFlag, VfrSyntaxParser.ResetRequiredFlag, VfrSyntaxParser.ReconnectRequiredFlag, VfrSyntaxParser.LateCheckFlag, VfrSyntaxParser.ReadOnlyFlag, VfrSyntaxParser.OptionOnlyFlag, VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1870
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDateContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_DATE_OP)
+ self.OpObj = CIfrDate()
+ self.QType = EFI_QUESION_TYPE.QUESTION_DATE
+ self.Val = EFI_IFR_TYPE_VALUE()
+ self.F1 = None # Token
+ self.F2 = None # Token
+
+ def Date(self):
+ return self.getToken(VfrSyntaxParser.Date, 0)
+
+ def EndDate(self):
+ return self.getToken(VfrSyntaxParser.EndDate, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def Year(self):
+ return self.getToken(VfrSyntaxParser.Year, 0)
+
+ def VarId(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.VarId)
+ else:
+ return self.getToken(VfrSyntaxParser.VarId, i)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+
+ def Prompt(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Prompt)
+ else:
+ return self.getToken(VfrSyntaxParser.Prompt, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Help)
+ else:
+ return self.getToken(VfrSyntaxParser.Help, i)
+
+ def minMaxDateStepDefault(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.MinMaxDateStepDefaultContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.MinMaxDateStepDefaultContext,i)
+
+
+ def Month(self):
+ return self.getToken(VfrSyntaxParser.Month, 0)
+
+ def Day(self):
+ return self.getToken(VfrSyntaxParser.Day, 0)
+
+ def vfrDateFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDateFlagsContext,0)
+
+
+ def vfrStatementInconsistentIf(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDate
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDate" ):
+ return visitor.visitVfrStatementDate(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDate(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDateContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 230, self.RULE_vfrStatementDate)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1873
+ self.match(VfrSyntaxParser.Date)
+ self.state = 1964
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Prompt, VfrSyntaxParser.Name, VfrSyntaxParser.VarId, VfrSyntaxParser.QuestionId]:
+ self.state = 1874
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 1875
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1881
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1876
+ localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1877
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1878
+ self.vfrDateFlags()
+ self.state = 1879
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1883
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ pass
+ elif token in [VfrSyntaxParser.Year]:
+ self.state = 1885
+ self.match(VfrSyntaxParser.Year)
+ self.state = 1886
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 1887
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1888
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1889
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 1890
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1891
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1892
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1893
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1894
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1895
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1896
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1897
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1898
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1899
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1900
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1901
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1902
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1903
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1904
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1905
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1906
+ self.minMaxDateStepDefault(localctx.Val.date, 0)
+ self.state = 1907
+ self.match(VfrSyntaxParser.Month)
+ self.state = 1908
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 1909
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1910
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1911
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 1912
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1913
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1914
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1915
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1916
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1917
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1918
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1919
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1920
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1921
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1922
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1923
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1924
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1925
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1926
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1927
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1928
+ self.minMaxDateStepDefault(localctx.Val.date, 1)
+ self.state = 1929
+ self.match(VfrSyntaxParser.Day)
+ self.state = 1930
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 1931
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1932
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1933
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 1934
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1935
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1936
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1937
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1938
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1939
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1940
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1941
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1942
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1943
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1944
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1945
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1946
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1947
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1948
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1949
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1950
+ self.minMaxDateStepDefault(localctx.Val.date, 2)
+ self.state = 1956
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1951
+ localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1952
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1953
+ self.vfrDateFlags()
+ self.state = 1954
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1961
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.InconsistentIf:
+ self.state = 1958
+ self.vfrStatementInconsistentIf()
+ self.state = 1963
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 1966
+ self.match(VfrSyntaxParser.EndDate)
+ self.state = 1967
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MinMaxDateStepDefaultContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Date=None, KeyValue=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Date = None
+ self.KeyValue = None
+ self.N = None # Token
+ self.Date = Date
+ self.KeyValue = KeyValue
+
+ def Minimum(self):
+ return self.getToken(VfrSyntaxParser.Minimum, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Maximum(self):
+ return self.getToken(VfrSyntaxParser.Maximum, 0)
+
+ def Step(self):
+ return self.getToken(VfrSyntaxParser.Step, 0)
+
+ def Default(self):
+ return self.getToken(VfrSyntaxParser.Default, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_minMaxDateStepDefault
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMinMaxDateStepDefault" ):
+ return visitor.visitMinMaxDateStepDefault(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def minMaxDateStepDefault(self, Date, KeyValue):
+
+ localctx = VfrSyntaxParser.MinMaxDateStepDefaultContext(self, self._ctx, self.state, Date, KeyValue)
+ self.enterRule(localctx, 232, self.RULE_minMaxDateStepDefault)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1969
+ self.match(VfrSyntaxParser.Minimum)
+ self.state = 1970
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1971
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1972
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1973
+ self.match(VfrSyntaxParser.Maximum)
+ self.state = 1974
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1975
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1976
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1981
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Step:
+ self.state = 1977
+ self.match(VfrSyntaxParser.Step)
+ self.state = 1978
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1979
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1980
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1987
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Default:
+ self.state = 1983
+ self.match(VfrSyntaxParser.Default)
+ self.state = 1984
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1985
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 1986
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDateFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlags = 0
+
+ def dateFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DateFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DateFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDateFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDateFlags" ):
+ return visitor.visitVfrDateFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDateFlags(self):
+
+ localctx = VfrSyntaxParser.VfrDateFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 234, self.RULE_vfrDateFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1989
+ self.dateFlagsField()
+ self.state = 1994
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1990
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1991
+ self.dateFlagsField()
+ self.state = 1996
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DateFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def YearSupppressFlag(self):
+ return self.getToken(VfrSyntaxParser.YearSupppressFlag, 0)
+
+ def MonthSuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.MonthSuppressFlag, 0)
+
+ def DaySuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.DaySuppressFlag, 0)
+
+ def StorageNormalFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
+
+ def StorageTimeFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
+
+ def StorageWakeUpFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dateFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDateFlagsField" ):
+ return visitor.visitDateFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dateFlagsField(self):
+
+ localctx = VfrSyntaxParser.DateFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 236, self.RULE_dateFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1997
+ _la = self._input.LA(1)
+ if not(((((_la - 181)) & ~0x3f) == 0 and ((1 << (_la - 181)) & ((1 << (VfrSyntaxParser.YearSupppressFlag - 181)) | (1 << (VfrSyntaxParser.MonthSuppressFlag - 181)) | (1 << (VfrSyntaxParser.DaySuppressFlag - 181)) | (1 << (VfrSyntaxParser.StorageNormalFlag - 181)) | (1 << (VfrSyntaxParser.StorageTimeFlag - 181)) | (1 << (VfrSyntaxParser.StorageWakeUpFlag - 181)))) != 0) or _la==VfrSyntaxParser.Number):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementTimeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_TIME_OP)
+ self.OpObj = CIfrTime()
+ self.QType = EFI_QUESION_TYPE.QUESTION_TIME
+ self.Val = EFI_IFR_TYPE_VALUE()
+ self.F1 = None # Token
+ self.F2 = None # Token
+
+ def Time(self):
+ return self.getToken(VfrSyntaxParser.Time, 0)
+
+ def EndTime(self):
+ return self.getToken(VfrSyntaxParser.EndTime, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def Hour(self):
+ return self.getToken(VfrSyntaxParser.Hour, 0)
+
+ def VarId(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.VarId)
+ else:
+ return self.getToken(VfrSyntaxParser.VarId, i)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+
+ def Prompt(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Prompt)
+ else:
+ return self.getToken(VfrSyntaxParser.Prompt, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Help)
+ else:
+ return self.getToken(VfrSyntaxParser.Help, i)
+
+ def minMaxTimeStepDefault(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.MinMaxTimeStepDefaultContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.MinMaxTimeStepDefaultContext,i)
+
+
+ def Minute(self):
+ return self.getToken(VfrSyntaxParser.Minute, 0)
+
+ def Second(self):
+ return self.getToken(VfrSyntaxParser.Second, 0)
+
+ def vfrTimeFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrTimeFlagsContext,0)
+
+
+ def vfrStatementInconsistentIf(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementTime
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementTime" ):
+ return visitor.visitVfrStatementTime(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementTime(self):
+
+ localctx = VfrSyntaxParser.VfrStatementTimeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 238, self.RULE_vfrStatementTime)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1999
+ self.match(VfrSyntaxParser.Time)
+ self.state = 2090
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Prompt, VfrSyntaxParser.Name, VfrSyntaxParser.VarId, VfrSyntaxParser.QuestionId]:
+ self.state = 2000
+ self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
+ self.state = 2001
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2007
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2002
+ localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2003
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2004
+ self.vfrTimeFlags()
+ self.state = 2005
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2009
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ pass
+ elif token in [VfrSyntaxParser.Hour]:
+ self.state = 2011
+ self.match(VfrSyntaxParser.Hour)
+ self.state = 2012
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 2013
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2014
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2015
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2016
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2017
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2018
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2019
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2020
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2021
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2022
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2023
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2024
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2025
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2026
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2027
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2028
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2029
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2030
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2031
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2032
+ self.minMaxTimeStepDefault(localctx.Val.time, 0)
+ self.state = 2033
+ self.match(VfrSyntaxParser.Minute)
+ self.state = 2034
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 2035
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2036
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2037
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2038
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2039
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2040
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2041
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2042
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2043
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2044
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2045
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2046
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2047
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2048
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2049
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2050
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2051
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2052
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2053
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2054
+ self.minMaxTimeStepDefault(localctx.Val.time, 1)
+ self.state = 2055
+ self.match(VfrSyntaxParser.Second)
+ self.state = 2056
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 2057
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2058
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2059
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2060
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2061
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2062
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2063
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2064
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2065
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2066
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2067
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2068
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2069
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2070
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2071
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2072
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2073
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2074
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2075
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2076
+ self.minMaxTimeStepDefault(localctx.Val.time, 2)
+ self.state = 2082
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2077
+ localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2078
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2079
+ self.vfrTimeFlags()
+ self.state = 2080
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2087
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.InconsistentIf:
+ self.state = 2084
+ self.vfrStatementInconsistentIf()
+ self.state = 2089
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 2092
+ self.match(VfrSyntaxParser.EndTime)
+ self.state = 2093
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MinMaxTimeStepDefaultContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Time=None, KeyValue=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Time = None
+ self.KeyValue = None
+ self.N = None # Token
+ self.Time = Time
+ self.KeyValue = KeyValue
+
+ def Minimum(self):
+ return self.getToken(VfrSyntaxParser.Minimum, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Maximum(self):
+ return self.getToken(VfrSyntaxParser.Maximum, 0)
+
+ def Step(self):
+ return self.getToken(VfrSyntaxParser.Step, 0)
+
+ def Default(self):
+ return self.getToken(VfrSyntaxParser.Default, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_minMaxTimeStepDefault
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMinMaxTimeStepDefault" ):
+ return visitor.visitMinMaxTimeStepDefault(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def minMaxTimeStepDefault(self, Time, KeyValue):
+
+ localctx = VfrSyntaxParser.MinMaxTimeStepDefaultContext(self, self._ctx, self.state, Time, KeyValue)
+ self.enterRule(localctx, 240, self.RULE_minMaxTimeStepDefault)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2095
+ self.match(VfrSyntaxParser.Minimum)
+ self.state = 2096
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2097
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2098
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2099
+ self.match(VfrSyntaxParser.Maximum)
+ self.state = 2100
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2101
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2102
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2107
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Step:
+ self.state = 2103
+ self.match(VfrSyntaxParser.Step)
+ self.state = 2104
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2105
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2106
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2113
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Default:
+ self.state = 2109
+ self.match(VfrSyntaxParser.Default)
+ self.state = 2110
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2111
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 2112
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrTimeFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlags = 0
+
+ def timeFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.TimeFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.TimeFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrTimeFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrTimeFlags" ):
+ return visitor.visitVfrTimeFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrTimeFlags(self):
+
+ localctx = VfrSyntaxParser.VfrTimeFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 242, self.RULE_vfrTimeFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2115
+ self.timeFlagsField()
+ self.state = 2120
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2116
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2117
+ self.timeFlagsField()
+ self.state = 2122
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TimeFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def HourSupppressFlag(self):
+ return self.getToken(VfrSyntaxParser.HourSupppressFlag, 0)
+
+ def MinuteSuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.MinuteSuppressFlag, 0)
+
+ def SecondSuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.SecondSuppressFlag, 0)
+
+ def StorageNormalFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
+
+ def StorageTimeFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
+
+ def StorageWakeUpFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_timeFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTimeFlagsField" ):
+ return visitor.visitTimeFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def timeFlagsField(self):
+
+ localctx = VfrSyntaxParser.TimeFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 244, self.RULE_timeFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2123
+ _la = self._input.LA(1)
+ if not(((((_la - 184)) & ~0x3f) == 0 and ((1 << (_la - 184)) & ((1 << (VfrSyntaxParser.HourSupppressFlag - 184)) | (1 << (VfrSyntaxParser.MinuteSuppressFlag - 184)) | (1 << (VfrSyntaxParser.SecondSuppressFlag - 184)) | (1 << (VfrSyntaxParser.StorageNormalFlag - 184)) | (1 << (VfrSyntaxParser.StorageTimeFlag - 184)) | (1 << (VfrSyntaxParser.StorageWakeUpFlag - 184)))) != 0) or _la==VfrSyntaxParser.Number):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementConditionalContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementDisableIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
+
+
+ def vfrStatementSuppressIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatContext,0)
+
+
+ def vfrStatementGrayOutIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatContext,0)
+
+
+ def vfrStatementInconsistentIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementConditional
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementConditional" ):
+ return visitor.visitVfrStatementConditional(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementConditional(self):
+
+ localctx = VfrSyntaxParser.VfrStatementConditionalContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 246, self.RULE_vfrStatementConditional)
+ try:
+ self.state = 2129
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.DisableIf]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2125
+ self.vfrStatementDisableIfStat()
+ pass
+ elif token in [VfrSyntaxParser.SuppressIf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2126
+ self.vfrStatementSuppressIfStat()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2127
+ self.vfrStatementGrayOutIfStat()
+ pass
+ elif token in [VfrSyntaxParser.InconsistentIf]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2128
+ self.vfrStatementInconsistentIfStat()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementConditionalNewContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementDisableIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
+
+
+ def vfrStatementSuppressIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewContext,0)
+
+
+ def vfrStatementGrayOutIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext,0)
+
+
+ def vfrStatementInconsistentIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementConditionalNew
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementConditionalNew" ):
+ return visitor.visitVfrStatementConditionalNew(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementConditionalNew(self):
+
+ localctx = VfrSyntaxParser.VfrStatementConditionalNewContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 248, self.RULE_vfrStatementConditionalNew)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2131
+ self.vfrStatementDisableIfStat()
+ self.state = 2132
+ self.vfrStatementSuppressIfStatNew()
+ self.state = 2133
+ self.vfrStatementGrayOutIfStatNew()
+ self.state = 2134
+ self.vfrStatementInconsistentIfStat()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementSuppressIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfStat" ):
+ return visitor.visitVfrStatementSuppressIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 250, self.RULE_vfrStatementSuppressIfStat)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2136
+ self.vfrStatementSuppressIfStatNew()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGrayOutIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementGrayOutIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGrayOutIfStat" ):
+ return visitor.visitVfrStatementGrayOutIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGrayOutIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 252, self.RULE_vfrStatementGrayOutIfStat)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2138
+ self.vfrStatementGrayOutIfStatNew()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def vfrStatementConditional(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
+
+
+ def vfrStatementLabel(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def vfrStatementInvalid(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatList" ):
+ return visitor.visitVfrStatementStatList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatList(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatListContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 254, self.RULE_vfrStatementStatList)
+ try:
+ self.state = 2146
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text, VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2140
+ self.vfrStatementStat()
+ pass
+ elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.OrderedList, VfrSyntaxParser.Date, VfrSyntaxParser.Time, VfrSyntaxParser.CheckBox, VfrSyntaxParser.Numeric, VfrSyntaxParser.Password, VfrSyntaxParser.String, VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2141
+ self.vfrStatementQuestions()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf, VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2142
+ self.vfrStatementConditional()
+ pass
+ elif token in [VfrSyntaxParser.Label]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2143
+ self.vfrStatementLabel()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2144
+ self.vfrStatementExtension()
+ pass
+ elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden, VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2145
+ self.vfrStatementInvalid()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatListOldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def vfrStatementLabel(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
+
+
+ def vfrStatementInvalid(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatListOld
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatListOld" ):
+ return visitor.visitVfrStatementStatListOld(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatListOld(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatListOldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 256, self.RULE_vfrStatementStatListOld)
+ try:
+ self.state = 2152
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text, VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2148
+ self.vfrStatementStat()
+ pass
+ elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.OrderedList, VfrSyntaxParser.Date, VfrSyntaxParser.Time, VfrSyntaxParser.CheckBox, VfrSyntaxParser.Numeric, VfrSyntaxParser.Password, VfrSyntaxParser.String, VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2149
+ self.vfrStatementQuestions()
+ pass
+ elif token in [VfrSyntaxParser.Label]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2150
+ self.vfrStatementLabel()
+ pass
+ elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden, VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2151
+ self.vfrStatementInvalid()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDisableIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_DISABLE_IF_OP)
+
+ def DisableIf(self):
+ return self.getToken(VfrSyntaxParser.DisableIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def vfrStatementStatList(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDisableIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDisableIfStat" ):
+ return visitor.visitVfrStatementDisableIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDisableIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDisableIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 258, self.RULE_vfrStatementDisableIfStat)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2154
+ self.match(VfrSyntaxParser.DisableIf)
+ self.state = 2155
+ self.vfrStatementExpression()
+ self.state = 2156
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 2160
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 46)) & ~0x3f) == 0 and ((1 << (_la - 46)) & ((1 << (VfrSyntaxParser.OneOf - 46)) | (1 << (VfrSyntaxParser.OrderedList - 46)) | (1 << (VfrSyntaxParser.Subtitle - 46)) | (1 << (VfrSyntaxParser.Text - 46)) | (1 << (VfrSyntaxParser.Date - 46)) | (1 << (VfrSyntaxParser.Time - 46)) | (1 << (VfrSyntaxParser.GrayOutIf - 46)) | (1 << (VfrSyntaxParser.Label - 46)) | (1 << (VfrSyntaxParser.Inventory - 46)) | (1 << (VfrSyntaxParser.CheckBox - 46)) | (1 << (VfrSyntaxParser.Numeric - 46)) | (1 << (VfrSyntaxParser.Password - 46)) | (1 << (VfrSyntaxParser.String - 46)) | (1 << (VfrSyntaxParser.SuppressIf - 46)) | (1 << (VfrSyntaxParser.DisableIf - 46)) | (1 << (VfrSyntaxParser.Hidden - 46)) | (1 << (VfrSyntaxParser.Goto - 46)))) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (VfrSyntaxParser.InconsistentIf - 110)) | (1 << (VfrSyntaxParser.Restore - 110)) | (1 << (VfrSyntaxParser.Save - 110)) | (1 << (VfrSyntaxParser.ResetButton - 110)) | (1 << (VfrSyntaxParser.Action - 110)) | (1 << (VfrSyntaxParser.GuidOp - 110)))) != 0):
+ self.state = 2157
+ self.vfrStatementStatList()
+ self.state = 2162
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2163
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2164
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementgrayoutIfSuppressIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementgrayoutIfSuppressIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementgrayoutIfSuppressIf" ):
+ return visitor.visitVfrStatementgrayoutIfSuppressIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementgrayoutIfSuppressIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementgrayoutIfSuppressIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 260, self.RULE_vfrStatementgrayoutIfSuppressIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2166
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 2179
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2167
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2168
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2169
+ self.flagsField()
+ self.state = 2174
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2170
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2171
+ self.flagsField()
+ self.state = 2176
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2177
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2181
+ self.vfrStatementExpression()
+ self.state = 2182
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementsuppressIfGrayOutIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def GrayOutIf(self):
+ return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementsuppressIfGrayOutIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementsuppressIfGrayOutIf" ):
+ return visitor.visitVfrStatementsuppressIfGrayOutIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementsuppressIfGrayOutIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementsuppressIfGrayOutIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 262, self.RULE_vfrStatementsuppressIfGrayOutIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2184
+ self.match(VfrSyntaxParser.GrayOutIf)
+ self.state = 2197
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2185
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2186
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2187
+ self.flagsField()
+ self.state = 2192
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2188
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2189
+ self.flagsField()
+ self.state = 2194
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2195
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2199
+ self.vfrStatementExpression()
+ self.state = 2200
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfStatNewContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementStatList(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfStatNew
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfStatNew" ):
+ return visitor.visitVfrStatementSuppressIfStatNew(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfStatNew(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfStatNewContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 264, self.RULE_vfrStatementSuppressIfStatNew)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2202
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 2215
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2203
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2204
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2205
+ self.flagsField()
+ self.state = 2210
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2206
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2207
+ self.flagsField()
+ self.state = 2212
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2213
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2217
+ self.vfrStatementExpression()
+ self.state = 2218
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 2222
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 46)) & ~0x3f) == 0 and ((1 << (_la - 46)) & ((1 << (VfrSyntaxParser.OneOf - 46)) | (1 << (VfrSyntaxParser.OrderedList - 46)) | (1 << (VfrSyntaxParser.Subtitle - 46)) | (1 << (VfrSyntaxParser.Text - 46)) | (1 << (VfrSyntaxParser.Date - 46)) | (1 << (VfrSyntaxParser.Time - 46)) | (1 << (VfrSyntaxParser.GrayOutIf - 46)) | (1 << (VfrSyntaxParser.Label - 46)) | (1 << (VfrSyntaxParser.Inventory - 46)) | (1 << (VfrSyntaxParser.CheckBox - 46)) | (1 << (VfrSyntaxParser.Numeric - 46)) | (1 << (VfrSyntaxParser.Password - 46)) | (1 << (VfrSyntaxParser.String - 46)) | (1 << (VfrSyntaxParser.SuppressIf - 46)) | (1 << (VfrSyntaxParser.DisableIf - 46)) | (1 << (VfrSyntaxParser.Hidden - 46)) | (1 << (VfrSyntaxParser.Goto - 46)))) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (VfrSyntaxParser.InconsistentIf - 110)) | (1 << (VfrSyntaxParser.Restore - 110)) | (1 << (VfrSyntaxParser.Save - 110)) | (1 << (VfrSyntaxParser.ResetButton - 110)) | (1 << (VfrSyntaxParser.Action - 110)) | (1 << (VfrSyntaxParser.GuidOp - 110)))) != 0):
+ self.state = 2219
+ self.vfrStatementStatList()
+ self.state = 2224
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2225
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2226
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGrayOutIfStatNewContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)
+
+ def GrayOutIf(self):
+ return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementStatList(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStatNew
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGrayOutIfStatNew" ):
+ return visitor.visitVfrStatementGrayOutIfStatNew(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGrayOutIfStatNew(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 266, self.RULE_vfrStatementGrayOutIfStatNew)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2228
+ self.match(VfrSyntaxParser.GrayOutIf)
+ self.state = 2241
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2229
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2230
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2231
+ self.flagsField()
+ self.state = 2236
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2232
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2233
+ self.flagsField()
+ self.state = 2238
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2239
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2243
+ self.vfrStatementExpression()
+ self.state = 2244
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 2248
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while ((((_la - 46)) & ~0x3f) == 0 and ((1 << (_la - 46)) & ((1 << (VfrSyntaxParser.OneOf - 46)) | (1 << (VfrSyntaxParser.OrderedList - 46)) | (1 << (VfrSyntaxParser.Subtitle - 46)) | (1 << (VfrSyntaxParser.Text - 46)) | (1 << (VfrSyntaxParser.Date - 46)) | (1 << (VfrSyntaxParser.Time - 46)) | (1 << (VfrSyntaxParser.GrayOutIf - 46)) | (1 << (VfrSyntaxParser.Label - 46)) | (1 << (VfrSyntaxParser.Inventory - 46)) | (1 << (VfrSyntaxParser.CheckBox - 46)) | (1 << (VfrSyntaxParser.Numeric - 46)) | (1 << (VfrSyntaxParser.Password - 46)) | (1 << (VfrSyntaxParser.String - 46)) | (1 << (VfrSyntaxParser.SuppressIf - 46)) | (1 << (VfrSyntaxParser.DisableIf - 46)) | (1 << (VfrSyntaxParser.Hidden - 46)) | (1 << (VfrSyntaxParser.Goto - 46)))) != 0) or ((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & ((1 << (VfrSyntaxParser.InconsistentIf - 110)) | (1 << (VfrSyntaxParser.Restore - 110)) | (1 << (VfrSyntaxParser.Save - 110)) | (1 << (VfrSyntaxParser.ResetButton - 110)) | (1 << (VfrSyntaxParser.Action - 110)) | (1 << (VfrSyntaxParser.GuidOp - 110)))) != 0):
+ self.state = 2245
+ self.vfrStatementStatList()
+ self.state = 2250
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2251
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2252
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInconsistentIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
+
+ def InconsistentIf(self):
+ return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInconsistentIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInconsistentIfStat" ):
+ return visitor.visitVfrStatementInconsistentIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInconsistentIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInconsistentIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 268, self.RULE_vfrStatementInconsistentIfStat)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2254
+ self.match(VfrSyntaxParser.InconsistentIf)
+ self.state = 2255
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2256
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2257
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2258
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2259
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2260
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2261
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2274
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2262
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2263
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2264
+ self.flagsField()
+ self.state = 2269
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2265
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2266
+ self.flagsField()
+ self.state = 2271
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2272
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2276
+ self.vfrStatementExpression()
+ self.state = 2277
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2278
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def vfrStatementInvalidHidden(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidHiddenContext,0)
+
+
+ def vfrStatementInvalidInventory(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidInventoryContext,0)
+
+
+ def vfrStatementInvalidSaveRestoreDefaults(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalid
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalid" ):
+ return visitor.visitVfrStatementInvalid(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalid(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 270, self.RULE_vfrStatementInvalid)
+ try:
+ self.state = 2283
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Hidden]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2280
+ self.vfrStatementInvalidHidden()
+ pass
+ elif token in [VfrSyntaxParser.Inventory]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2281
+ self.vfrStatementInvalidInventory()
+ pass
+ elif token in [VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2282
+ self.vfrStatementInvalidSaveRestoreDefaults()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidHiddenContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Hidden(self):
+ return self.getToken(VfrSyntaxParser.Hidden, 0)
+
+ def Value(self):
+ return self.getToken(VfrSyntaxParser.Value, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalidHidden
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalidHidden" ):
+ return visitor.visitVfrStatementInvalidHidden(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalidHidden(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidHiddenContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 272, self.RULE_vfrStatementInvalidHidden)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2285
+ self.match(VfrSyntaxParser.Hidden)
+ self.state = 2286
+ self.match(VfrSyntaxParser.Value)
+ self.state = 2287
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2288
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2289
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2290
+ self.match(VfrSyntaxParser.Key)
+ self.state = 2291
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2292
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2293
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidInventoryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Inventory(self):
+ return self.getToken(VfrSyntaxParser.Inventory, 0)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Text(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Text)
+ else:
+ return self.getToken(VfrSyntaxParser.Text, i)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalidInventory
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalidInventory" ):
+ return visitor.visitVfrStatementInvalidInventory(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalidInventory(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidInventoryContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 274, self.RULE_vfrStatementInvalidInventory)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2295
+ self.match(VfrSyntaxParser.Inventory)
+ self.state = 2296
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2297
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2298
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2299
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2300
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2301
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2302
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2303
+ self.match(VfrSyntaxParser.Text)
+ self.state = 2304
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2305
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2306
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2307
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2308
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2309
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2316
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Text:
+ self.state = 2310
+ self.match(VfrSyntaxParser.Text)
+ self.state = 2311
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2312
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2313
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2314
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2315
+ self.match(VfrSyntaxParser.CloseParen)
+
+
+ self.state = 2318
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidSaveRestoreDefaultsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Defaults(self):
+ return self.getToken(VfrSyntaxParser.Defaults, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Save(self):
+ return self.getToken(VfrSyntaxParser.Save, 0)
+
+ def Restore(self):
+ return self.getToken(VfrSyntaxParser.Restore, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalidSaveRestoreDefaults
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalidSaveRestoreDefaults" ):
+ return visitor.visitVfrStatementInvalidSaveRestoreDefaults(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalidSaveRestoreDefaults(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 276, self.RULE_vfrStatementInvalidSaveRestoreDefaults)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2320
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.Restore or _la==VfrSyntaxParser.Save):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ self.state = 2321
+ self.match(VfrSyntaxParser.Defaults)
+ self.state = 2322
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2323
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 2324
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2325
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2326
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2327
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2328
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2329
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2330
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2331
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2332
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2333
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2334
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2335
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2336
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2337
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2338
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2339
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2351
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
+ if la_ == 1:
+ self.state = 2340
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2341
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2342
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2343
+ self.flagsField()
+ self.state = 2348
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2344
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2345
+ self.flagsField()
+ self.state = 2350
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+
+
+ self.state = 2357
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 2353
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2354
+ self.match(VfrSyntaxParser.Key)
+ self.state = 2355
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2356
+ self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 2359
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementLabelContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_GUID_OP)
+
+ def Label(self):
+ return self.getToken(VfrSyntaxParser.Label, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementLabel
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementLabel" ):
+ return visitor.visitVfrStatementLabel(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementLabel(self):
+
+ localctx = VfrSyntaxParser.VfrStatementLabelContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 278, self.RULE_vfrStatementLabel)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2361
+ self.match(VfrSyntaxParser.Label)
+ self.state = 2362
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2363
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementBannerContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_GUID_OP)
+
+ def Banner(self):
+ return self.getToken(VfrSyntaxParser.Banner, 0)
+
+ def Title(self):
+ return self.getToken(VfrSyntaxParser.Title, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Line(self):
+ return self.getToken(VfrSyntaxParser.Line, 0)
+
+ def Align(self):
+ return self.getToken(VfrSyntaxParser.Align, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Timeout(self):
+ return self.getToken(VfrSyntaxParser.Timeout, 0)
+
+ def Left(self):
+ return self.getToken(VfrSyntaxParser.Left, 0)
+
+ def Center(self):
+ return self.getToken(VfrSyntaxParser.Center, 0)
+
+ def Right(self):
+ return self.getToken(VfrSyntaxParser.Right, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementBanner
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementBanner" ):
+ return visitor.visitVfrStatementBanner(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementBanner(self):
+
+ localctx = VfrSyntaxParser.VfrStatementBannerContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 280, self.RULE_vfrStatementBanner)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2365
+ self.match(VfrSyntaxParser.Banner)
+ self.state = 2367
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 2366
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2369
+ self.match(VfrSyntaxParser.Title)
+ self.state = 2370
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2371
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2372
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2373
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2374
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2375
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2386
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Line]:
+ self.state = 2376
+ self.match(VfrSyntaxParser.Line)
+ self.state = 2377
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2378
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2379
+ self.match(VfrSyntaxParser.Align)
+ self.state = 2380
+ _la = self._input.LA(1)
+ if not(((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (VfrSyntaxParser.Left - 136)) | (1 << (VfrSyntaxParser.Right - 136)) | (1 << (VfrSyntaxParser.Center - 136)))) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ self.state = 2381
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+ elif token in [VfrSyntaxParser.Timeout]:
+ self.state = 2382
+ self.match(VfrSyntaxParser.Timeout)
+ self.state = 2383
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2384
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2385
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementExtensionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_GUID_OP)
+ self.DataBuff = None
+ self.Size = 0
+ self.TypeName = ''
+ self.TypeSize = 0
+ self.IsStruct = False
+ self.ArrayNum = 0
+ self.D = None # Token
+
+ def GuidOp(self):
+ return self.getToken(VfrSyntaxParser.GuidOp, 0)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def EndGuidOp(self):
+ return self.getToken(VfrSyntaxParser.EndGuidOp, 0)
+
+ def DataType(self):
+ return self.getToken(VfrSyntaxParser.DataType, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Boolean(self):
+ return self.getToken(VfrSyntaxParser.Boolean, 0)
+
+ def EFI_STRING_ID(self):
+ return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def vfrExtensionData(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrExtensionDataContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExtensionDataContext,i)
+
+
+ def vfrStatementExtension(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExtensionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,i)
+
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementExtension
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementExtension" ):
+ return visitor.visitVfrStatementExtension(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementExtension(self):
+
+ localctx = VfrSyntaxParser.VfrStatementExtensionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 282, self.RULE_vfrStatementExtension)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2388
+ self.match(VfrSyntaxParser.GuidOp)
+ self.state = 2389
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 2390
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2391
+ self.guidDefinition()
+ self.state = 2463
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
+ if la_ == 1:
+ self.state = 2392
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2393
+ localctx.D = self.match(VfrSyntaxParser.DataType)
+ self.state = 2394
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2455
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Uint64]:
+ self.state = 2395
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 2399
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2396
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2397
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2398
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Uint32]:
+ self.state = 2401
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 2405
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2402
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2403
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2404
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Uint16]:
+ self.state = 2407
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 2411
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2408
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2409
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2410
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Uint8]:
+ self.state = 2413
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 2417
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2414
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2415
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2416
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Boolean]:
+ self.state = 2419
+ self.match(VfrSyntaxParser.Boolean)
+ self.state = 2423
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2420
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2421
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2422
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_STRING_ID]:
+ self.state = 2425
+ self.match(VfrSyntaxParser.EFI_STRING_ID)
+ self.state = 2429
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2426
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2427
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2428
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_DATE]:
+ self.state = 2431
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 2435
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2432
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2433
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2434
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_TIME]:
+ self.state = 2437
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 2441
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2438
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2439
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2440
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_REF]:
+ self.state = 2443
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 2447
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2444
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2445
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2446
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 2449
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2453
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2450
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2451
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2452
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 2460
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,196,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 2457
+ self.vfrExtensionData(localctx.DataBuff)
+ self.state = 2462
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,196,self._ctx)
+
+
+
+ self.state = 2473
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 2465
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2469
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.GuidOp:
+ self.state = 2466
+ self.vfrStatementExtension()
+ self.state = 2471
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2472
+ self.match(VfrSyntaxParser.EndGuidOp)
+
+
+ self.state = 2475
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExtensionDataContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, DataBuff=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.DataBuff = None
+ self.IsStruct = None
+ self.N = None # Token
+ self.DataBuff = DataBuff
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Data(self):
+ return self.getToken(VfrSyntaxParser.Data, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+
+ def arrayName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExtensionData
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExtensionData" ):
+ return visitor.visitVfrExtensionData(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExtensionData(self, DataBuff):
+
+ localctx = VfrSyntaxParser.VfrExtensionDataContext(self, self._ctx, self.state, DataBuff)
+ self.enterRule(localctx, 284, self.RULE_vfrExtensionData)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2477
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2478
+ self.match(VfrSyntaxParser.Data)
+ self.state = 2482
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2479
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2480
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2481
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 2488
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Dot:
+ self.state = 2484
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2485
+ self.arrayName()
+ self.state = 2490
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2491
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2492
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementModalContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrModalTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrModalTagContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementModal
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementModal" ):
+ return visitor.visitVfrStatementModal(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementModal(self):
+
+ localctx = VfrSyntaxParser.VfrStatementModalContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 286, self.RULE_vfrStatementModal)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2494
+ self.vfrModalTag()
+ self.state = 2495
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrModalTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = VfrTreeNode(EFI_IFR_MODAL_TAG_OP)
+
+ def Modal(self):
+ return self.getToken(VfrSyntaxParser.Modal, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrModalTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrModalTag" ):
+ return visitor.visitVfrModalTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrModalTag(self):
+
+ localctx = VfrSyntaxParser.VfrModalTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 288, self.RULE_vfrModalTag)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2497
+ self.match(VfrSyntaxParser.Modal)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementExpressionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = ExpressionInfo()
+
+ def andTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
+
+
+ def OR(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OR)
+ else:
+ return self.getToken(VfrSyntaxParser.OR, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementExpression
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementExpression" ):
+ return visitor.visitVfrStatementExpression(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementExpression(self):
+
+ localctx = VfrSyntaxParser.VfrStatementExpressionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 290, self.RULE_vfrStatementExpression)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2499
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2504
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.OR:
+ self.state = 2500
+ self.match(VfrSyntaxParser.OR)
+ self.state = 2501
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2506
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementExpressionSubContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = ExpressionInfo()
+
+ def andTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
+
+
+ def OR(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OR)
+ else:
+ return self.getToken(VfrSyntaxParser.OR, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementExpressionSub
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementExpressionSub" ):
+ return visitor.visitVfrStatementExpressionSub(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementExpressionSub(self):
+
+ localctx = VfrSyntaxParser.VfrStatementExpressionSubContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 292, self.RULE_vfrStatementExpressionSub)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2507
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2512
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.OR:
+ self.state = 2508
+ self.match(VfrSyntaxParser.OR)
+ self.state = 2509
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2514
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AndTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrAndList = []
+ self.ExpInfo = ExpInfo
+
+ def bitwiseorTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.BitwiseorTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.BitwiseorTermContext,i)
+
+
+ def AND(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.AND)
+ else:
+ return self.getToken(VfrSyntaxParser.AND, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_andTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAndTerm" ):
+ return visitor.visitAndTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def andTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AndTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 294, self.RULE_andTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2515
+ self.bitwiseorTerm(ExpInfo)
+ self.state = 2520
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.AND:
+ self.state = 2516
+ self.match(VfrSyntaxParser.AND)
+ self.state = 2517
+ self.bitwiseorTerm(ExpInfo)
+ self.state = 2522
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class BitwiseorTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrBitWiseOrList = []
+ self.ExpInfo = ExpInfo
+
+ def bitwiseandTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.BitwiseandTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.BitwiseandTermContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_bitwiseorTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitBitwiseorTerm" ):
+ return visitor.visitBitwiseorTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def bitwiseorTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.BitwiseorTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 296, self.RULE_bitwiseorTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2523
+ self.bitwiseandTerm(ExpInfo)
+ self.state = 2528
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2524
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2525
+ self.bitwiseandTerm(ExpInfo)
+ self.state = 2530
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class BitwiseandTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrBitWiseAndList = []
+ self.ExpInfo = ExpInfo
+
+ def equalTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.EqualTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.EqualTermContext,i)
+
+
+ def BitWiseAnd(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseAnd)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseAnd, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_bitwiseandTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitBitwiseandTerm" ):
+ return visitor.visitBitwiseandTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def bitwiseandTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.BitwiseandTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 298, self.RULE_bitwiseandTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2531
+ self.equalTerm(ExpInfo)
+ self.state = 2536
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseAnd:
+ self.state = 2532
+ self.match(VfrSyntaxParser.BitWiseAnd)
+ self.state = 2533
+ self.equalTerm(ExpInfo)
+ self.state = 2538
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class EqualTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrEqualList = []
+ self.CIfrNotEqualList = []
+ self.ExpInfo = ExpInfo
+
+ def compareTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
+
+
+ def equalTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.EqualTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.EqualTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_equalTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEqualTerm" ):
+ return visitor.visitEqualTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def equalTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.EqualTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 300, self.RULE_equalTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2539
+ self.compareTerm(localctx.ExpInfo)
+ self.state = 2543
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Equal or _la==VfrSyntaxParser.NotEqual:
+ self.state = 2540
+ self.equalTermSupplementary(localctx.CIfrEqualList, localctx.CIfrNotEqualList, ExpInfo)
+ self.state = 2545
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class EqualTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, CIfrEqualList=None, CIfrNotEqualList=None, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.CIfrEqualList = None
+ self.CIfrNotEqualList = None
+ self.ExpInfo = None
+ self.CIfrEqualList = CIfrEqualList
+ self.CIfrNotEqualList = CIfrNotEqualList
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_equalTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.CIfrEqualList = ctx.CIfrEqualList
+ self.CIfrNotEqualList = ctx.CIfrNotEqualList
+ self.ExpInfo = ctx.ExpInfo
+
+
+
+ class EqualTermEqualRuleContext(EqualTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.EqualTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+ def compareTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEqualTermEqualRule" ):
+ return visitor.visitEqualTermEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class EqualTermNotEqualRuleContext(EqualTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.EqualTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def NotEqual(self):
+ return self.getToken(VfrSyntaxParser.NotEqual, 0)
+ def compareTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEqualTermNotEqualRule" ):
+ return visitor.visitEqualTermNotEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def equalTermSupplementary(self, CIfrEqualList, CIfrNotEqualList, ExpInfo):
+
+ localctx = VfrSyntaxParser.EqualTermSupplementaryContext(self, self._ctx, self.state, CIfrEqualList, CIfrNotEqualList, ExpInfo)
+ self.enterRule(localctx, 302, self.RULE_equalTermSupplementary)
+ try:
+ self.state = 2550
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ localctx = VfrSyntaxParser.EqualTermEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2546
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2547
+ self.compareTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.NotEqual]:
+ localctx = VfrSyntaxParser.EqualTermNotEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2548
+ self.match(VfrSyntaxParser.NotEqual)
+ self.state = 2549
+ self.compareTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CompareTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrLessThanList = []
+ self.CIfrLessEqualList = []
+ self.CIfrGreaterThanList = []
+ self.CIfrGreaterEqualList = []
+ self.ExpInfo = ExpInfo
+
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def compareTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.CompareTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_compareTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTerm" ):
+ return visitor.visitCompareTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def compareTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.CompareTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 304, self.RULE_compareTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2552
+ self.shiftTerm(ExpInfo)
+ self.state = 2556
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << VfrSyntaxParser.LessEqual) | (1 << VfrSyntaxParser.Less) | (1 << VfrSyntaxParser.GreaterEqual) | (1 << VfrSyntaxParser.Greater))) != 0):
+ self.state = 2553
+ self.compareTermSupplementary(localctx.CIfrLessThanList, localctx.CIfrLessEqualList, localctx.CIfrGreaterThanList, localctx.CIfrGreaterEqualList, ExpInfo)
+ self.state = 2558
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CompareTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, CIfrLessThanList=None, CIfrLessEqualList=None, CIfrGreaterThanList=None, CIfrGreaterEqualList=None, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.CIfrLessThanList = None
+ self.CIfrLessEqualList = None
+ self.CIfrGreaterThanList = None
+ self.CIfrGreaterEqualList = None
+ self.ExpInfo = None
+ self.CIfrLessThanList = CIfrLessThanList
+ self.CIfrLessEqualList = CIfrLessEqualList
+ self.CIfrGreaterThanList = CIfrGreaterThanList
+ self.CIfrGreaterEqualList = CIfrGreaterEqualList
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_compareTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.CIfrLessThanList = ctx.CIfrLessThanList
+ self.CIfrLessEqualList = ctx.CIfrLessEqualList
+ self.CIfrGreaterThanList = ctx.CIfrGreaterThanList
+ self.CIfrGreaterEqualList = ctx.CIfrGreaterEqualList
+ self.ExpInfo = ctx.ExpInfo
+
+
+
+ class CompareTermLessRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermLessRule" ):
+ return visitor.visitCompareTermLessRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class CompareTermGreaterEqualRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermGreaterEqualRule" ):
+ return visitor.visitCompareTermGreaterEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class CompareTermGreaterRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermGreaterRule" ):
+ return visitor.visitCompareTermGreaterRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class CompareTermLessEqualRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermLessEqualRule" ):
+ return visitor.visitCompareTermLessEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def compareTermSupplementary(self, CIfrLessThanList, CIfrLessEqualList, CIfrGreaterThanList, CIfrGreaterEqualList, ExpInfo):
+
+ localctx = VfrSyntaxParser.CompareTermSupplementaryContext(self, self._ctx, self.state, CIfrLessThanList, CIfrLessEqualList, CIfrGreaterThanList, CIfrGreaterEqualList, ExpInfo)
+ self.enterRule(localctx, 306, self.RULE_compareTermSupplementary)
+ try:
+ self.state = 2567
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Less]:
+ localctx = VfrSyntaxParser.CompareTermLessRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2559
+ self.match(VfrSyntaxParser.Less)
+ self.state = 2560
+ self.shiftTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ localctx = VfrSyntaxParser.CompareTermLessEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2561
+ self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2562
+ self.shiftTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ localctx = VfrSyntaxParser.CompareTermGreaterRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2563
+ self.match(VfrSyntaxParser.Greater)
+ self.state = 2564
+ self.shiftTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ localctx = VfrSyntaxParser.CompareTermGreaterEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2565
+ self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2566
+ self.shiftTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ShiftTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrShiftLeftList = []
+ self.CIfrShiftRightList = []
+ self.ExpInfo = ExpInfo
+
+ def addMinusTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
+
+
+ def shiftTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ShiftTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_shiftTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShiftTerm" ):
+ return visitor.visitShiftTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def shiftTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ShiftTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 308, self.RULE_shiftTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2569
+ self.addMinusTerm(ExpInfo)
+ self.state = 2573
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.T__9 or _la==VfrSyntaxParser.T__10:
+ self.state = 2570
+ self.shiftTermSupplementary(localctx.CIfrShiftLeftList, localctx.CIfrShiftRightList, ExpInfo)
+ self.state = 2575
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ShiftTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, CIfrShiftLeftList=None, CIfrShiftRightList=None, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.CIfrShiftLeftList = None
+ self.CIfrShiftRightList = None
+ self.ExpInfo = None
+ self.CIfrShiftLeftList = CIfrShiftLeftList
+ self.CIfrShiftRightList = CIfrShiftRightList
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_shiftTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.CIfrShiftLeftList = ctx.CIfrShiftLeftList
+ self.CIfrShiftRightList = ctx.CIfrShiftRightList
+ self.ExpInfo = ctx.ExpInfo
+
+
+
+ class ShiftTermRightContext(ShiftTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.ShiftTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def addMinusTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShiftTermRight" ):
+ return visitor.visitShiftTermRight(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class ShiftTermLeftContext(ShiftTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.ShiftTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def addMinusTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShiftTermLeft" ):
+ return visitor.visitShiftTermLeft(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def shiftTermSupplementary(self, CIfrShiftLeftList, CIfrShiftRightList, ExpInfo):
+
+ localctx = VfrSyntaxParser.ShiftTermSupplementaryContext(self, self._ctx, self.state, CIfrShiftLeftList, CIfrShiftRightList, ExpInfo)
+ self.enterRule(localctx, 310, self.RULE_shiftTermSupplementary)
+ try:
+ self.state = 2580
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.T__9]:
+ localctx = VfrSyntaxParser.ShiftTermLeftContext(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2576
+ self.match(VfrSyntaxParser.T__9)
+ self.state = 2577
+ self.addMinusTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.T__10]:
+ localctx = VfrSyntaxParser.ShiftTermRightContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2578
+ self.match(VfrSyntaxParser.T__10)
+ self.state = 2579
+ self.addMinusTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AddMinusTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrAddList = []
+ self.CIfrSubtractList = []
+ self.ExpInfo = ExpInfo
+
+ def multdivmodTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
+
+
+ def addMinusTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.AddMinusTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_addMinusTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAddMinusTerm" ):
+ return visitor.visitAddMinusTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def addMinusTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AddMinusTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 312, self.RULE_addMinusTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2582
+ self.multdivmodTerm(ExpInfo)
+ self.state = 2586
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.T__11 or _la==VfrSyntaxParser.Negative:
+ self.state = 2583
+ self.addMinusTermSupplementary(localctx.CIfrAddList, localctx.CIfrSubtractList, ExpInfo)
+ self.state = 2588
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AddMinusTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, CIfrAddList=None, CIfrSubtractList=None, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.CIfrAddList = None
+ self.CIfrSubtractList = None
+ self.ExpInfo = None
+ self.CIfrAddList = CIfrAddList
+ self.CIfrSubtractList = CIfrSubtractList
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_addMinusTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.CIfrAddList = ctx.CIfrAddList
+ self.CIfrSubtractList = ctx.CIfrSubtractList
+ self.ExpInfo = ctx.ExpInfo
+
+
+
+ class AddMinusTermpAddContext(AddMinusTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.AddMinusTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def multdivmodTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAddMinusTermpAdd" ):
+ return visitor.visitAddMinusTermpAdd(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class AddMinusTermSubtractContext(AddMinusTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.AddMinusTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Negative(self):
+ return self.getToken(VfrSyntaxParser.Negative, 0)
+ def multdivmodTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAddMinusTermSubtract" ):
+ return visitor.visitAddMinusTermSubtract(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def addMinusTermSupplementary(self, CIfrAddList, CIfrSubtractList, ExpInfo):
+
+ localctx = VfrSyntaxParser.AddMinusTermSupplementaryContext(self, self._ctx, self.state, CIfrAddList, CIfrSubtractList, ExpInfo)
+ self.enterRule(localctx, 314, self.RULE_addMinusTermSupplementary)
+ try:
+ self.state = 2593
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.T__11]:
+ localctx = VfrSyntaxParser.AddMinusTermpAddContext(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2589
+ self.match(VfrSyntaxParser.T__11)
+ self.state = 2590
+ self.multdivmodTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Negative]:
+ localctx = VfrSyntaxParser.AddMinusTermSubtractContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2591
+ self.match(VfrSyntaxParser.Negative)
+ self.state = 2592
+ self.multdivmodTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MultdivmodTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CIfrMultiplyList = []
+ self.CIfrDivideList = []
+ self.CIfrModuloList = []
+ self.ExpInfo = ExpInfo
+
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def multdivmodTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.MultdivmodTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_multdivmodTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTerm" ):
+ return visitor.visitMultdivmodTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def multdivmodTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.MultdivmodTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 316, self.RULE_multdivmodTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2595
+ self.castTerm(ExpInfo)
+ self.state = 2599
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << VfrSyntaxParser.T__12) | (1 << VfrSyntaxParser.T__13) | (1 << VfrSyntaxParser.Slash))) != 0):
+ self.state = 2596
+ self.multdivmodTermSupplementary(localctx.CIfrMultiplyList, localctx.CIfrDivideList, localctx.CIfrModuloList, ExpInfo)
+ self.state = 2601
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MultdivmodTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, CIfrMultiplyList=None, CIfrDivideList=None, CIfrModuloList=None, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.CIfrMultiplyList = None
+ self.CIfrDivideList = None
+ self.CIfrModuloList = None
+ self.ExpInfo = None
+ self.CIfrMultiplyList = CIfrMultiplyList
+ self.CIfrDivideList = CIfrDivideList
+ self.CIfrModuloList = CIfrModuloList
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_multdivmodTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.CIfrMultiplyList = ctx.CIfrMultiplyList
+ self.CIfrDivideList = ctx.CIfrDivideList
+ self.CIfrModuloList = ctx.CIfrModuloList
+ self.ExpInfo = ctx.ExpInfo
+
+
+
+ class MultdivmodTermDivContext(MultdivmodTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.MultdivmodTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Slash(self):
+ return self.getToken(VfrSyntaxParser.Slash, 0)
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTermDiv" ):
+ return visitor.visitMultdivmodTermDiv(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class MultdivmodTermMulContext(MultdivmodTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.MultdivmodTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTermMul" ):
+ return visitor.visitMultdivmodTermMul(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class MultdivmodTermModuloContext(MultdivmodTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.MultdivmodTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTermModulo" ):
+ return visitor.visitMultdivmodTermModulo(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def multdivmodTermSupplementary(self, CIfrMultiplyList, CIfrDivideList, CIfrModuloList, ExpInfo):
+
+ localctx = VfrSyntaxParser.MultdivmodTermSupplementaryContext(self, self._ctx, self.state, CIfrMultiplyList, CIfrDivideList, CIfrModuloList, ExpInfo)
+ self.enterRule(localctx, 318, self.RULE_multdivmodTermSupplementary)
+ try:
+ self.state = 2608
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.T__12]:
+ localctx = VfrSyntaxParser.MultdivmodTermMulContext(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2602
+ self.match(VfrSyntaxParser.T__12)
+ self.state = 2603
+ self.castTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Slash]:
+ localctx = VfrSyntaxParser.MultdivmodTermDivContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2604
+ self.match(VfrSyntaxParser.Slash)
+ self.state = 2605
+ self.castTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.T__13]:
+ localctx = VfrSyntaxParser.MultdivmodTermModuloContext(self, localctx)
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2606
+ self.match(VfrSyntaxParser.T__13)
+ self.state = 2607
+ self.castTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CastTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TBObj = None
+ self.TUObj = None
+ self.ExpInfo = ExpInfo
+
+ def atomTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
+
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Boolean(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Boolean)
+ else:
+ return self.getToken(VfrSyntaxParser.Boolean, i)
+
+ def Uint64(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Uint64)
+ else:
+ return self.getToken(VfrSyntaxParser.Uint64, i)
+
+ def Uint32(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Uint32)
+ else:
+ return self.getToken(VfrSyntaxParser.Uint32, i)
+
+ def Uint16(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Uint16)
+ else:
+ return self.getToken(VfrSyntaxParser.Uint16, i)
+
+ def Uint8(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Uint8)
+ else:
+ return self.getToken(VfrSyntaxParser.Uint8, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_castTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCastTerm" ):
+ return visitor.visitCastTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def castTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.CastTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 320, self.RULE_castTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2615
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,217,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 2610
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2611
+ _la = self._input.LA(1)
+ if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (VfrSyntaxParser.Boolean - 80)) | (1 << (VfrSyntaxParser.Uint64 - 80)) | (1 << (VfrSyntaxParser.Uint32 - 80)) | (1 << (VfrSyntaxParser.Uint16 - 80)) | (1 << (VfrSyntaxParser.Uint8 - 80)))) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ self.state = 2612
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2617
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,217,self._ctx)
+
+ self.state = 2618
+ self.atomTerm(ExpInfo)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AtomTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def vfrExpressionCatenate(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionCatenateContext,0)
+
+
+ def vfrExpressionMatch(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatchContext,0)
+
+
+ def vfrExpressionMatch2(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatch2Context,0)
+
+
+ def vfrExpressionParen(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionParenContext,0)
+
+
+ def vfrExpressionBuildInFunction(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionBuildInFunctionContext,0)
+
+
+ def vfrExpressionConstant(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionConstantContext,0)
+
+
+ def vfrExpressionUnaryOp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionUnaryOpContext,0)
+
+
+ def vfrExpressionTernaryOp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionTernaryOpContext,0)
+
+
+ def vfrExpressionMap(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMapContext,0)
+
+
+ def NOT(self):
+ return self.getToken(VfrSyntaxParser.NOT, 0)
+
+ def atomTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_atomTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAtomTerm" ):
+ return visitor.visitAtomTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def atomTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AtomTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 322, self.RULE_atomTerm)
+ try:
+ self.state = 2632
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,218,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2620
+ self.vfrExpressionCatenate(ExpInfo)
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2621
+ self.vfrExpressionMatch(ExpInfo)
+ pass
+
+ elif la_ == 3:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2622
+ self.vfrExpressionMatch2(ExpInfo)
+ pass
+
+ elif la_ == 4:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2623
+ self.vfrExpressionParen(ExpInfo)
+ pass
+
+ elif la_ == 5:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2624
+ self.vfrExpressionBuildInFunction(ExpInfo)
+ pass
+
+ elif la_ == 6:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2625
+ self.vfrExpressionConstant(ExpInfo)
+ pass
+
+ elif la_ == 7:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 2626
+ self.vfrExpressionUnaryOp(ExpInfo)
+ pass
+
+ elif la_ == 8:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 2627
+ self.vfrExpressionTernaryOp(ExpInfo)
+ pass
+
+ elif la_ == 9:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 2628
+ self.vfrExpressionMap(ExpInfo)
+ pass
+
+ elif la_ == 10:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 2629
+ self.match(VfrSyntaxParser.NOT)
+ self.state = 2630
+ self.atomTerm(ExpInfo)
+ pass
+
+ elif la_ == 11:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 2631
+ self.vfrExpressionMatch2(ExpInfo)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionCatenateContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CObj = None
+ self.ExpInfo = ExpInfo
+
+ def Catenate(self):
+ return self.getToken(VfrSyntaxParser.Catenate, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionCatenate
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionCatenate" ):
+ return visitor.visitVfrExpressionCatenate(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionCatenate(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionCatenateContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 324, self.RULE_vfrExpressionCatenate)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2634
+ self.match(VfrSyntaxParser.Catenate)
+ self.state = 2635
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2636
+ self.vfrStatementExpressionSub()
+ self.state = 2637
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2638
+ self.vfrStatementExpressionSub()
+ self.state = 2639
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionMatchContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.MObj = None
+ self.ExpInfo = ExpInfo
+
+ def Match(self):
+ return self.getToken(VfrSyntaxParser.Match, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionMatch
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionMatch" ):
+ return visitor.visitVfrExpressionMatch(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionMatch(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionMatchContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 326, self.RULE_vfrExpressionMatch)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2641
+ self.match(VfrSyntaxParser.Match)
+ self.state = 2642
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2643
+ self.vfrStatementExpressionSub()
+ self.state = 2644
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2645
+ self.vfrStatementExpressionSub()
+ self.state = 2646
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionMatch2Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.M2Obj = None
+ self.ExpInfo = ExpInfo
+
+ def Match2(self):
+ return self.getToken(VfrSyntaxParser.Match2, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionMatch2
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionMatch2" ):
+ return visitor.visitVfrExpressionMatch2(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionMatch2(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionMatch2Context(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 328, self.RULE_vfrExpressionMatch2)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2648
+ self.match(VfrSyntaxParser.Match2)
+ self.state = 2649
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2650
+ self.vfrStatementExpressionSub()
+ self.state = 2651
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2652
+ self.vfrStatementExpressionSub()
+ self.state = 2653
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2654
+ self.guidDefinition()
+ self.state = 2655
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionParenContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionParen
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionParen" ):
+ return visitor.visitVfrExpressionParen(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionParen(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionParenContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 330, self.RULE_vfrExpressionParen)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2657
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2658
+ self.vfrStatementExpressionSub()
+ self.state = 2659
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionBuildInFunctionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def dupExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.DupExpContext,0)
+
+
+ def vareqvalExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VareqvalExpContext,0)
+
+
+ def ideqvalExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.IdeqvalExpContext,0)
+
+
+ def ideqidExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.IdeqidExpContext,0)
+
+
+ def ideqvallistExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.IdeqvallistExpContext,0)
+
+
+ def questionref1Exp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Questionref1ExpContext,0)
+
+
+ def rulerefExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.RulerefExpContext,0)
+
+
+ def stringref1Exp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Stringref1ExpContext,0)
+
+
+ def pushthisExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PushthisExpContext,0)
+
+
+ def securityExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SecurityExpContext,0)
+
+
+ def getExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GetExpContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionBuildInFunction
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionBuildInFunction" ):
+ return visitor.visitVfrExpressionBuildInFunction(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionBuildInFunction(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionBuildInFunctionContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 332, self.RULE_vfrExpressionBuildInFunction)
+ try:
+ self.state = 2672
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Dup]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2661
+ self.dupExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.VarEqVal]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2662
+ self.vareqvalExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.IdEqVal]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2663
+ self.ideqvalExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.IdEqId]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2664
+ self.ideqidExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.IdEqValList]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2665
+ self.ideqvallistExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.QuestionRef]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2666
+ self.questionref1Exp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.RuleRef]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 2667
+ self.rulerefExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.StringRef]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 2668
+ self.stringref1Exp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.PushThis]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 2669
+ self.pushthisExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Security]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 2670
+ self.securityExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Get]:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 2671
+ self.getExp(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DupExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.DObj = None
+ self.ExpInfo = ExpInfo
+
+ def Dup(self):
+ return self.getToken(VfrSyntaxParser.Dup, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dupExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDupExp" ):
+ return visitor.visitDupExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dupExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.DupExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 334, self.RULE_dupExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2674
+ self.match(VfrSyntaxParser.Dup)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VareqvalExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def VarEqVal(self):
+ return self.getToken(VfrSyntaxParser.VarEqVal, 0)
+
+ def Var(self):
+ return self.getToken(VfrSyntaxParser.Var, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vareqvalExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVareqvalExp" ):
+ return visitor.visitVareqvalExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vareqvalExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VareqvalExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 336, self.RULE_vareqvalExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2676
+ self.match(VfrSyntaxParser.VarEqVal)
+ self.state = 2677
+ self.match(VfrSyntaxParser.Var)
+ self.state = 2678
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2679
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2680
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2691
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ self.state = 2681
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2682
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ self.state = 2683
+ self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2684
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Less]:
+ self.state = 2685
+ self.match(VfrSyntaxParser.Less)
+ self.state = 2686
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ self.state = 2687
+ self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2688
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ self.state = 2689
+ self.match(VfrSyntaxParser.Greater)
+ self.state = 2690
+ self.match(VfrSyntaxParser.Number)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class IdeqvalExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.I = None # Token
+ self.ExpInfo = ExpInfo
+
+ def vfrQuestionDataFieldName(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,0)
+
+
+ def IdEqVal(self):
+ return self.getToken(VfrSyntaxParser.IdEqVal, 0)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_ideqvalExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdeqvalExp" ):
+ return visitor.visitIdeqvalExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def ideqvalExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.IdeqvalExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 338, self.RULE_ideqvalExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2693
+ localctx.I = self.match(VfrSyntaxParser.IdEqVal)
+ self.state = 2694
+ self.vfrQuestionDataFieldName()
+ self.state = 2705
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ self.state = 2695
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2696
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ self.state = 2697
+ self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2698
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Less]:
+ self.state = 2699
+ self.match(VfrSyntaxParser.Less)
+ self.state = 2700
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ self.state = 2701
+ self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2702
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ self.state = 2703
+ self.match(VfrSyntaxParser.Greater)
+ self.state = 2704
+ self.match(VfrSyntaxParser.Number)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class IdeqidExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.I = None # Token
+ self.E = None # Token
+ self.LE = None # Token
+ self.L = None # Token
+ self.BE = None # Token
+ self.B = None # Token
+ self.ExpInfo = ExpInfo
+
+ def vfrQuestionDataFieldName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrQuestionDataFieldNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,i)
+
+
+ def IdEqId(self):
+ return self.getToken(VfrSyntaxParser.IdEqId, 0)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_ideqidExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdeqidExp" ):
+ return visitor.visitIdeqidExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def ideqidExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.IdeqidExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 340, self.RULE_ideqidExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2707
+ localctx.I = self.match(VfrSyntaxParser.IdEqId)
+ self.state = 2708
+ self.vfrQuestionDataFieldName()
+ self.state = 2719
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ self.state = 2709
+ localctx.E = self.match(VfrSyntaxParser.Equal)
+ self.state = 2710
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ self.state = 2711
+ localctx.LE = self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2712
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.Less]:
+ self.state = 2713
+ localctx.L = self.match(VfrSyntaxParser.Less)
+ self.state = 2714
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ self.state = 2715
+ localctx.BE = self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2716
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ self.state = 2717
+ localctx.B = self.match(VfrSyntaxParser.Greater)
+ self.state = 2718
+ self.vfrQuestionDataFieldName()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class IdeqvallistExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def IdEqValList(self):
+ return self.getToken(VfrSyntaxParser.IdEqValList, 0)
+
+ def vfrQuestionDataFieldName(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,0)
+
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_ideqvallistExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdeqvallistExp" ):
+ return visitor.visitIdeqvallistExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def ideqvallistExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.IdeqvallistExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 342, self.RULE_ideqvallistExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2721
+ self.match(VfrSyntaxParser.IdEqValList)
+ self.state = 2722
+ self.vfrQuestionDataFieldName()
+ self.state = 2723
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2725
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while True:
+ self.state = 2724
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2727
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if not (_la==VfrSyntaxParser.Number):
+ break
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrQuestionDataFieldNameContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.QId = EFI_QUESTION_ID_INVALID
+ self.Mask = 0
+ self.VarIdStr = ''
+ self.Line = None
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrQuestionDataFieldName
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.QId = ctx.QId
+ self.Mask = ctx.Mask
+ self.VarIdStr = ctx.VarIdStr
+ self.Line = ctx.Line
+
+
+
+ class VfrQuestionDataFieldNameRule2Context(VfrQuestionDataFieldNameContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrQuestionDataFieldNameContext
+ super().__init__(parser)
+ self.SN2 = None # Token
+ self.copyFrom(ctx)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+ def arrayName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionDataFieldNameRule2" ):
+ return visitor.visitVfrQuestionDataFieldNameRule2(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class VfrQuestionDataFieldNameRule1Context(VfrQuestionDataFieldNameContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrQuestionDataFieldNameContext
+ super().__init__(parser)
+ self.SN1 = None # Token
+ self.I = None # Token
+ self.copyFrom(ctx)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionDataFieldNameRule1" ):
+ return visitor.visitVfrQuestionDataFieldNameRule1(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def vfrQuestionDataFieldName(self):
+
+ localctx = VfrSyntaxParser.VfrQuestionDataFieldNameContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 344, self.RULE_vfrQuestionDataFieldName)
+ self._la = 0 # Token type
+ try:
+ self.state = 2741
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
+ if la_ == 1:
+ localctx = VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2729
+ localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2730
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2731
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 2732
+ self.match(VfrSyntaxParser.CloseBracket)
+ pass
+
+ elif la_ == 2:
+ localctx = VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2733
+ localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2738
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Dot:
+ self.state = 2734
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2735
+ self.arrayName()
+ self.state = 2740
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ArrayNameContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.SubStr = ''
+ self.SubStrZ = ''
+ self.N = None # Token
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_arrayName
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitArrayName" ):
+ return visitor.visitArrayName(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def arrayName(self):
+
+ localctx = VfrSyntaxParser.ArrayNameContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 346, self.RULE_arrayName)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2743
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2747
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2744
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2745
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 2746
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Questionref1ExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def QuestionRef(self):
+ return self.getToken(VfrSyntaxParser.QuestionRef, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_questionref1Exp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitQuestionref1Exp" ):
+ return visitor.visitQuestionref1Exp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def questionref1Exp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Questionref1ExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 348, self.RULE_questionref1Exp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2749
+ self.match(VfrSyntaxParser.QuestionRef)
+ self.state = 2750
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2751
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.Number or _la==VfrSyntaxParser.StringIdentifier):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ self.state = 2752
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class RulerefExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def RuleRef(self):
+ return self.getToken(VfrSyntaxParser.RuleRef, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_rulerefExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitRulerefExp" ):
+ return visitor.visitRulerefExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def rulerefExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.RulerefExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 350, self.RULE_rulerefExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2754
+ self.match(VfrSyntaxParser.RuleRef)
+ self.state = 2755
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2756
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2757
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Stringref1ExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def StringRef(self):
+ return self.getToken(VfrSyntaxParser.StringRef, 0)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_stringref1Exp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStringref1Exp" ):
+ return visitor.visitStringref1Exp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def stringref1Exp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Stringref1ExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 352, self.RULE_stringref1Exp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2759
+ self.match(VfrSyntaxParser.StringRef)
+ self.state = 2760
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2766
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringToken]:
+ self.state = 2761
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2762
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2763
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2764
+ self.match(VfrSyntaxParser.CloseParen)
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 2765
+ self.match(VfrSyntaxParser.Number)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 2768
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PushthisExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def PushThis(self):
+ return self.getToken(VfrSyntaxParser.PushThis, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pushthisExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPushthisExp" ):
+ return visitor.visitPushthisExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pushthisExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.PushthisExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 354, self.RULE_pushthisExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2770
+ self.match(VfrSyntaxParser.PushThis)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SecurityExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def Security(self):
+ return self.getToken(VfrSyntaxParser.Security, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_securityExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSecurityExp" ):
+ return visitor.visitSecurityExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def securityExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.SecurityExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 356, self.RULE_securityExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2772
+ self.match(VfrSyntaxParser.Security)
+ self.state = 2773
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2774
+ self.guidDefinition()
+ self.state = 2775
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class NumericVarStoreTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.VarType = None
+
+ def NumericSizeOne(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
+
+ def NumericSizeTwo(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
+
+ def NumericSizeFour(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
+
+ def NumericSizeEight(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_numericVarStoreType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitNumericVarStoreType" ):
+ return visitor.visitNumericVarStoreType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def numericVarStoreType(self):
+
+ localctx = VfrSyntaxParser.NumericVarStoreTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 358, self.RULE_numericVarStoreType)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2777
+ _la = self._input.LA(1)
+ if not(((((_la - 237)) & ~0x3f) == 0 and ((1 << (_la - 237)) & ((1 << (VfrSyntaxParser.NumericSizeOne - 237)) | (1 << (VfrSyntaxParser.NumericSizeTwo - 237)) | (1 << (VfrSyntaxParser.NumericSizeFour - 237)) | (1 << (VfrSyntaxParser.NumericSizeEight - 237)))) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GetExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.BaseInfo = EFI_VARSTORE_INFO()
+ self.GObj = None
+ self.ExpInfo = ExpInfo
+
+ def Get(self):
+ return self.getToken(VfrSyntaxParser.Get, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStorageVarId(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self):
+ return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def numericVarStoreType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_getExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGetExp" ):
+ return visitor.visitGetExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def getExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.GetExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 360, self.RULE_getExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2779
+ self.match(VfrSyntaxParser.Get)
+ self.state = 2780
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2781
+ self.vfrStorageVarId(localctx.BaseInfo, False)
+ self.state = 2786
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2782
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2783
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2784
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2785
+ self.numericVarStoreType()
+
+
+ self.state = 2788
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionConstantContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def TrueSymbol(self):
+ return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
+
+ def FalseSymbol(self):
+ return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
+
+ def One(self):
+ return self.getToken(VfrSyntaxParser.One, 0)
+
+ def Ones(self):
+ return self.getToken(VfrSyntaxParser.Ones, 0)
+
+ def Zero(self):
+ return self.getToken(VfrSyntaxParser.Zero, 0)
+
+ def Undefined(self):
+ return self.getToken(VfrSyntaxParser.Undefined, 0)
+
+ def Version(self):
+ return self.getToken(VfrSyntaxParser.Version, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionConstant
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionConstant" ):
+ return visitor.visitVfrExpressionConstant(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionConstant(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionConstantContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 362, self.RULE_vfrExpressionConstant)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2790
+ _la = self._input.LA(1)
+ if not(((((_la - 209)) & ~0x3f) == 0 and ((1 << (_la - 209)) & ((1 << (VfrSyntaxParser.TrueSymbol - 209)) | (1 << (VfrSyntaxParser.FalseSymbol - 209)) | (1 << (VfrSyntaxParser.One - 209)) | (1 << (VfrSyntaxParser.Ones - 209)) | (1 << (VfrSyntaxParser.Zero - 209)) | (1 << (VfrSyntaxParser.Undefined - 209)) | (1 << (VfrSyntaxParser.Version - 209)) | (1 << (VfrSyntaxParser.Number - 209)))) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionUnaryOpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def lengthExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.LengthExpContext,0)
+
+
+ def bitwisenotExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.BitwisenotExpContext,0)
+
+
+ def question23refExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Question23refExpContext,0)
+
+
+ def stringref2Exp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Stringref2ExpContext,0)
+
+
+ def toboolExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ToboolExpContext,0)
+
+
+ def tostringExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.TostringExpContext,0)
+
+
+ def unintExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.UnintExpContext,0)
+
+
+ def toupperExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ToupperExpContext,0)
+
+
+ def tolwerExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.TolwerExpContext,0)
+
+
+ def setExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SetExpContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionUnaryOp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionUnaryOp" ):
+ return visitor.visitVfrExpressionUnaryOp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionUnaryOp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionUnaryOpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 364, self.RULE_vfrExpressionUnaryOp)
+ try:
+ self.state = 2802
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Length]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2792
+ self.lengthExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.BitWiseNot]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2793
+ self.bitwisenotExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.QuestionRefVal]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2794
+ self.question23refExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.StringRefVal]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2795
+ self.stringref2Exp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.BoolVal]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2796
+ self.toboolExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.StringVal]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2797
+ self.tostringExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.UnIntVal]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 2798
+ self.unintExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.ToUpper]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 2799
+ self.toupperExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.ToLower]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 2800
+ self.tolwerExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Set]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 2801
+ self.setExp(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class LengthExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.LObj = None
+ self.ExpInfo = ExpInfo
+
+ def Length(self):
+ return self.getToken(VfrSyntaxParser.Length, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_lengthExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitLengthExp" ):
+ return visitor.visitLengthExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def lengthExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.LengthExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 366, self.RULE_lengthExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2804
+ self.match(VfrSyntaxParser.Length)
+ self.state = 2805
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2806
+ self.vfrStatementExpressionSub()
+ self.state = 2807
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class BitwisenotExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.BWNObj = None
+ self.ExpInfo = ExpInfo
+
+ def BitWiseNot(self):
+ return self.getToken(VfrSyntaxParser.BitWiseNot, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_bitwisenotExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitBitwisenotExp" ):
+ return visitor.visitBitwisenotExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def bitwisenotExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.BitwisenotExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 368, self.RULE_bitwisenotExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2809
+ self.match(VfrSyntaxParser.BitWiseNot)
+ self.state = 2810
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2811
+ self.vfrStatementExpressionSub()
+ self.state = 2812
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Question23refExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def QuestionRefVal(self):
+ return self.getToken(VfrSyntaxParser.QuestionRefVal, 0)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def DevicePath(self):
+ return self.getToken(VfrSyntaxParser.DevicePath, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_question23refExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitQuestion23refExp" ):
+ return visitor.visitQuestion23refExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def question23refExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Question23refExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 370, self.RULE_question23refExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2814
+ self.match(VfrSyntaxParser.QuestionRefVal)
+ self.state = 2815
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2823
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.DevicePath:
+ self.state = 2816
+ self.match(VfrSyntaxParser.DevicePath)
+ self.state = 2817
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2818
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2819
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2820
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2821
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2822
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2830
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Uuid:
+ self.state = 2825
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 2826
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2827
+ self.guidDefinition()
+ self.state = 2828
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2832
+ self.vfrStatementExpressionSub()
+ self.state = 2833
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Stringref2ExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.SR2Obj = None
+ self.ExpInfo = ExpInfo
+
+ def StringRefVal(self):
+ return self.getToken(VfrSyntaxParser.StringRefVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_stringref2Exp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStringref2Exp" ):
+ return visitor.visitStringref2Exp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def stringref2Exp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Stringref2ExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 372, self.RULE_stringref2Exp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2835
+ self.match(VfrSyntaxParser.StringRefVal)
+ self.state = 2836
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2837
+ self.vfrStatementExpressionSub()
+ self.state = 2838
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ToboolExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TBObj = None
+ self.ExpInfo = ExpInfo
+
+ def BoolVal(self):
+ return self.getToken(VfrSyntaxParser.BoolVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_toboolExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitToboolExp" ):
+ return visitor.visitToboolExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def toboolExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ToboolExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 374, self.RULE_toboolExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2840
+ self.match(VfrSyntaxParser.BoolVal)
+ self.state = 2841
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2842
+ self.vfrStatementExpressionSub()
+ self.state = 2843
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TostringExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TSObj = None
+ self.ExpInfo = ExpInfo
+
+ def StringVal(self):
+ return self.getToken(VfrSyntaxParser.StringVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_tostringExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTostringExp" ):
+ return visitor.visitTostringExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def tostringExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.TostringExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 376, self.RULE_tostringExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2845
+ self.match(VfrSyntaxParser.StringVal)
+ self.state = 2850
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.T__14:
+ self.state = 2846
+ self.match(VfrSyntaxParser.T__14)
+ self.state = 2847
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2848
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2849
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2852
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2853
+ self.vfrStatementExpressionSub()
+ self.state = 2854
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class UnintExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TUObj = None
+ self.ExpInfo = ExpInfo
+
+ def UnIntVal(self):
+ return self.getToken(VfrSyntaxParser.UnIntVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_unintExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitUnintExp" ):
+ return visitor.visitUnintExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def unintExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.UnintExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 378, self.RULE_unintExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2856
+ self.match(VfrSyntaxParser.UnIntVal)
+ self.state = 2857
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2858
+ self.vfrStatementExpressionSub()
+ self.state = 2859
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ToupperExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TUObj = None
+ self.ExpInfo = ExpInfo
+
+ def ToUpper(self):
+ return self.getToken(VfrSyntaxParser.ToUpper, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_toupperExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitToupperExp" ):
+ return visitor.visitToupperExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def toupperExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ToupperExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 380, self.RULE_toupperExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2861
+ self.match(VfrSyntaxParser.ToUpper)
+ self.state = 2862
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2863
+ self.vfrStatementExpressionSub()
+ self.state = 2864
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TolwerExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TLObj = None
+ self.ExpInfo = ExpInfo
+
+ def ToLower(self):
+ return self.getToken(VfrSyntaxParser.ToLower, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_tolwerExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTolwerExp" ):
+ return visitor.visitTolwerExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def tolwerExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.TolwerExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 382, self.RULE_tolwerExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2866
+ self.match(VfrSyntaxParser.ToLower)
+ self.state = 2867
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2868
+ self.vfrStatementExpressionSub()
+ self.state = 2869
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SetExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.BaseInfo = EFI_VARSTORE_INFO()
+ self.TSObj = None
+ self.ExpInfo = ExpInfo
+
+ def Set(self):
+ return self.getToken(VfrSyntaxParser.Set, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStorageVarId(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self):
+ return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def numericVarStoreType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_setExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSetExp" ):
+ return visitor.visitSetExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def setExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.SetExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 384, self.RULE_setExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2871
+ self.match(VfrSyntaxParser.Set)
+ self.state = 2872
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2873
+ self.vfrStorageVarId(localctx.BaseInfo, False)
+ self.state = 2878
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2874
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2875
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2876
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2877
+ self.numericVarStoreType()
+
+
+ self.state = 2880
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2881
+ self.vfrStatementExpressionSub()
+ self.state = 2882
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionTernaryOpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.ExpInfo = ExpInfo
+
+ def conditionalExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ConditionalExpContext,0)
+
+
+ def findExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.FindExpContext,0)
+
+
+ def midExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MidExpContext,0)
+
+
+ def tokenExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.TokenExpContext,0)
+
+
+ def spanExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SpanExpContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionTernaryOp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionTernaryOp" ):
+ return visitor.visitVfrExpressionTernaryOp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionTernaryOp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionTernaryOpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 386, self.RULE_vfrExpressionTernaryOp)
+ try:
+ self.state = 2889
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Cond]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2884
+ self.conditionalExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Find]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2885
+ self.findExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Mid]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2886
+ self.midExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Tok]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2887
+ self.tokenExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Span]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2888
+ self.spanExp(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ConditionalExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.CObj = None
+ self.ExpInfo = ExpInfo
+
+ def Cond(self):
+ return self.getToken(VfrSyntaxParser.Cond, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_conditionalExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitConditionalExp" ):
+ return visitor.visitConditionalExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def conditionalExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ConditionalExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 388, self.RULE_conditionalExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2891
+ self.match(VfrSyntaxParser.Cond)
+ self.state = 2892
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2893
+ self.vfrStatementExpressionSub()
+ self.state = 2894
+ self.match(VfrSyntaxParser.T__15)
+ self.state = 2895
+ self.vfrStatementExpressionSub()
+ self.state = 2896
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 2897
+ self.vfrStatementExpressionSub()
+ self.state = 2898
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FindExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.FObj = None
+ self.ExpInfo = ExpInfo
+
+ def Find(self):
+ return self.getToken(VfrSyntaxParser.Find, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def findFormat(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FindFormatContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FindFormatContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_findExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFindExp" ):
+ return visitor.visitFindExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def findExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.FindExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 390, self.RULE_findExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2900
+ self.match(VfrSyntaxParser.Find)
+ self.state = 2901
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2902
+ self.findFormat(ExpInfo)
+ self.state = 2907
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2903
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2904
+ self.findFormat(ExpInfo)
+ self.state = 2909
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2910
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2911
+ self.vfrStatementExpressionSub()
+ self.state = 2912
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2913
+ self.vfrStatementExpressionSub()
+ self.state = 2914
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2915
+ self.vfrStatementExpressionSub()
+ self.state = 2916
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FindFormatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Format = 0
+ self.ExpInfo = ExpInfo
+
+ def Sensitive(self):
+ return self.getToken(VfrSyntaxParser.Sensitive, 0)
+
+ def Insensitive(self):
+ return self.getToken(VfrSyntaxParser.Insensitive, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_findFormat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFindFormat" ):
+ return visitor.visitFindFormat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def findFormat(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.FindFormatContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 392, self.RULE_findFormat)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2918
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.Insensitive or _la==VfrSyntaxParser.Sensitive):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MidExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.MObj = None
+ self.ExpInfo = ExpInfo
+
+ def Mid(self):
+ return self.getToken(VfrSyntaxParser.Mid, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_midExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMidExp" ):
+ return visitor.visitMidExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def midExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.MidExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 394, self.RULE_midExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2920
+ self.match(VfrSyntaxParser.Mid)
+ self.state = 2921
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2922
+ self.vfrStatementExpressionSub()
+ self.state = 2923
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2924
+ self.vfrStatementExpressionSub()
+ self.state = 2925
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2926
+ self.vfrStatementExpressionSub()
+ self.state = 2927
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TokenExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.TObj = None
+ self.ExpInfo = ExpInfo
+
+ def Tok(self):
+ return self.getToken(VfrSyntaxParser.Tok, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_tokenExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTokenExp" ):
+ return visitor.visitTokenExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def tokenExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.TokenExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 396, self.RULE_tokenExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2929
+ self.match(VfrSyntaxParser.Tok)
+ self.state = 2930
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2931
+ self.vfrStatementExpressionSub()
+ self.state = 2932
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2933
+ self.vfrStatementExpressionSub()
+ self.state = 2934
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2935
+ self.vfrStatementExpressionSub()
+ self.state = 2936
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SpanExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.SObj = None
+ self.ExpInfo = ExpInfo
+
+ def Span(self):
+ return self.getToken(VfrSyntaxParser.Span, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def spanFlags(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.SpanFlagsContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.SpanFlagsContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_spanExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSpanExp" ):
+ return visitor.visitSpanExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def spanExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.SpanExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 398, self.RULE_spanExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2938
+ self.match(VfrSyntaxParser.Span)
+ self.state = 2939
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2940
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2941
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2942
+ self.spanFlags()
+ self.state = 2947
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2943
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2944
+ self.spanFlags()
+ self.state = 2949
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2950
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2951
+ self.vfrStatementExpressionSub()
+ self.state = 2952
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2953
+ self.vfrStatementExpressionSub()
+ self.state = 2954
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2955
+ self.vfrStatementExpressionSub()
+ self.state = 2956
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SpanFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def LastNonMatch(self):
+ return self.getToken(VfrSyntaxParser.LastNonMatch, 0)
+
+ def FirstNonMatch(self):
+ return self.getToken(VfrSyntaxParser.FirstNonMatch, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_spanFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSpanFlags" ):
+ return visitor.visitSpanFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def spanFlags(self):
+
+ localctx = VfrSyntaxParser.SpanFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 400, self.RULE_spanFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2958
+ _la = self._input.LA(1)
+ if not(((((_la - 246)) & ~0x3f) == 0 and ((1 << (_la - 246)) & ((1 << (VfrSyntaxParser.LastNonMatch - 246)) | (1 << (VfrSyntaxParser.FirstNonMatch - 246)) | (1 << (VfrSyntaxParser.Number - 246)))) != 0)):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionMapContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.MObj = None
+ self.ExpInfo = ExpInfo
+
+ def Map(self):
+ return self.getToken(VfrSyntaxParser.Map, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def vfrStatementExpression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionMap
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionMap" ):
+ return visitor.visitVfrExpressionMap(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionMap(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionMapContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 402, self.RULE_vfrExpressionMap)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2960
+ self.match(VfrSyntaxParser.Map)
+ self.state = 2961
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2962
+ self.vfrStatementExpressionSub()
+ self.state = 2963
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 2971
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.OpenParen or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (VfrSyntaxParser.Cond - 192)) | (1 << (VfrSyntaxParser.Find - 192)) | (1 << (VfrSyntaxParser.Mid - 192)) | (1 << (VfrSyntaxParser.Tok - 192)) | (1 << (VfrSyntaxParser.Span - 192)) | (1 << (VfrSyntaxParser.Dup - 192)) | (1 << (VfrSyntaxParser.VarEqVal - 192)) | (1 << (VfrSyntaxParser.IdEqVal - 192)) | (1 << (VfrSyntaxParser.IdEqId - 192)) | (1 << (VfrSyntaxParser.IdEqValList - 192)) | (1 << (VfrSyntaxParser.QuestionRef - 192)) | (1 << (VfrSyntaxParser.RuleRef - 192)) | (1 << (VfrSyntaxParser.StringRef - 192)) | (1 << (VfrSyntaxParser.PushThis - 192)) | (1 << (VfrSyntaxParser.Security - 192)) | (1 << (VfrSyntaxParser.Get - 192)) | (1 << (VfrSyntaxParser.TrueSymbol - 192)) | (1 << (VfrSyntaxParser.FalseSymbol - 192)) | (1 << (VfrSyntaxParser.One - 192)) | (1 << (VfrSyntaxParser.Ones - 192)) | (1 << (VfrSyntaxParser.Zero - 192)) | (1 << (VfrSyntaxParser.Undefined - 192)) | (1 << (VfrSyntaxParser.Version - 192)) | (1 << (VfrSyntaxParser.Length - 192)) | (1 << (VfrSyntaxParser.NOT - 192)) | (1 << (VfrSyntaxParser.Set - 192)) | (1 << (VfrSyntaxParser.BitWiseNot - 192)) | (1 << (VfrSyntaxParser.BoolVal - 192)) | (1 << (VfrSyntaxParser.StringVal - 192)) | (1 << (VfrSyntaxParser.UnIntVal - 192)) | (1 << (VfrSyntaxParser.ToUpper - 192)) | (1 << (VfrSyntaxParser.ToLower - 192)) | (1 << (VfrSyntaxParser.Match - 192)) | (1 << (VfrSyntaxParser.Match2 - 192)) | (1 << (VfrSyntaxParser.Catenate - 192)) | (1 << (VfrSyntaxParser.QuestionRefVal - 192)) | (1 << (VfrSyntaxParser.StringRefVal - 192)) | (1 << (VfrSyntaxParser.Map - 192)) | (1 << (VfrSyntaxParser.Number - 192)))) != 0):
+ self.state = 2964
+ self.vfrStatementExpression()
+ self.state = 2965
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2966
+ self.vfrStatementExpression()
+ self.state = 2967
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 2973
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2974
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
diff --git a/edk2basetools/VfrCompiler/VfrSyntaxVisitor.py b/edk2basetools/VfrCompiler/VfrSyntaxVisitor.py
new file mode 100644
index 0000000..5eee407
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrSyntaxVisitor.py
@@ -0,0 +1,5106 @@
+from cgi import print_environ_usage
+from email.errors import NonASCIILocalPartDefect, NonPrintableDefect
+from enum import Flag
+from fileinput import lineno
+from http.client import ResponseNotReady
+from itertools import count
+from modulefinder import STORE_NAME
+from msilib.schema import CreateFolder
+from re import T
+from sre_parse import FLAGS
+from tokenize import Number
+from antlr4 import *
+from VfrCompiler.CommonCtypes import *
+from VfrCompiler.VfrFormPkg import *
+from VfrCompiler.VfrUtility import *
+from VfrCompiler.VfrTree import *
+import ctypes
+import struct
+
+if __name__ is not None and "." in __name__:
+ from .VfrSyntaxParser import VfrSyntaxParser
+else:
+ from VfrSyntaxParser import VfrSyntaxParser
+
+gCVfrVarDataTypeDB = CVfrVarDataTypeDB()
+gCVfrDefaultStore = CVfrDefaultStore()
+gCVfrDataStorage = CVfrDataStorage()
+
+# This class defines a complete generic visitor for a parse tree produced by VfrSyntaxParser.
+class VfrSyntaxVisitor(ParseTreeVisitor):
+ gZeroEfiIfrTypeValue = EFI_IFR_TYPE_VALUE()
+
+ def __init__(self):
+ self.__OverrideClassGuid = None
+ self.__ParserStatus = 0
+ self.__CIfrOpHdrIndex = -1
+ self.__ConstantOnlyInExpression = False
+ self.__UsedDefaultArray = []
+
+ self.__CVfrRulesDB = CVfrRulesDB()
+ self.__CIfrOpHdr = [] #
+ self.__CIfrOpHdrLineNo = []
+ self.__CurrQestVarInfo = EFI_VARSTORE_INFO()
+
+ self.__CVfrQuestionDB = CVfrQuestionDB()
+ self.__CurrentQuestion = None
+ self.__CurrentMinMaxData = None #
+
+ self.__IsStringOp = False
+ self.__IsOrderedList = False
+ self.__IsCheckBoxOp = False
+ self.__Root = VfrTreeNode()
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrProgram.
+ def visitVfrProgram(self, ctx:VfrSyntaxParser.VfrProgramContext):
+
+ #self.__CVfrQuestionDB.PrintAllQuestion('test\\Questions.txt')
+ #gCVfrVarDataTypeDB.Dump("test\\DataTypeInfo.txt")
+
+ return self.visitChildren(ctx)
+
+ # Visit a parse tree produced by VfrSyntaxParser#pragmaPackShowDef.
+ def visitPragmaPackShowDef(self, ctx:VfrSyntaxParser.PragmaPackShowDefContext):
+
+ Line = ctx.start.line
+ gCVfrVarDataTypeDB.Pack(Line, VFR_PACK_SHOW)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#pragmaPackStackDef.
+ def visitPragmaPackStackDef(self, ctx:VfrSyntaxParser.PragmaPackStackDefContext):
+
+ Identifier = self.__TransId(ctx.StringIdentifier())
+
+ if str(ctx.getChild(0)) == 'push':
+ Action = VFR_PACK_PUSH
+ else:
+ Action = VFR_PACK_POP
+
+ if ctx.Number() != None:
+ Action |= VFR_PACK_ASSIGN
+
+ PackNumber = self.__TransNum(ctx.Number(), DEFAULT_PACK_ALIGN)
+ Line = ctx.start.line
+ gCVfrVarDataTypeDB.Pack(Line, Action, Identifier, PackNumber)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#pragmaPackNumber.
+ def visitPragmaPackNumber(self, ctx:VfrSyntaxParser.PragmaPackNumberContext):
+
+ Line = ctx.start.line
+ PackNumber = self.__TransNum(ctx.Number(), DEFAULT_PACK_ALIGN)
+
+ gCVfrVarDataTypeDB.Pack(Line, VFR_PACK_ASSIGN, None, PackNumber)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrPragmaPackDefinition.
+ def visitVfrPragmaPackDefinition(
+ self, ctx: VfrSyntaxParser.VfrPragmaPackDefinitionContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrDataStructDefinition.
+ def visitVfrDataStructDefinition(self, ctx: VfrSyntaxParser.VfrDataStructDefinitionContext):
+
+ gCVfrVarDataTypeDB.DeclareDataTypeBegin()
+
+ if ctx.N1 != None:
+ ReturnCode = gCVfrVarDataTypeDB.SetNewTypeName(ctx.N1.text)
+ self.__ErrorHandler(ReturnCode, ctx.N1.line, ctx.N1.text)
+
+ if ctx.N2 != None:
+ ReturnCode = gCVfrVarDataTypeDB.SetNewTypeName(ctx.N2.text)
+ self.__ErrorHandler(ReturnCode, ctx.N2.line, ctx.N2.text)
+
+ self.visitChildren(ctx)
+
+ gCVfrVarDataTypeDB.DeclareDataTypeEnd()
+
+ return None
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrDataUnionDefinition.
+ def visitVfrDataUnionDefinition(self, ctx:VfrSyntaxParser.VfrDataUnionDefinitionContext):
+ gCVfrVarDataTypeDB.DeclareDataTypeBegin()
+ if ctx.N1 != None:
+ ReturnCode = gCVfrVarDataTypeDB.SetNewTypeName(ctx.N1.text)
+ self.__ErrorHandler(ReturnCode, ctx.N1.line, ctx.N1.text)
+
+ if ctx.N2 != None:
+ ReturnCode = gCVfrVarDataTypeDB.SetNewTypeName(ctx.N2.text)
+ self.__ErrorHandler(ReturnCode, ctx.N2.line, ctx.N2.text)
+
+ self.visitChildren(ctx)
+
+ gCVfrVarDataTypeDB.DeclareDataTypeEnd()
+ return None
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrDataStructFields.
+ def visitVfrDataStructFields(self, ctx:VfrSyntaxParser.VfrDataStructFieldsContext):
+
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructField64.
+ def visitDataStructField64(self, ctx:VfrSyntaxParser.DataStructField64Context):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'UINT64', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructField32.
+ def visitDataStructField32(self, ctx:VfrSyntaxParser.DataStructField32Context):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'UINT32', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructField16.
+ def visitDataStructField16(self, ctx:VfrSyntaxParser.DataStructField16Context):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'UINT16', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructField8.
+ def visitDataStructField8(self, ctx:VfrSyntaxParser.DataStructField8Context):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'UINT8', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructFieldBool.
+ def visitDataStructFieldBool(self, ctx:VfrSyntaxParser.DataStructFieldBoolContext):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'BOOLEAN', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructFieldString.
+ def visitDataStructFieldString(self, ctx:VfrSyntaxParser.DataStructFieldStringContext):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'EFI_STRING_ID', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructFieldDate.
+ def visitDataStructFieldDate(self, ctx:VfrSyntaxParser.DataStructFieldDateContext):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'EFI_HII_DATE', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructFieldTime.
+ def visitDataStructFieldTime(self, ctx:VfrSyntaxParser.DataStructFieldTimeContext):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'EFI_HII_TIME', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructFieldRef.
+ def visitDataStructFieldRef(self, ctx:VfrSyntaxParser.DataStructFieldRefContext):
+ ArrayNum = self.__TransNum(ctx.Number())
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'EFI_HII_REF', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructFieldUser.
+ def visitDataStructFieldUser(self, ctx:VfrSyntaxParser.DataStructFieldUserContext):
+ ArrayNum = self.__TransNum(ctx.Number())
+ if ctx.T.text != 'CHAR16':
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, ctx.T.text, ArrayNum, ctx.FieldInUnion)
+ else:
+ ReturnCode = gCVfrVarDataTypeDB.DataTypeAddField(ctx.N.text, 'UINT16', ArrayNum, ctx.FieldInUnion)
+ self.__ErrorHandler(ReturnCode, ctx.N.line, ctx.N.text)
+ return self.visitChildren(ctx)
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructBitField64.
+ def visitDataStructBitField64(self, ctx:VfrSyntaxParser.DataStructBitField64Context):
+ Width = self.__TransNum(ctx.Number())
+ if ctx.N != None:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(ctx.N.text, 'UINT64', Width, ctx.FieldInUnion), ctx.N.line, ctx.N.text)
+ else:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(None, 'UINT64', Width, ctx.FieldInUnion), ctx.D.line, ctx.D.text)
+
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructBitField32.
+ def visitDataStructBitField32(self, ctx:VfrSyntaxParser.DataStructBitField32Context):
+ Width = self.__TransNum(ctx.Number())
+ if ctx.N != None:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(ctx.N.text, 'UINT32', Width, ctx.FieldInUnion), ctx.N.line, ctx.N.text)
+ else:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(None, 'UINT32', Width, ctx.FieldInUnion), ctx.D.line, ctx.D.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructBitField16.
+ def visitDataStructBitField16(self, ctx:VfrSyntaxParser.DataStructBitField16Context):
+ Width = self.__TransNum(ctx.Number())
+ if ctx.N != None:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(ctx.N.text, 'UINT16', Width, ctx.FieldInUnion), ctx.N.line, ctx.N.text)
+ else:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(None, 'UINT16', Width, ctx.FieldInUnion), ctx.D.line, ctx.D.text)
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dataStructBitField8.
+ def visitDataStructBitField8(self, ctx:VfrSyntaxParser.DataStructBitField8Context):
+ Width = self.__TransNum(ctx.Number())
+ if ctx.N != None:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(ctx.N.text, 'UINT8', Width, ctx.FieldInUnion), ctx.N.line, ctx.N.text)
+ else:
+ self.__ErrorHandler(gCVfrVarDataTypeDB.DataTypeAddBitField(None, 'UINT8', Width, ctx.FieldInUnion), ctx.D.line, ctx.D.text)
+ return self.visitChildren(ctx)
+
+ def __DeclareStandardDefaultStorage(self, LineNo):
+
+ DSObj = CIfrDefaultStore()
+ gCVfrDefaultStore.RegisterDefaultStore(DSObj.GetDefaultStore(), "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD)
+ DSObj.SetLineNo (LineNo)
+ DSObj.SetDefaultName (EFI_STRING_ID_INVALID)
+ DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD)
+
+ DSObjMF = CIfrDefaultStore()
+ gCVfrDefaultStore.RegisterDefaultStore(DSObjMF.GetDefaultStore(), "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING)
+ DSObjMF.SetLineNo (LineNo)
+ DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID)
+ DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrFormSetDefinition.
+ def visitVfrFormSetDefinition(self, ctx:VfrSyntaxParser.VfrFormSetDefinitionContext):
+ self.__InsertChild(self.__Root, ctx)
+ self.__InsertChild(ctx.Node, ctx.classDefinition())
+ self.__InsertChild(ctx.Node, ctx.subclassDefinition())
+ Line = ctx.start.line
+ self.__DeclareStandardDefaultStorage(Line)
+
+ self.visitChildren(ctx)
+ ClassGuidNum = 0
+ GuidList = []
+ if ctx.classguidDefinition() != None:
+ GuidList = ctx.classguidDefinition().GuidList
+ ClassGuidNum = len(GuidList)
+
+ DefaultClassGuid = EFI_HII_PLATFORM_SETUP_FORMSET_GUID
+
+ if (self.__OverrideClassGuid != None and ClassGuidNum >=4):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, None, 'Already has 4 class guids, can not add extra class guid!')
+
+ if ClassGuidNum == 0:
+ if self.__OverrideClassGuid != None:
+ ClassGuidNum = 2
+ else:
+ ClassGuidNum = 1
+ FSObj = CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID))
+ FSObj.SetClassGuid(DefaultClassGuid)
+ if (self.__OverrideClassGuid != None):
+ FSObj.SetClassGuid(self.__OverrideClassGuid)
+
+ elif ClassGuidNum == 1:
+ if self.__OverrideClassGuid != None:
+ ClassGuidNum += 1
+ FSObj = CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID))
+ FSObj.SetClassGuid(GuidList[0])
+ if (self.__OverrideClassGuid != None):
+ FSObj.SetClassGuid(self.__OverrideClassGuid)
+
+ elif ClassGuidNum == 2:
+ if self.__OverrideClassGuid != None:
+ ClassGuidNum += 1
+ FSObj = CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID))
+ FSObj.SetClassGuid(GuidList[0])
+ FSObj.SetClassGuid(GuidList[1])
+ if (self.__OverrideClassGuid != None):
+ FSObj.SetClassGuid(self.__OverrideClassGuid)
+
+ elif ClassGuidNum == 3:
+ if self.__OverrideClassGuid != None:
+ ClassGuidNum += 1
+ FSObj = CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID))
+ FSObj.SetClassGuid(GuidList[0])
+ FSObj.SetClassGuid(GuidList[1])
+ FSObj.SetClassGuid(GuidList[2])
+ if (self.__OverrideClassGuid != None):
+ FSObj.SetClassGuid(self.__OverrideClassGuid)
+
+ elif ClassGuidNum == 4:
+ if self.__OverrideClassGuid != None:
+ ClassGuidNum += 1
+ FSObj = CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID))
+ FSObj.SetClassGuid(GuidList[0])
+ FSObj.SetClassGuid(GuidList[1])
+ FSObj.SetClassGuid(GuidList[2])
+ FSObj.SetClassGuid(GuidList[3])
+
+ FSObj.SetLineNo(Line)
+ FSObj.SetGuid(ctx.guidDefinition().Guid)
+ FSObj.SetFormSetTitle(self.__TransNum(ctx.Number(0)))
+ FSObj.SetHelp(self.__TransNum(ctx.Number(1)))
+
+ ctx.Node.Data = FSObj
+ # Declare undefined Question so that they can be used in expression.
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#classguidDefinition.
+ def visitClassguidDefinition(self, ctx:VfrSyntaxParser.ClassguidDefinitionContext):
+
+ self.visitChildren(ctx)
+
+ for GuidCtx in ctx.guidDefinition():
+ ctx.GuidList.append(GuidCtx.Guid)
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#classDefinition.
+ def visitClassDefinition(self, ctx:VfrSyntaxParser.ClassDefinitionContext):
+ CObj = CIfrClass()
+ self.visitChildren(ctx)
+ Class = 0
+ for ClassNameCtx in ctx.validClassNames():
+ Class |= ClassNameCtx.ClassName
+ Line = ctx.start.line
+ CObj.SetLineNo(Line)
+ CObj.SetClass(Class)
+ ctx.Node.Data = CObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#validClassNames.
+ def visitValidClassNames(self, ctx:VfrSyntaxParser.ValidClassNamesContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.ClassNonDevice() != None:
+ ctx.ClassName = EFI_NON_DEVICE_CLASS
+ elif ctx.ClassDiskDevice() != None:
+ ctx.ClassName = EFI_DISK_DEVICE_CLASS
+ elif ctx.ClassVideoDevice() != None:
+ ctx.ClassName = EFI_VIDEO_DEVICE_CLASS
+ elif ctx.ClassNetworkDevice() != None:
+ ctx.ClassName = EFI_NETWORK_DEVICE_CLASS
+ elif ctx.ClassInputDevice() != None:
+ ctx.ClassName = EFI_INPUT_DEVICE_CLASS
+ elif ctx.ClassOnBoardDevice() != None:
+ ctx.ClassName = EFI_ON_BOARD_DEVICE_CLASS
+ elif ctx.ClassOtherDevice() != None:
+ ctx.ClassName = EFI_OTHER_DEVICE_CLASS
+ else:
+ ctx.ClassName = self.__TransNum(ctx.Number())
+
+ return ctx.ClassName
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#subclassDefinition.
+ def visitSubclassDefinition(self, ctx:VfrSyntaxParser.SubclassDefinitionContext):
+ SubObj = CIfrSubClass()
+
+ self.visitChildren(ctx)
+
+ Line = ctx.start.line
+ SubObj.SetLineNo(Line)
+ SubClass = 0
+ if ctx.SubclassSetupApplication() != None:
+ SubClass |= EFI_SETUP_APPLICATION_SUBCLASS
+ elif ctx.SubclassGeneralApplication() != None:
+ SubClass |= EFI_GENERAL_APPLICATION_SUBCLASS
+ elif ctx.SubclassFrontPage() != None:
+ SubClass |= EFI_FRONT_PAGE_SUBCLASS
+ elif ctx.SubclassSingleUse() != None:
+ SubClass |= EFI_SINGLE_USE_SUBCLASS
+ else:
+ SubClass = self.__TransNum(ctx.Number())
+
+ SubObj.SetSubClass(SubClass)
+ ctx.Node.Data = SubObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrFormSetList.
+ def visitVfrFormSetList(self, ctx:VfrSyntaxParser.VfrFormSetListContext):
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrFormSet():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrFormSet.
+ def visitVfrFormSet(self, ctx:VfrSyntaxParser.VfrFormSetContext):
+ self.visitChildren(ctx)
+
+ if ctx.vfrFormDefinition() != None:
+ ctx.Node = ctx.vfrFormDefinition().Node
+ if ctx.vfrFormMapDefinition() != None:
+ ctx.Node = ctx.vfrFormMapDefinition().Node
+ if ctx.vfrStatementImage() != None:
+ ctx.Node = ctx.vfrStatementImage().Node
+ if ctx.vfrStatementVarStoreLinear() != None:
+ ctx.Node = ctx.vfrStatementVarStoreLinear().Node
+ if ctx.vfrStatementVarStoreEfi() != None:
+ ctx.Node = ctx.vfrStatementVarStoreEfi().Node
+ if ctx.vfrStatementVarStoreNameValue() != None:
+ ctx.Node = ctx.vfrStatementVarStoreNameValue().Node
+ if ctx.vfrStatementDefaultStore() != None:
+ ctx.Node = ctx.vfrStatementDefaultStore().Node
+ if ctx.vfrStatementDisableIfFormSet() != None:
+ ctx.Node = ctx.vfrStatementDisableIfFormSet().Node
+ if ctx.vfrStatementSuppressIfFormSet() != None:
+ ctx.Node = ctx.vfrStatementSuppressIfFormSet().Node
+ if ctx.vfrStatementExtension() != None:
+ ctx.Node = ctx.vfrStatementExtension().Node
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDefaultStore.
+ def visitVfrStatementDefaultStore(self, ctx:VfrSyntaxParser.VfrStatementDefaultStoreContext):
+ DSObj = CIfrDefaultStore()
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+
+ RefName = ctx.N.text
+ DefaultStoreNameId = self.__TransNum(ctx.S.text)
+
+ DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD if ctx.Attribute()== None else self.__TransNum(ctx.A.text)
+
+ if gCVfrDefaultStore.DefaultIdRegistered(DefaultId) == False:
+ self.__ErrorHandler(gCVfrDefaultStore.RegisterDefaultStore(DSObj.GetDefaultStore(), RefName, DefaultStoreNameId, DefaultId) , Line)
+ DSObj.SetDefaultName(DefaultStoreNameId)
+ DSObj.SetDefaultId (DefaultId)
+ DSObj.SetLineNo(Line)
+ else:
+ pNode, ReturnCode = gCVfrDefaultStore.ReRegisterDefaultStoreById(DefaultId, RefName, DefaultStoreNameId)
+ self.__ErrorHandler(ReturnCode, Line)
+ DSObj.SetDefaultStore = pNode.ObjAddr
+ DSObj.SetLineNo(Line)
+
+ ctx.Node.Data = DSObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreLinear.
+ def visitVfrStatementVarStoreLinear(self, ctx:VfrSyntaxParser.VfrStatementVarStoreLinearContext):
+ VSObj = CIfrVarStore()
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ VSObj.SetLineNo(Line)
+
+ TypeName = str(ctx.getChild(1))
+ if TypeName == 'CHAR16':
+ TypeName = 'UINT16'
+
+ IsBitVarStore = False
+ if ctx.TN != None:
+ IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField(ctx.TN.text)
+
+ VarStoreId = EFI_VARSTORE_ID_INVALID
+ if ctx.VarId() != None:
+ VarStoreId = self.__TransNum(ctx.ID.text)
+ self.__CompareErrorHandler(VarStoreId!=0, True, ctx.ID.line, ctx.ID.text, 'varid 0 is not allowed.')
+ StoreName = ctx.SN.text
+ Guid = ctx.guidDefinition().Guid
+ self.__ErrorHandler(gCVfrDataStorage.DeclareBufferVarStore(StoreName, Guid, gCVfrVarDataTypeDB, TypeName, VarStoreId, IsBitVarStore), Line)
+ VSObj.SetGuid(Guid)
+ VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(StoreName, Guid)
+ self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
+ VSObj.SetVarStoreId(VarStoreId)
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
+ self.__ErrorHandler(ReturnCode, Line)
+ VSObj.SetSize(Size)
+ VSObj.SetName(StoreName)
+
+ ctx.Node.Data = VSObj
+
+ return VSObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreEfi.
+ def visitVfrStatementVarStoreEfi(self, ctx:VfrSyntaxParser.VfrStatementVarStoreEfiContext):
+
+ VSEObj = CIfrVarStoreEfi()
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ VSEObj.SetLineNo(Line)
+
+ Guid = ctx.guidDefinition().Guid
+
+ CustomizedName = False
+ IsBitVarStore = False
+ VarStoreId = EFI_VARSTORE_ID_INVALID
+ IsUEFI23EfiVarstore = True
+ ReturnCode = None
+
+ TypeName = str(ctx.getChild(1))
+
+ if TypeName == 'CHAR16':
+ TypeName = 'UINT16'
+
+ elif ctx.TN != None:
+ CustomizedName = True
+ IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField(TypeName)
+
+ if ctx.VarId() != None:
+ VarStoreId = self.__TransNum(ctx.ID.text)
+ self.__CompareErrorHandler(VarStoreId!=0, True, ctx.ID.line, ctx.ID.text, 'varid 0 is not allowed.')
+
+ Attributes = 0
+ for AtrCtx in ctx.vfrVarStoreEfiAttr():
+ Attributes |= AtrCtx.Attr
+ VSEObj.SetAttributes(Attributes)
+
+ if ctx.SN != None:
+ StoreName = ctx.SN.text
+ else:
+ IsUEFI23EfiVarstore = False
+ NameStringId = self.__TransNum(ctx.VN.text)
+ StoreName = gCVfrStringDB.GetVarStoreNameFromStringId(NameStringId) #
+ if StoreName == None:
+ gCVfrErrorHandle.HandleWarning(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.VN.line, 'Can\'t get varstore name for this StringId!')
+ if not(CustomizedName):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, 'Old style efivarstore must have String Identifier!')
+ Size = self.__TransNum(ctx.N.text)
+ if Size == 1: TypeName = 'UINT8'
+ elif Size == 2: TypeName = 'UINT16'
+ elif Size == 4: TypeName = 'UINT32'
+ elif Size == 8: TypeName = 'UINT64'
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line, ctx.N.text)
+
+ if IsUEFI23EfiVarstore:
+ self.__ErrorHandler(gCVfrDataStorage.DeclareBufferVarStore(StoreName, Guid, gCVfrVarDataTypeDB, TypeName, VarStoreId, IsBitVarStore, Attributes), Line)
+ VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(StoreName, Guid)
+ self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
+ self.__ErrorHandler(ReturnCode, Line)
+ else:
+ self.__ErrorHandler(gCVfrDataStorage.DeclareBufferVarStore(self.__GetText(ctx.TN), Guid, gCVfrVarDataTypeDB, TypeName, VarStoreId, IsBitVarStore, Attributes), Line) #
+ VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(self.__GetText(ctx.TN), Guid)
+ self.__ErrorHandler(ReturnCode, ctx.VN.line, ctx.VN.text)
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
+ self.__ErrorHandler(ReturnCode, ctx.N.line)
+
+ VSEObj.SetGuid(Guid)
+ VSEObj.SetVarStoreId (VarStoreId)
+ VSEObj.SetSize(Size)
+ VSEObj.SetName(StoreName)
+
+ ctx.Node.Data = VSEObj
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrVarStoreEfiAttr.
+ def visitVfrVarStoreEfiAttr(self, ctx:VfrSyntaxParser.VfrVarStoreEfiAttrContext):
+
+ self.visitChildren(ctx)
+ ctx.Attr = self.__TransNum(ctx.Number())
+ return ctx.Attr
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreNameValue.
+ def visitVfrStatementVarStoreNameValue(self, ctx:VfrSyntaxParser.VfrStatementVarStoreNameValueContext):
+
+ VSNVObj = CIfrVarStoreNameValue()
+ self.visitChildren(ctx)
+
+ Guid = ctx.guidDefinition().Guid
+ HasVarStoreId = False
+ VarStoreId = EFI_VARSTORE_ID_INVALID
+
+ if ctx.VarId() != None:
+ HasVarStoreId = True
+ VarStoreId = self.__TransNum(ctx.ID.text)
+ self.__CompareErrorHandler(VarStoreId !=0, True, ctx.ID.line, ctx.ID.text, 'varid 0 is not allowed')
+
+ StoreName = ctx.SN.text
+ Created = False
+
+ sIndex = 0 if HasVarStoreId == False else 1
+ eIndex = len(ctx.Name())
+ for i in range(sIndex, eIndex):
+ if Created == False:
+ self.__ErrorHandler(gCVfrDataStorage.DeclareNameVarStoreBegin(StoreName, VarStoreId), ctx.SN.line, ctx.SN.text)
+ Created = True
+ Item = self.__TransNum(ctx.Number(i))
+ gCVfrDataStorage.NameTableAddItem(Item)
+
+ gCVfrDataStorage.DeclareNameVarStoreEnd(Guid)
+
+ VSNVObj.SetLineNo(ctx.start.line)
+ VSNVObj.SetGuid(Guid)
+ VarstoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(StoreName, Guid)
+ self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
+ VSNVObj.SetVarStoreId(VarstoreId)
+
+ ctx.Node.Data = VSNVObj
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDisableIfFormSet.
+ def visitVfrStatementDisableIfFormSet(self, ctx:VfrSyntaxParser.VfrStatementDisableIfFormSetContext):
+
+ DIObj = CIfrDisableIf()
+ DIObj.SetLineNo(ctx.start.line)
+ self.__ConstantOnlyInExpression = True
+ ctx.Node.Data = DIObj
+ Condition = 'disableif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ ctx.Node.Condition = Condition
+ self.visitChildren(ctx)
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfFormSet.
+ def visitVfrStatementSuppressIfFormSet(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfFormSetContext):
+
+ SIObj = CIfrSuppressIf()
+ SIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = SIObj
+ Condition = 'suppressif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ ctx.Node.Condition = Condition
+ self.visitChildren(ctx)
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#guidSubDefinition.
+ def visitGuidSubDefinition(self, ctx:VfrSyntaxParser.GuidSubDefinitionContext):
+
+ ctx.Guid.Data4[0] = self.__TransNum(ctx.Number(0))
+ ctx.Guid.Data4[1] = self.__TransNum(ctx.Number(1))
+ ctx.Guid.Data4[2] = self.__TransNum(ctx.Number(2))
+ ctx.Guid.Data4[3] = self.__TransNum(ctx.Number(3))
+ ctx.Guid.Data4[4] = self.__TransNum(ctx.Number(4))
+ ctx.Guid.Data4[5] = self.__TransNum(ctx.Number(5))
+ ctx.Guid.Data4[6] = self.__TransNum(ctx.Number(6))
+ ctx.Guid.Data4[7] = self.__TransNum(ctx.Number(7))
+
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#guidDefinition.
+ def visitGuidDefinition(self, ctx:VfrSyntaxParser.GuidDefinitionContext):
+
+ self.visitChildren(ctx)
+
+ ctx.Guid.Data1 = self.__TransNum(ctx.Number(0))
+ ctx.Guid.Data2 = self.__TransNum(ctx.Number(1))
+ ctx.Guid.Data3 = self.__TransNum(ctx.Number(2))
+
+ return None
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#getStringId.
+ def visitGetStringId(self, ctx:VfrSyntaxParser.GetStringIdContext):
+
+ ctx.StringId = self.__TransNum(ctx.Number())
+
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementHeader.
+ def visitVfrStatementHeader(self, ctx:VfrSyntaxParser.VfrStatementHeaderContext):
+
+ ctx.OpObj = ctx.parentCtx.OpObj
+ if ctx.OpObj != None:
+ Prompt = self.__TransNum(ctx.Number(0))
+ ctx.OpObj.SetPrompt(Prompt)
+ Help = self.__TransNum(ctx.Number(1))
+ ctx.OpObj.SetHelp(Help)
+
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionHeader.
+ def visitVfrQuestionHeader(self, ctx:VfrSyntaxParser.VfrQuestionHeaderContext):
+
+ ctx.OpObj = ctx.parentCtx.OpObj
+
+ return self.visitChildren(ctx)
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionBaseInfo.
+ def visitVfrQuestionBaseInfo(self, ctx:VfrSyntaxParser.VfrQuestionBaseInfoContext):
+
+ ctx.OpObj = ctx.parentCtx.OpObj
+
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_OTHER
+ ctx.BaseInfo.VarTotalSize = 0
+ ctx.BaseInfo.Info.VarOffset = EFI_VAROFFSET_INVALID
+ ctx.BaseInfo.VarStoreId = EFI_VARSTORE_ID_INVALID
+ ctx.BaseInfo.IsBitVar = False
+
+ QName = None
+ QId = EFI_QUESTION_ID_INVALID
+ ReturnCode = None
+
+ self.visitChildren(ctx)
+ if ctx.Name() != None:
+ QName = ctx.QN.text
+ ReturnCode = self.__CVfrQuestionDB.FindQuestionByName(QName)
+ self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_UNDEFINED, ctx.QN.line, ctx.QN.text, 'has already been used please used anther name')
+
+ VarIdStr = '' if ctx.VarId() == None else ctx.vfrStorageVarId().VarIdStr
+ if ctx.QuestionId() != None:
+ QId = self.__TransNum(ctx.ID.text)
+ ReturnCode = self.__CVfrQuestionDB.FindQuestionById(QId)
+ self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_UNDEFINED, ctx.ID.line, ctx.ID.text, 'has already been used please used anther number')
+
+ if ctx.QType == EFI_QUESION_TYPE.QUESTION_NORMAL:
+ if self.__IsCheckBoxOp:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_BOOLEAN
+ QId, ReturnCode = self.__CVfrQuestionDB.RegisterQuestion(QName, VarIdStr, QId)
+ self.__ErrorHandler(ReturnCode, ctx.start.line)
+
+ elif ctx.QType == EFI_QUESION_TYPE.QUESTION_DATE:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
+ QId, ReturnCode = self.__CVfrQuestionDB.RegisterNewDateQuestion(QName, VarIdStr, QId)
+ self.__ErrorHandler(ReturnCode, ctx.start.line)
+
+ elif ctx.QType == EFI_QUESION_TYPE.QUESTION_TIME:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
+ QId, ReturnCode = self.__CVfrQuestionDB.RegisterNewTimeQuestion(QName, VarIdStr, QId)
+ self.__ErrorHandler(ReturnCode, ctx.start.line)
+
+ elif ctx.QType == EFI_QUESION_TYPE.QUESTION_REF:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_REF
+ if VarIdStr != '': #stand for question with storage.
+ QId, ReturnCode = self.__CVfrQuestionDB.RegisterRefQuestion(QName, VarIdStr, QId)
+ self.__ErrorHandler(ReturnCode, ctx.start.line)
+ else:
+ QId, ReturnCode = self.__CVfrQuestionDB.RegisterQuestion(QName, None, QId)
+ self.__ErrorHandler(ReturnCode, ctx.start.line)
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, ctx.start.line)
+
+ self.__CurrQestVarInfo = ctx.BaseInfo
+
+ if ctx.OpObj != None:
+ ctx.OpObj.SetQuestionId(QId)
+ if ctx.BaseInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ ctx.OpObj.SetVarStoreInfo(ctx.BaseInfo)
+
+ return ctx.OpObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#questionheaderFlagsField.
+ def visitQuestionheaderFlagsField(self, ctx:VfrSyntaxParser.QuestionheaderFlagsFieldContext):
+
+ self.visitChildren(ctx)
+ if ctx.ReadOnlyFlag() != None:
+ ctx.QHFlag = 0x01
+
+ elif ctx.InteractiveFlag() != None:
+ ctx.QHFlag = 0x04
+
+ elif ctx.ResetRequiredFlag() != None:
+ ctx.QHFlag = 0x10
+
+ elif ctx.RestStyleFlag() != None:
+ ctx.QHFlag = 0x20
+
+ elif ctx.ReconnectRequiredFlag() != None:
+ ctx.QHFlag = 0x40
+
+ elif ctx.OptionOnlyFlag() != None:
+ gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.O.line, ctx.O.text)
+
+ elif ctx.NVAccessFlag() != None:
+ gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.N.line, ctx.N.text)
+
+ elif ctx.LateCheckFlag() != None:
+ gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text)
+
+ return ctx.QHFlag
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStorageVarIdRule1.
+ def visitVfrStorageVarIdRule1(self, ctx:VfrSyntaxParser.VfrStorageVarIdRule1Context):
+
+ self.visitChildren(ctx)
+
+ SName = ctx.SN1.text
+ ctx.VarIdStr += SName
+
+ Idx = self.__TransNum(ctx.I.text)
+ ctx.VarIdStr += '['
+ ctx.VarIdStr += ctx.I.text
+ ctx.VarIdStr += ']'
+
+ ctx.BaseInfo.VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(SName)
+ if ctx.CheckFlag or ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
+ self.__ErrorHandler(ReturnCode, ctx.SN1.line, ctx.SN1.text)
+ self.__ErrorHandler(gCVfrDataStorage.GetNameVarStoreInfo(ctx.BaseInfo, Idx), ctx.SN1.line, ctx.SN1.text)
+
+ return ctx.VarIdStr
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStorageVarIdRule2.
+ def visitVfrStorageVarIdRule2(self, ctx:VfrSyntaxParser.VfrStorageVarIdRule2Context):
+
+ self.visitChildren(ctx)
+
+ VarStr = '' # type.field
+ SName = ctx.SN2.text
+ ctx.VarIdStr += SName
+ ctx.BaseInfo.VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(SName)
+ if ctx.CheckFlag or ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
+ self.__ErrorHandler(ReturnCode, ctx.SN2.line, ctx.SN2.text)
+ VarStoreType = gCVfrDataStorage.GetVarStoreType(ctx.BaseInfo.VarStoreId)
+ if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS:
+ TName, ReturnCode2 = gCVfrDataStorage.GetBufferVarStoreDataTypeName(ctx.BaseInfo.VarStoreId)
+ self.__ErrorHandler(ReturnCode2, ctx.SN2.line, ctx.SN2.text)
+ VarStr += TName
+
+ Count = len(ctx.Dot())
+ for i in range(0, Count):
+ if ctx.CheckFlag or ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
+ cond = (VarStoreType != EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER) and (VarStoreType != EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS)
+ ReturnCode = VfrReturnCode.VFR_RETURN_EFIVARSTORE_USE_ERROR if cond else VfrReturnCode.VFR_RETURN_SUCCESS
+ self.__ErrorHandler(ReturnCode, ctx.SN2.line, ctx.SN2.text)
+
+ ctx.VarIdStr += '.'
+ VarStr += '.'
+ ctx.VarIdStr += ctx.arrayName(i).SubStr
+ VarStr += ctx.arrayName(i).SubStrZ
+
+ if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
+ self.__ErrorHandler(gCVfrDataStorage.GetEfiVarStoreInfo(ctx.BaseInfo), ctx.SN2.line, ctx.SN2.text)
+
+ elif VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS:
+ ctx.BaseInfo.Info.VarOffset, ctx.BaseInfo.VarType, ctx.BaseInfo.VarTotalSize, ctx.BaseInfo.IsBitVar, ReturnCode = gCVfrVarDataTypeDB.GetDataFieldInfo(VarStr)
+ self.__ErrorHandler(ReturnCode, ctx.SN2.line, VarStr)
+ VarGuid = gCVfrDataStorage.GetVarStoreGuid(ctx.BaseInfo.VarStoreId)
+ self.__ErrorHandler(gCVfrBufferConfig.Register(SName, VarGuid), ctx.SN2.line)
+ Dummy = self.gZeroEfiIfrTypeValue
+ ReturnCode = VfrReturnCode(gCVfrBufferConfig.Write(
+ 'a',
+ SName,
+ VarGuid,
+ None,
+ ctx.BaseInfo.VarType,
+ ctx.BaseInfo.Info.VarOffset,
+ ctx.BaseInfo.VarTotalSize,
+ Dummy)) # the definition of dummy is needed to check
+ self.__ErrorHandler(ReturnCode, ctx.SN2.line)
+ self.__ErrorHandler(gCVfrDataStorage.AddBufferVarStoreFieldInfo(ctx.BaseInfo), ctx.SN2.line)
+
+ return ctx.VarIdStr
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrConstantValueField.
+ def visitVfrConstantValueField(self, ctx:VfrSyntaxParser.VfrConstantValueFieldContext):
+ self.visitChildren(ctx)
+
+ IntDecStyle = False
+ if self.__CurrentMinMaxData != None and self.__CurrentMinMaxData.IsNumericOpcode():
+ NumericQst = CIfrNumeric(self.__CurrentQuestion) #
+ IntDecStyle = True if (NumericQst.GetNumericFlags() & EFI_IFR_DISPLAY) == 0 else False #
+
+ if ctx.TrueSymbol() != None:
+ ctx.Value.b = 1
+
+ elif ctx.FalseSymbol() != None:
+ ctx.Value.b = 0
+
+ elif ctx.One() != None:
+ ctx.Value.u8 = int(ctx.getText())
+
+ elif ctx.Ones() != None:
+ ctx.Value.u64 = int(ctx.getText())
+
+ elif ctx.Zero() != None:
+ ctx.Value.u8 = int(ctx.getText())
+
+ elif ctx.Colon() != []:
+ ctx.Value.time.Hour = self.__TransNum(ctx.Number(0))
+ ctx.Value.time.Minute = self.__TransNum(ctx.Number(1))
+ ctx.Value.time.Second = self.__TransNum(ctx.Number(2))
+
+ elif ctx.Slash() != []:
+ ctx.Value.date.Year = self.__TransNum(ctx.Number(0))
+ ctx.Value.date.Month = self.__TransNum(ctx.Number(1))
+ ctx.Value.date.Day = self.__TransNum(ctx.Number(2))
+
+ elif ctx.Semicolon() != []:
+ ctx.Value.ref.QuestionId = self.__TransNum(ctx.Number(0))
+ ctx.Value.ref.FormId = self.__TransNum(ctx.Number(1))
+ ctx.Value.ref.DevicePath = self.__TransNum(ctx.Number(2))
+ ctx.Value.ref.FormSetGuid = ctx.guidDefinition().Guid
+
+ elif ctx.StringToken() != None:
+ ctx.Value.string = self.__TransNum(ctx.Number(0))
+
+ elif ctx.OpenBrace() != None:
+ ctx.ListType = True
+ Type = self.__CurrQestVarInfo.VarType
+ for i in range(0, len(ctx.Number())):
+ TempValue = EFI_IFR_TYPE_VALUE()
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ TempValue.u8 = self.__TransNum(ctx.Number(i))
+ ctx.ValueList.append(TempValue)
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ TempValue.u16 = self.__TransNum(ctx.Number(i))
+ ctx.ValueList.append(TempValue)
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ TempValue.u32 = self.__TransNum(ctx.Number(i))
+ ctx.ValueList.append(TempValue)
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ TempValue.u64 = self.__TransNum(ctx.Number(i))
+ ctx.ValueList.append(TempValue)
+ else:
+ Negative = True if ctx.Negative() != None else False
+ # The value stored in bit fields is always set to UINT32 type.
+ if self.__CurrQestVarInfo.IsBitVar:
+ ctx.Value.u32 = self.__TransNum(ctx.Number(0))
+ else:
+ Type = self.__CurrQestVarInfo.VarType
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ ctx.Value.u8 = self.__TransNum(ctx.Number(0))
+ if IntDecStyle:
+ if Negative:
+ if ctx.Value.u8 > 0x80:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT8 type can't big than 0x7F, small than -0x80")
+ else:
+ if ctx.Value.u8 > 0x7F:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT8 type can't big than 0x7F, small than -0x80")
+ if Negative:
+ ctx.Value.u8 = ~ctx.Value.u8 + 1
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ ctx.Value.u16 = self.__TransNum(ctx.Number(0))
+ if IntDecStyle:
+ if Negative:
+ if ctx.Value.u16 > 0x8000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT16 type can't big than 0x7FFF, small than -0x8000")
+ else:
+ if ctx.Value.u16 > 0x7FFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT16 type can't big than 0x7FFF, small than -0x8000")
+ if Negative:
+ ctx.Value.u16 = ~ctx.Value.u16 + 1
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ ctx.Value.u32 = self.__TransNum(ctx.Number(0))
+ if IntDecStyle:
+ if Negative:
+ if ctx.Value.u32 > 0x80000000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT32 type can't big than 0x7FFFFFFF, small than -0x80000000")
+ else:
+ if ctx.Value.u32 > 0X7FFFFFFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT32 type can't big than 0x7FFFFFFF, small than -0x80000000")
+ if Negative:
+ ctx.Value.u32 = ~ctx.Value.u32 + 1
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ ctx.Value.u64 = self.__TransNum(ctx.Number(0))
+ if IntDecStyle:
+ if Negative:
+ if ctx.Value.u64 > 0x8000000000000000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000")
+ else:
+ if ctx.Value.u64 > 0x7FFFFFFFFFFFFFFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000")
+ if Negative:
+ ctx.Value.u64 = ~ctx.Value.u64 + 1
+
+ if Type == EFI_IFR_TYPE_BOOLEAN:
+ ctx.Value.b = self.__TransNum(ctx.Number(0))
+
+ if Type == EFI_IFR_TYPE_BOOLEAN:
+ ctx.Value.string = self.__TransNum(ctx.Number(0))
+
+ return ctx.Value, ctx.ValueList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrImageTag.
+ def visitVfrImageTag(self, ctx:VfrSyntaxParser.VfrImageTagContext):
+
+ IObj = CIfrImage()
+ self.visitChildren(ctx)
+ IObj.SetLineNo(ctx.start.line)
+ IObj.SetImageId(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = IObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrLockedTag.
+ def visitVfrLockedTag(self, ctx:VfrSyntaxParser.VfrLockedTagContext):
+
+ LObj=CIfrLocked()
+ self.visitChildren(ctx)
+ LObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = LObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatTag.
+ def visitVfrStatementStatTag(self, ctx:VfrSyntaxParser.VfrStatementStatTagContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrImageTag() != None:
+ ctx.Node = ctx.vfrImageTag().Node
+ else:
+ ctx.Node = ctx.vfrLockedTag().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatTagList.
+ def visitVfrStatementStatTagList(self, ctx:VfrSyntaxParser.VfrStatementStatTagListContext):
+
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrStatementStatTag():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrFormDefinition.
+ def visitVfrFormDefinition(self, ctx:VfrSyntaxParser.VfrFormDefinitionContext):
+
+ FObj = CIfrForm()
+ self.visitChildren(ctx)
+
+ FObj.SetLineNo(ctx.start.line)
+ FormId = self.__TransNum(ctx.Number(0))
+ FObj.SetFormId(FormId)
+ FormTitle = self.__TransNum(ctx.Number(1))
+ FObj.SetFormTitle(FormTitle)
+
+ ctx.Node.Data = FObj
+ for Ctx in ctx.vfrForm():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrForm.
+ def visitVfrForm(self, ctx:VfrSyntaxParser.VfrFormContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementImage() != None:
+ ctx.Node = ctx.vfrStatementImage().Node
+ if ctx.vfrStatementLocked() != None:
+ ctx.Node = ctx.vfrStatementLocked().Node
+ if ctx.vfrStatementRules() != None:
+ ctx.Node = ctx.vfrStatementRules().Node
+ if ctx.vfrStatementDefault() != None:
+ ctx.Node = ctx.vfrStatementDefault().Node
+ if ctx.vfrStatementStat() != None:
+ ctx.Node = ctx.vfrStatementStat().Node
+ if ctx.vfrStatementQuestions() != None:
+ ctx.Node = ctx.vfrStatementQuestions().Node
+ if ctx.vfrStatementConditional() != None:
+ ctx.Node = ctx.vfrStatementConditional().Node
+ if ctx.vfrStatementLabel() != None:
+ ctx.Node = ctx.vfrStatementLabel().Node
+ if ctx.vfrStatementBanner() != None:
+ ctx.Node = ctx.vfrStatementBanner().Node
+ if ctx.vfrStatementInvalid() != None:
+ ctx.Node = ctx.vfrStatementInvalid().Node
+ if ctx.vfrStatementExtension() != None:
+ ctx.Node = ctx.vfrStatementExtension().Node
+ if ctx.vfrStatementModal() != None:
+ ctx.Node = ctx.vfrStatementModal().Node
+ if ctx.vfrStatementRefreshEvent() != None:
+ ctx.Node = ctx.vfrStatementRefreshEvent().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrFormMapDefinition.
+ def visitVfrFormMapDefinition(self, ctx:VfrSyntaxParser.VfrFormMapDefinitionContext):
+
+ FMapObj = CIfrFormMap()
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ FMapObj.SetLineNo(Line)
+ self.__ErrorHandler(FMapObj.SetFormId(self.__TransNum(ctx.S1.text)), ctx.S1.line, ctx.S1.line)
+ FormMapMethodNumber = len(ctx.MapTitle())
+ if FormMapMethodNumber == 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'No MapMethod is set for FormMap!')
+ else:
+ for i in range(0, FormMapMethodNumber):
+ FMapObj.SetFormMapMethod(self.__TransNum(ctx.Number(i+1)), ctx.guidDefinition(i).Guid)
+ ctx.Node.Data = FMapObj
+ for Ctx in ctx.vfrForm():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementImage.
+ def visitVfrStatementImage(self, ctx:VfrSyntaxParser.VfrStatementImageContext):
+
+ self.visitChildren(ctx)
+ ctx.Node = ctx.vfrImageTag().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementLocked.
+ def visitVfrStatementLocked(self, ctx:VfrSyntaxParser.VfrStatementLockedContext):
+
+ self.visitChildren(ctx)
+ ctx.Node = ctx.vfrLockedTag().Node
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRules.
+ def visitVfrStatementRules(self, ctx:VfrSyntaxParser.VfrStatementRulesContext):
+
+ RObj = CIfrRule()
+ self.visitChildren(ctx)
+
+ RObj.SetLineNo(ctx.start.line)
+ RuleName = self.__TransId(ctx.StringIdentifier())
+ self.__CVfrRulesDB.RegisterRule(RuleName)
+ RObj.SetRuleId(self.__CVfrRulesDB.GetRuleId(RuleName))
+ ctx.Node.Data = RObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ # expression
+ # end rule
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStat.
+ def visitVfrStatementStat(self, ctx:VfrSyntaxParser.VfrStatementStatContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementSubTitle() != None:
+ ctx.Node = ctx.vfrStatementSubTitle().Node
+ if ctx.vfrStatementStaticText() != None:
+ ctx.Node = ctx.vfrStatementStaticText().Node
+ if ctx.vfrStatementCrossReference() != None:
+ ctx.Node = ctx.vfrStatementCrossReference().Node
+ return ctx.Node
+
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSubTitle.
+ def visitVfrStatementSubTitle(self, ctx:VfrSyntaxParser.VfrStatementSubTitleContext):
+
+ SObj = ctx.OpObj
+
+ Line = ctx.start.line
+ SObj.SetLineNo(Line)
+
+ Prompt = self.__TransNum(ctx.Number())
+ SObj.SetPrompt(Prompt)
+
+ self.visitChildren(ctx)
+
+ if ctx.vfrSubtitleFlags() != None:
+ SObj.SetFlags(ctx.vfrSubtitleFlags().SubFlags)
+
+ ctx.Node.Data = SObj
+ self.__InsertChild(ctx.Node, ctx.vfrStatementStatTagList())
+ # sequence question
+ for Ctx in ctx.vfrStatementSubTitleComponent():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSubTitleComponent.
+ def visitVfrStatementSubTitleComponent(self, ctx:VfrSyntaxParser.VfrStatementSubTitleComponentContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementQuestions() != None:
+ ctx.Node = ctx.vfrStatementQuestions().Node
+ elif ctx.vfrStatementStat() != None:
+ ctx.Node = ctx.vfrStatementStat().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrSubtitleFlags.
+ def visitVfrSubtitleFlags(self, ctx:VfrSyntaxParser.VfrSubtitleFlagsContext):
+
+ self.visitChildren(ctx)
+
+ for FlagsFieldCtx in ctx.subtitleFlagsField():
+ ctx.SubFlags |= FlagsFieldCtx.Flag
+
+ return None
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#subtitleFlagsField.
+ def visitSubtitleFlagsField(self, ctx:VfrSyntaxParser.SubtitleFlagsFieldContext):
+
+ if ctx.Number() != None:
+ ctx.Flag = self.__TransNum(ctx.Number())
+ else:
+ ctx.Flag = 0x01
+
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStaticText.
+ def visitVfrStatementStaticText(self, ctx:VfrSyntaxParser.VfrStatementStaticTextContext):
+
+ self.visitChildren(ctx)
+
+ QId = EFI_QUESTION_ID_INVALID
+ Help = self.__TransNum(ctx.S1.text)
+ Prompt = self.__TransNum(ctx.S2.text)
+ TxtTwo = EFI_STRING_ID_INVALID
+ if ctx.S3 != None:
+ TxtTwo = self.__TransNum(ctx.S3.text)
+
+ TextFlags = 0
+ for FlagsFieldCtx in ctx.staticTextFlagsField():
+ TextFlags |= FlagsFieldCtx.Flag
+
+ if TextFlags & EFI_IFR_FLAG_CALLBACK:
+ if TxtTwo != EFI_STRING_ID_INVALID:
+ gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_ACTION_WITH_TEXT_TWO, ctx.S3.line, ctx.S3.text)
+
+ AObj = CIfrAction()
+ QId, _ = self.__CVfrQuestionDB.RegisterQuestion(None, None, QId)
+ AObj.SetLineNo(ctx.F.line)
+ AObj.SetQuestionId(QId)
+ AObj.SetHelp(Help)
+ AObj.SetPrompt(Prompt)
+ self.__ErrorHandler(AObj.SetFlags(TextFlags), ctx.F.line)
+ if ctx.Key() != None:
+ Key = self.__TransNum(ctx.S4.text)
+ self.__AssignQuestionKey(AObj, Key)
+ ctx.Node.Data = AObj
+ ctx.Node.OpCode = EFI_IFR_ACTION_OP #
+
+ else:
+ TObj = CIfrText()
+ Line = ctx.start.line
+ TObj.SetLineNo(Line)
+ TObj.SetHelp(Help)
+ TObj.SetPrompt(Prompt)
+ TObj.SetTextTwo(TxtTwo)
+ ctx.Node.Data = TObj
+
+ return ctx.Node
+
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#staticTextFlagsField.
+ def visitStaticTextFlagsField(self, ctx:VfrSyntaxParser.StaticTextFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ ctx.Flag = self.__TransNum(ctx.N.text)
+ if ctx.Flag != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line)
+ else:
+
+ ctx.Flag = ctx.questionheaderFlagsField().QHFlag
+
+ return ctx.Flag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementCrossReference.
+ def visitVfrStatementCrossReference(self, ctx:VfrSyntaxParser.VfrStatementCrossReferenceContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementGoto() != None:
+ ctx.Node = ctx.vfrStatementGoto().Node
+ elif ctx.vfrStatementResetButton() != None:
+ ctx.Node = ctx.vfrStatementResetButton().Node
+ return ctx.Node
+
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGoto.
+ def visitVfrStatementGoto(self, ctx:VfrSyntaxParser.VfrStatementGotoContext):
+
+ RefType = 5
+ DevPath = EFI_STRING_ID_INVALID
+ QId = EFI_QUESTION_ID_INVALID
+ BitMask = 0
+ Line = ctx.start.line
+ R5Obj = CIfrRef5()
+ R5Obj.SetLineNo(Line)
+ ctx.OpObj = R5Obj
+ #ctx.OHObj = R5Obj
+
+ if ctx.DevicePath() != None:
+ RefType = 4
+ DevPath = self.__TransNum(ctx.Number(0))
+ FId = self.__TransNum(ctx.Number(1))
+ QId = self.__TransNum(ctx.Number(2))
+ R4Obj = CIfrRef4()
+ R4Obj.SetLineNo(Line)
+ R4Obj.SetDevicePath(DevPath)
+ R4Obj.SetFormId(FId)
+ R4Obj.SetQuestionId(QId)
+ ctx.OpObj = R4Obj
+ #ctx.OHObj = R4Obj
+
+ elif ctx.FormSetGuid() != None:
+ RefType = 3
+ FId = self.__TransNum(ctx.Number(0))
+ QId = self.__TransNum(ctx.Number(1))
+ R3Obj = CIfrRef3()
+ R3Obj.SetLineNo(Line)
+ R3Obj.SetFormId(FId)
+ R3Obj.SetQuestionId(QId)
+ ctx.OpObj = R3Obj
+ #ctx.OHObj = R3Obj
+
+ elif ctx.FormId() != None:
+ FId = self.__TransNum(ctx.Number(0))
+ RefType = 2
+ if ctx.QN != None:
+ Name = ctx.QN.text
+ QId, BitMask, _ = self.__CVfrQuestionDB.GetQuestionId(Name)
+ if QId == EFI_QUESTION_ID_INVALID:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNDEFINED, ctx.QN.line)
+ else:
+ QId = self.__TransNum(ctx.Number(1))
+ R2Obj = CIfrRef2()
+ R2Obj.SetLineNo(Line)
+ R2Obj.SetFormId(FId)
+ R2Obj.SetQuestionId(QId)
+ ctx.OpObj = R2Obj
+ # ctx.OHObj = R2Obj
+
+
+ elif str(ctx.getChild(1)) == str(ctx.Number(0)):
+ RefType = 1
+ FId = self.__TransNum(ctx.Number(0))
+ RObj = CIfrRef()
+ RObj.SetLineNo(Line)
+ RObj.SetFormId(FId)
+ ctx.OpObj = RObj
+ # ctx.OHObj = RObj
+
+ self.visitChildren(ctx)
+
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
+ self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_REF
+
+ if RefType == 4 or RefType == 3:
+ ctx.OpObj.SetFormSetId(ctx.guidDefinition().Guid)
+ # ctx.OHObj.SetFormSetId(ctx.guidDefinition().Guid)
+
+ if ctx.FLAGS() != None:
+ ctx.OpObj.SetFlags(ctx.vfrGotoFlags().GotoFlags)
+ # ctx.OHObj.SetFlags(ctx.vfrGotoFlags().GotoFlags)
+
+ if ctx.Key() != None:
+ index = int(len(ctx.Number())) - 1
+ Key = self.__TransNum(ctx.Number(index))
+ self.__AssignQuestionKey(ctx.OpObj, Key)
+
+ # ctx.OHObj.SetScope(1)
+ ctx.OpObj.SetScope(1)
+ ctx.Node.Data = ctx.OpObj
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrGotoFlags.
+ def visitVfrGotoFlags(self, ctx:VfrSyntaxParser.VfrGotoFlagsContext):
+
+ self.visitChildren(ctx)
+ for FlagsFieldCtx in ctx.gotoFlagsField():
+ ctx.GotoFlags |= FlagsFieldCtx.Flag
+
+ return ctx.GotoFlags
+
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#gotoFlagsField.
+ def visitGotoFlagsField(self, ctx:VfrSyntaxParser.GotoFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.N != None:
+ if self.__TransNum(ctx.N.text) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line)
+ else:
+ ctx.Flag = ctx.questionheaderFlagsField().QHFlag
+
+ return ctx.Flag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementResetButton.
+ def visitVfrStatementResetButton(self, ctx:VfrSyntaxParser.VfrStatementResetButtonContext):
+
+ self.visitChildren(ctx)
+
+ RBObj = ctx.OpObj
+ Line = ctx.start.line
+ RBObj.SetLineNo(Line)
+ defaultstore = ctx.N.text
+ DefaultId, ReturnCode = gCVfrDefaultStore.GetDefaultId(defaultstore)
+ self.__ErrorHandler(ReturnCode, ctx.N.line)
+ RBObj.SetDefaultId(DefaultId)
+
+ ctx.Node.Data = RBObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestions.
+ def visitVfrStatementQuestions(self, ctx:VfrSyntaxParser.VfrStatementQuestionsContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementBooleanType() != None:
+ ctx.Node = ctx.vfrStatementBooleanType().Node
+ if ctx.vfrStatementDate() != None:
+ ctx.Node = ctx.vfrStatementDate().Node
+ if ctx.vfrStatementNumericType() != None:
+ ctx.Node = ctx.vfrStatementNumericType().Node
+ if ctx.vfrStatementStringType() != None:
+ ctx.Node = ctx.vfrStatementStringType().Node
+ if ctx.vfrStatementOrderedList() != None:
+ ctx.Node = ctx.vfrStatementOrderedList().Node
+ if ctx.vfrStatementTime() != None:
+ ctx.Node = ctx.vfrStatementTime().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionTag.
+ def visitVfrStatementQuestionTag(self, ctx:VfrSyntaxParser.VfrStatementQuestionTagContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementStatTag() != None:
+ ctx.Node = ctx.vfrStatementStatTag().Node
+ if ctx.vfrStatementInconsistentIf() != None:
+ ctx.Node = ctx.vfrStatementInconsistentIf().Node
+ if ctx.vfrStatementNoSubmitIf() != None:
+ ctx.Node = ctx.vfrStatementNoSubmitIf().Node
+ if ctx.vfrStatementDisableIfQuest() != None:
+ ctx.Node = ctx.vfrStatementDisableIfQuest().Node
+ if ctx.vfrStatementRefresh() != None:
+ ctx.Node = ctx.vfrStatementRefresh().Node
+ if ctx.vfrStatementVarstoreDevice() != None:
+ ctx.Node = ctx.vfrStatementVarstoreDevice().Node
+ if ctx.vfrStatementExtension() != None:
+ ctx.Node = ctx.vfrStatementExtension().Node
+ if ctx.vfrStatementRefreshEvent() != None:
+ ctx.Node = ctx.vfrStatementRefreshEvent().Node
+ if ctx.vfrStatementWarningIf() != None:
+ ctx.Node = ctx.vfrStatementWarningIf().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInconsistentIf.
+ def visitVfrStatementInconsistentIf(self, ctx:VfrSyntaxParser.VfrStatementInconsistentIfContext):
+
+ IIObj = CIfrInconsistentIf()
+ self.visitChildren(ctx)
+
+ IIObj.SetLineNo(ctx.start.line)
+ IIObj.SetError(self.__TransNum(ctx.Number()))
+
+ ctx.Node.Data = IIObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementNoSubmitIf.
+ def visitVfrStatementNoSubmitIf(self, ctx:VfrSyntaxParser.VfrStatementNoSubmitIfContext):
+ NSIObj = CIfrNoSubmitIf()
+ self.visitChildren(ctx)
+
+ NSIObj.SetLineNo(ctx.start.line)
+ NSIObj.SetError(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = NSIObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDisableIfQuest.
+ def visitVfrStatementDisableIfQuest(self, ctx:VfrSyntaxParser.VfrStatementDisableIfQuestContext):
+ DIObj = CIfrDisableIf()
+ self.visitChildren(ctx)
+
+ DIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = DIObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRefresh.
+ def visitVfrStatementRefresh(self, ctx:VfrSyntaxParser.VfrStatementRefreshContext):
+ RObj = CIfrRefresh()
+ self.visitChildren(ctx)
+
+ RObj.SetLineNo(ctx.start.line)
+ RObj.SetRefreshInterval(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = RObj
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarstoreDevice.
+ def visitVfrStatementVarstoreDevice(self, ctx:VfrSyntaxParser.VfrStatementVarstoreDeviceContext):
+ VDObj = CIfrVarStoreDevice()
+ self.visitChildren(ctx)
+
+ VDObj.SetLineNo(ctx.start.line)
+ VDObj.SetDevicePath(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = VDObj
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRefreshEvent.
+ def visitVfrStatementRefreshEvent(self, ctx:VfrSyntaxParser.VfrStatementRefreshEventContext):
+ RiObj = CIfrRefreshId()
+ self.visitChildren(ctx)
+
+ RiObj.SetLineNo(ctx.start.line)
+ RiObj.SetRefreshEventGroutId(ctx.guidDefinition().Guid)
+ ctx.Node.Data = RiObj
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementWarningIf.
+ def visitVfrStatementWarningIf(self, ctx:VfrSyntaxParser.VfrStatementWarningIfContext):
+ WIObj = CIfrWarningIf()
+ self.visitChildren(ctx)
+
+ WIObj.SetLineNo(ctx.start.line)
+ WIObj.SetWarning(self.__TransNum(ctx.Number(0)))
+ WIObj.SetTimeOut(self.__TransNum(ctx.Number(1)))
+ ctx.Node.Data = WIObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionTagList.
+ def visitVfrStatementQuestionTagList(self, ctx:VfrSyntaxParser.VfrStatementQuestionTagListContext):
+
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrStatementQuestionTag():
+ self.__InsertChild(ctx.Node, Ctx)
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionOptionTag.
+ def visitVfrStatementQuestionOptionTag(self, ctx:VfrSyntaxParser.VfrStatementQuestionOptionTagContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementSuppressIfQuest() != None:
+ ctx.Node = ctx.vfrStatementSuppressIfQuest().Node
+
+ if ctx.vfrStatementGrayOutIfQuest() != None:
+ ctx.Node = ctx.vfrStatementGrayOutIfQuest().Node
+
+ if ctx.vfrStatementValue() != None:
+ ctx.Node = ctx.vfrStatementValue().Node
+
+ if ctx.vfrStatementDefault() != None:
+ ctx.Node = ctx.vfrStatementDefault().Node
+
+ if ctx.vfrStatementOptions() != None:
+ ctx.Node = ctx.vfrStatementOptions().Node
+
+ if ctx.vfrStatementRead() != None:
+ ctx.Node = ctx.vfrStatementRead().Node
+
+ if ctx.vfrStatementWrite() != None:
+ ctx.Node = ctx.vfrStatementWrite().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfQuest.
+ def visitVfrStatementSuppressIfQuest(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfQuestContext):
+
+ SIObj = CIfrSuppressIf()
+ SIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = SIObj
+ ctx.Node.Condition = 'suppressif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ self.visitChildren(ctx)
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGrayOutIfQuest.
+ def visitVfrStatementGrayOutIfQuest(self, ctx:VfrSyntaxParser.VfrStatementGrayOutIfQuestContext):
+ GOIObj = CIfrGrayOutIf()
+ GOIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = GOIObj
+ ctx.Node.Condition = 'grayoutif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ self.visitChildren(ctx)
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#flagsField.
+ def visitFlagsField(self, ctx:VfrSyntaxParser.FlagsFieldContext):
+
+ if ctx.N != None:
+ CVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.N.line, ctx.N.text)
+ if ctx.L != None:
+ CVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text)
+
+ return self.visitChildren(ctx)
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDefault.
+ def visitVfrStatementDefault(self, ctx:VfrSyntaxParser.VfrStatementDefaultContext):
+
+ self.visitChildren(ctx)
+ IsExp = False
+ DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD
+ Line = ctx.start.line
+
+ if ctx.vfrConstantValueField() != None:
+ Value = ctx.vfrConstantValueField().Value
+ ValueList = ctx.vfrConstantValueField().ValueList
+ Type = self.__CurrQestVarInfo.VarType
+ Size = 0
+
+ if self.__CurrentMinMaxData != None and self.__CurrentMinMaxData.IsNumericOpcode():
+ # check default value is valid for Numeric Opcode
+ if ValueList == []:
+ ValueList.append(Value)
+ for i in range(0, len(ValueList)):
+ Value = ValueList[i]
+ NumericQst = CIfrNumeric (self.__CurrentQuestion) #
+ if (NumericQst.GetNumericFlags() & EFI_IFR_DISPLAY) == 0 and self.__CurrQestVarInfo.IsBitVar == False: #
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ if Value.u8 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u8 > self.__CurrentMinMaxData.GetMaxData(Type, False):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ if Value.u16 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u16 > self.__CurrentMinMaxData.GetMaxData(Type, False):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ if Value.u32 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u32 > self.__CurrentMinMaxData.GetMaxData(Type, False):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ if Value.u64 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u64 > self.__CurrentMinMaxData.GetMaxData(Type, False):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
+
+ else:
+ # Value for question stored in bit fields is always set to UINT32 type.
+ if self.__CurrQestVarInfo.IsBitVar:
+ if Value.u32 < self.__CurrentMinMaxData.GetMinData(Type, True) or Value.u32 > self.__CurrentMinMaxData.GetMaxData(Type, True):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
+ else:
+ if Value.u64 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u64 > self.__CurrentMinMaxData.GetMaxData(Type, False):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
+
+ if Type == EFI_IFR_TYPE_OTHER:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, "Default data type error.")
+ Size = sizeof(EFI_IFR_TYPE_VALUE)
+
+ elif ctx.vfrConstantValueField().ListType:
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ Size = sizeof(c_ubyte) * len(ValueList)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ Size = sizeof(c_ushort) * len(ValueList)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ Size = sizeof(c_ulong) * len(ValueList)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ Size = sizeof(c_ulonglong) * len(ValueList)
+
+ else:
+ if self.__CurrQestVarInfo.IsBitVar:
+ Size = sizeof(c_ulong)
+ else:
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(Type)
+ self.__ErrorHandler(ReturnCode, Line)
+
+ Size += EFI_IFR_DEFAULT.Value.offset
+ if not ctx.vfrConstantValueField().ListType:
+ DObj = CIfrDefault(Size)
+ DObj.SetLineNo(Line)
+ DObj.SetValue(Value)
+
+ if self.__IsStringOp:
+ DObj.SetType(EFI_IFR_TYPE_STRING)
+ else:
+ if self.__CurrQestVarInfo.IsBitVar:
+ DObj.SetType(EFI_IFR_TYPE_NUM_SIZE_32)
+ else:
+ DObj.SetType(self.__CurrQestVarInfo.VarType)
+ else:
+ DObj = CIfrDefault3(Size, len(ValueList), Type)
+ DObj.SetLineNo(Line)
+ DObj.SetValue(ValueList)
+ DObj.SetType(EFI_IFR_TYPE_BUFFER)
+
+ else:
+ IsExp = True
+ DObj = CIfrDefault2()
+ DObj.SetLineNo(Line)
+ DObj.SetScope(1)
+
+ if ctx.DefaultStore() != None:
+ DefaultId, ReturnCode = gCVfrDefaultStore.GetDefaultId(ctx.SN.text)
+ self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
+ DObj.SetDefaultId(DefaultId)
+
+ self.__CheckDuplicateDefaultValue(DefaultId, ctx.D.line, ctx.D.text)
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ VarStoreName, ReturnCode = gCVfrDataStorage.GetVarStoreName(self.__CurrQestVarInfo.VarStoreId)
+ self.__ErrorHandler(ReturnCode, Line)
+ VarGuid = gCVfrDataStorage.GetVarStoreGuid(self.__CurrQestVarInfo.VarStoreId)
+ VarStoreType = gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId)
+ if (IsExp == False) and (VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER):
+ self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(DefaultId, self.__CurrQestVarInfo, VarStoreName, VarGuid, self.__CurrQestVarInfo.VarType, Value), Line)
+ ctx.Node.Data = DObj
+ self.__InsertChild(ctx.Node, ctx.vfrStatementValue())
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementValue.
+ def visitVfrStatementValue(self, ctx:VfrSyntaxParser.VfrStatementValueContext):
+
+ VObj = CIfrValue()
+ self.visitChildren(ctx)
+
+ VObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = VObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOptions.
+ def visitVfrStatementOptions(self, ctx:VfrSyntaxParser.VfrStatementOptionsContext):
+
+ self.visitChildren(ctx)
+ ctx.Node = ctx.vfrStatementOneOfOption().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOneOfOption.
+ def visitVfrStatementOneOfOption(self, ctx:VfrSyntaxParser.VfrStatementOneOfOptionContext):
+
+ Line = ctx.start.line
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, "Get data type error.")
+
+ self.visitChildren(ctx)
+
+ Value = ctx.vfrConstantValueField().Value
+ ValueList = ctx.vfrConstantValueField().ValueList
+ Type = self.__CurrQestVarInfo.VarType
+ Size = 0
+ if self.__CurrentMinMaxData != None:
+ #set min/max value for oneof opcode
+ Step = self.__CurrentMinMaxData.GetStepData(self.__CurrQestVarInfo.VarType, self.__CurrQestVarInfo.IsBitVar)
+ if self.__CurrQestVarInfo.IsBitVar:
+ self.__CurrentMinMaxData.SetMinMaxStepData(Value.u32, Value.u32, Step, EFI_IFR_TYPE_NUM_SIZE_32)
+ else:
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ self.__CurrentMinMaxData.SetMinMaxStepData(Value.u64, Value.u64, Step, EFI_IFR_TYPE_NUM_SIZE_64)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ self.__CurrentMinMaxData.SetMinMaxStepData(Value.u32, Value.u32, Step, EFI_IFR_TYPE_NUM_SIZE_32)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ self.__CurrentMinMaxData.SetMinMaxStepData(Value.u16, Value.u16, Step, EFI_IFR_TYPE_NUM_SIZE_16)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ self.__CurrentMinMaxData.SetMinMaxStepData(Value.u8, Value.u8, Step, EFI_IFR_TYPE_NUM_SIZE_8)
+
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
+ Size = sizeof(EFI_IFR_TYPE_VALUE)
+ elif ctx.vfrConstantValueField().ListType:
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ Size = sizeof(c_ubyte) * len(ValueList)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ Size = sizeof(c_ushort) * len(ValueList)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ Size = sizeof(c_ulong) * len(ValueList)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ Size = sizeof(c_ulonglong) * len(ValueList)
+ else:
+ # For the oneof stored in bit fields, set the option type as UINT32.
+ if self.__CurrQestVarInfo.IsBitVar:
+ Size = sizeof(c_long)
+ else:
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(Type)
+ self.__ErrorHandler(ReturnCode, Line)
+
+ Size += EFI_IFR_ONE_OF_OPTION.Value.offset
+ OOOObj = None
+ if not ctx.vfrConstantValueField().ListType:
+ OOOObj = CIfrOneOfOption(Size)
+ if self.__CurrQestVarInfo.IsBitVar:
+ OOOObj.SetType(EFI_IFR_TYPE_NUM_SIZE_32)
+ else:
+ OOOObj.SetType(Type)
+ OOOObj.SetValue(Value)
+ else:
+ OOOObj = CIfrOneOfOption2(Size, len(ValueList), Type)
+ OOOObj.SetType(EFI_IFR_TYPE_BUFFER)
+ OOOObj.SetValue(ValueList)
+
+
+ OOOObj.SetLineNo(Line)
+ OOOObj.SetOption(self.__TransNum(ctx.Number(0)))
+
+
+ self.__ErrorHandler(OOOObj.SetFlags(ctx.vfrOneOfOptionFlags().LFlags), ctx.F.line)
+ self.__ErrorHandler(self.__CurrentQuestion.SetQHeaderFlags(ctx.vfrOneOfOptionFlags().HFlags), ctx.F.line)
+
+ # Array type only for default type OneOfOption.
+ if (OOOObj.GetFlags() & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) == 0 and (ctx.vfrConstantValueField().ListType):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, "Default keyword should with array value type!")
+
+ # Clear the default flag if the option not use array value but has default flag.
+ if (OOOObj.GetFlags() & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) != 0 and (ctx.vfrConstantValueField().ListType == False) and (self.__IsOrderedList):
+ OOOObj.SetFlags(OOOObj.GetFlags() & ~(EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG))
+
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ VarStoreName, ReturnCode = gCVfrDataStorage.GetVarStoreName(self.__CurrQestVarInfo.VarStoreId)
+ self.__ErrorHandler(ReturnCode, Line)
+ VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(self.__CurrQestVarInfo.VarStoreId)
+ if OOOObj.GetFlags() & EFI_IFR_OPTION_DEFAULT:
+ self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_STANDARD, ctx.F.line, ctx.F.text)
+ self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_STANDARD, self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, Value), Line)
+ if OOOObj.GetFlags() & EFI_IFR_OPTION_DEFAULT_MFG:
+ self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_MANUFACTURING, ctx.F.line, ctx.F.text)
+ self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_MANUFACTURING, self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, Value), Line)
+
+ if ctx.Key() != None:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.KN.line, ctx.KN.text)
+ # Guid Option Key
+ IfrOptionKey = CIfrOptionKey(self.__CurrentQuestion.GetQuestionId(), Value, self.__TransNum(ctx.KN.text))
+ IfrOptionKey.SetLineNo()
+ if ctx.vfrImageTag() != None:
+ OOOObj.SetScope(1) #
+ ctx.Node.Data = OOOObj
+ for Ctx in ctx.vfrImageTag():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrOneOfOptionFlags.
+ def visitVfrOneOfOptionFlags(self, ctx:VfrSyntaxParser.VfrOneOfOptionFlagsContext):
+
+ self.visitChildren(ctx)
+
+ ctx.LFlags = self.__CurrQestVarInfo.VarType
+ for FlagsFieldCtx in ctx.oneofoptionFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+ ctx.LFlags |= FlagsFieldCtx.LFlag
+
+ return ctx.HFlags, ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#oneofoptionFlagsField.
+ def visitOneofoptionFlagsField(self, ctx:VfrSyntaxParser.OneofoptionFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ ctx.LFlag = self.__TransNum(ctx.Number())
+ if ctx.OptionDefault() != None:
+ ctx.LFlag = 0x10
+ if ctx.OptionDefaultMfg() != None:
+ ctx.LFlag = 0x20
+ if ctx.InteractiveFlag() != None:
+ ctx.HFlag = 0x04
+ if ctx.ResetRequiredFlag() != None:
+ ctx.HFlag = 0x10
+ if ctx.RestStyleFlag() != None:
+ ctx.HFlag = 0x20
+ if ctx.ReconnectRequiredFlag() != None:
+ ctx.HFlag = 0x40
+ if ctx.ManufacturingFlag() != None:
+ ctx.LFlag = 0x20
+ if ctx.DefaultFlag() != None:
+ ctx.LFlag = 0x10
+ if ctx.NVAccessFlag() != None:
+ gCVfrErrorHandle.HandleWarning (EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.A.line, ctx.A.text)
+ if ctx.LateCheckFlag() != None:
+ gCVfrErrorHandle.HandleWarning (EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text)
+
+ return ctx.HFlag, ctx.LFlag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRead.
+ def visitVfrStatementRead(self, ctx:VfrSyntaxParser.VfrStatementReadContext):
+
+ RObj = CIfrRead()
+ self.visitChildren(ctx)
+
+ RObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = RObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementWrite.
+ def visitVfrStatementWrite(self, ctx:VfrSyntaxParser.VfrStatementWriteContext):
+
+ WObj = CIfrWrite()
+ self.visitChildren(ctx)
+
+ WObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = WObj
+ ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionOptionList.
+ def visitVfrStatementQuestionOptionList(self, ctx:VfrSyntaxParser.VfrStatementQuestionOptionListContext):
+
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrStatementQuestionOption():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionOption.
+ def visitVfrStatementQuestionOption(self, ctx:VfrSyntaxParser.VfrStatementQuestionOptionContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementQuestionTag() != None:
+ ctx.Node = ctx.vfrStatementQuestionTag().Node
+
+ elif ctx.vfrStatementQuestionOptionTag() != None:
+ ctx.Node = ctx.vfrStatementQuestionOptionTag().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementBooleanType.
+ def visitVfrStatementBooleanType(self, ctx:VfrSyntaxParser.VfrStatementBooleanTypeContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementCheckBox() != None:
+ ctx.Node = ctx.vfrStatementCheckBox().Node
+ else:
+ ctx.Node = ctx.vfrStatementAction().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementCheckBox.
+ def visitVfrStatementCheckBox(self, ctx:VfrSyntaxParser.VfrStatementCheckBoxContext):
+
+ CBObj = ctx.OpObj
+ Line = ctx.start.line
+ CBObj.SetLineNo(Line)
+ self.__CurrentQuestion = CBObj.GetQuestion()
+ self.__IsCheckBoxOp = True
+
+ self.visitChildren(ctx)
+
+ # Create a GUID opcode to wrap the checkbox opcode, if it refer to bit varstore.
+ if self.__CurrQestVarInfo.IsBitVar:
+ GuidObj = CIfrGuid(0)
+ GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
+ GuidObj.SetLineNo(Line)
+ GuidObj.SetScope(1) #
+
+ # check dataType
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
+ self.__CurrQestVarInfo.VarType = EFI_IFR_TYPE_BOOLEAN
+
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ # Check whether the question refers to a bit field, if yes. create a Guid to indicate the question refers to a bit field.
+ if self.__CurrQestVarInfo.IsBitVar:
+ _, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, "CheckBox varid is not the valid data type")
+ if gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS and self.__CurrQestVarInfo.VarTotalSize != 1:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "CheckBox varid only occupy 1 bit in Bit Varstore")
+ else:
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, "CheckBox varid is not the valid data type")
+ if Size != 0 and Size != self.__CurrQestVarInfo.VarTotalSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "CheckBox varid doesn't support array")
+ elif gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER and self.__CurrQestVarInfo.VarTotalSize != sizeof(ctypes.c_bool):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "CheckBox varid only support BOOLEAN data type")
+
+ if ctx.FLAGS() != None:
+ CBObj.SetFlags(ctx.vfrCheckBoxFlags().HFlags, ctx.vfrCheckBoxFlags().LFlags)
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ VarStoreName, ReturnCode = gCVfrDataStorage.GetVarStoreName(self.__CurrQestVarInfo.VarStoreId)
+ self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_SUCCESS, Line, ctx.L.text, "Failed to retrieve varstore name")
+
+ VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(self.__CurrQestVarInfo.VarStoreId)
+ self.gZeroEfiIfrTypeValue.b = True
+ if CBObj.GetFlags() & 0x01:
+ self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_STANDARD, ctx.F.line, ctx.F.text)
+ ReturnCode = gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_STANDARD,self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, self.gZeroEfiIfrTypeValue)
+ self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_SUCCESS, Line, ctx.L.text, "No standard default storage found")
+ if CBObj.GetFlags() & 0x02:
+ self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_MANUFACTURING, ctx.F.line, ctx.F.text)
+ ReturnCode = gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_MANUFACTURING, self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, self.gZeroEfiIfrTypeValue)
+ self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_SUCCESS, Line, ctx.L.text, "No manufacturing default storage found")
+ if ctx.Key() != None:
+ Key = self.__TransNum(ctx.Number())
+ self.__AssignQuestionKey(CBObj, Key)
+
+ ctx.Node.Data = CBObj
+ self.__IsCheckBoxOp = False
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrCheckBoxFlags.
+ def visitVfrCheckBoxFlags(self, ctx:VfrSyntaxParser.VfrCheckBoxFlagsContext):
+
+ self.visitChildren(ctx)
+ for FlagsFieldCtx in ctx.checkboxFlagsField():
+ ctx.LFlags |= FlagsFieldCtx.LFlag
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+
+ return ctx.HFlags, ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#checkboxFlagsField.
+ def visitCheckboxFlagsField(self, ctx:VfrSyntaxParser.CheckboxFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ if self.__TransNum(ctx.Number()) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
+ elif ctx.DefaultFlag() != None:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.D.line, ctx.D.text)
+ elif ctx.ManufacturingFlag() != None:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.M.line, ctx.M.text)
+ elif ctx.CheckBoxDefaultFlag() != None:
+ ctx.LFlag = 0x01
+ elif ctx.CheckBoxDefaultMfgFlag() != None:
+ ctx.LFlag = 0x02
+ else:
+ ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
+
+ return ctx.HFlag, ctx.LFlag
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementAction.
+ def visitVfrStatementAction(self, ctx:VfrSyntaxParser.VfrStatementActionContext):
+
+ self.visitChildren(ctx)
+ AObj = ctx.OpObj
+ AObj.SetLineNo(ctx.start.line)
+ AObj.SetQuestionConfig(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = AObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrActionFlags.
+ def visitVfrActionFlags(self, ctx:VfrSyntaxParser.VfrActionFlagsContext):
+
+ self.visitChildren(ctx)
+ for FlagsFieldCtx in ctx.actionFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+
+ return ctx.HFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#actionFlagsField.
+ def visitActionFlagsField(self, ctx:VfrSyntaxParser.ActionFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ if self.__TransNum(ctx.Number()) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line)
+ else:
+ ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
+ return ctx.HFlag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementNumericType.
+ def visitVfrStatementNumericType(self, ctx:VfrSyntaxParser.VfrStatementNumericTypeContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementNumeric() != None:
+ ctx.Node = ctx.vfrStatementNumeric().Node
+ elif ctx.vfrStatementOneOf() != None:
+ ctx.Node = ctx.vfrStatementOneOf().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxP-arser#vfrStatementNumeric.
+ def visitVfrStatementNumeric(self, ctx:VfrSyntaxParser.VfrStatementNumericContext):
+
+ self.visitChildren(ctx)
+ NObj = ctx.OpObj
+ NObj.SetLineNo(ctx.start.line)
+ self.__CurrentQuestion = NObj.GetQuestion()
+ Line = ctx.start.line
+
+ if self.__CurrQestVarInfo.IsBitVar:
+ GuidObj = CIfrGuid(0)
+ GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
+ GuidObj.SetLineNo(Line)
+ GuidObj.SetScope(1) # pos
+
+ # check data type
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ if self.__CurrQestVarInfo.IsBitVar:
+ LFlags = EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
+ self.__ErrorHandler(NObj.SetFlagsForBitField(NObj.GetFlags(),LFlags), Line)
+ else:
+ DataTypeSize, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, 'Numeric varid is not the valid data type')
+ if DataTypeSize != 0 and DataTypeSize != self.__CurrQestVarInfo.VarTotalSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric varid doesn\'t support array')
+ self.__ErrorHandler(NObj.SetFlags(NObj.GetFlags(), self.__CurrQestVarInfo.VarType), Line)
+
+
+ if ctx.FLAGS() != None:
+ if self.__CurrQestVarInfo.IsBitVar:
+ self.__ErrorHandler(NObj.SetFlagsForBitField(ctx.vfrNumericFlags().HFlags,ctx.vfrNumericFlags().LFlags, ctx.vfrNumericFlags().IsDisplaySpecified), ctx.F.line)
+ else:
+ self.__ErrorHandler(NObj.SetFlags(ctx.vfrNumericFlags().HFlags,ctx.vfrNumericFlags().LFlags, ctx.vfrNumericFlags().IsDisplaySpecified), ctx.F.line)
+
+ if ctx.Key() != None:
+ Key = self.__TransNum(ctx.Number())
+ self.__AssignQuestionKey(NObj,Key)
+
+ ShrinkSize = 0
+ IsSupported = True
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ Type = self.__CurrQestVarInfo.VarType
+ # Base on the type to know the actual used size, shrink the buffer size allocate before.
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ ShrinkSize = 21
+ elif Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ ShrinkSize = 18
+ elif Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ ShrinkSize = 12
+ elif Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ ShrinkSize = 0
+ else:
+ IsSupported = False
+ else:
+ # Question stored in bit fields saved as UINT32 type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
+ ShrinkSize = 12
+
+ ####### NObj->ShrinkBinSize (ShrinkSize);
+ if IsSupported == False:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type.')
+
+ ctx.Node.Data = NObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrSetMinMaxStep.
+ def visitVfrSetMinMaxStep(self, ctx:VfrSyntaxParser.VfrSetMinMaxStepContext):
+ IntDecStyle = False
+ if ((self.__CurrQestVarInfo.IsBitVar) and (ctx.OpObj.GetOpCode() == EFI_IFR_NUMERIC_OP) and ((ctx.OpObj.GetNumericFlags() & EDKII_IFR_DISPLAY_BIT) == 0)) or \
+ ((self.__CurrQestVarInfo.IsBitVar == False) and (ctx.OpObj.GetOpCode() == EFI_IFR_NUMERIC_OP) and ((ctx.OpObj.GetNumericFlags() & EFI_IFR_DISPLAY) == 0)):
+ IntDecStyle = True
+ MinNegative = False
+ MaxNegative = False
+
+ self.visitChildren(ctx)
+
+ Min = self.__TransNum(ctx.I.text)
+ Max = self.__TransNum(ctx.A.text)
+ Step = self.__TransNum(ctx.S.text) if ctx.Step() != None else 0
+
+ if ctx.N1 !=None:
+ MinNegative = True
+
+ if IntDecStyle == False and MinNegative == True:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, '\'-\' can\'t be used when not in int decimal type.')
+ if self.__CurrQestVarInfo.IsBitVar:
+ if (IntDecStyle == False) and (Min > (1 << self.__CurrQestVarInfo.VarTotalSize) - 1): #
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'BIT type minimum can\'t small than 0, bigger than 2^BitWidth -1')
+ else:
+ Type = self.__CurrQestVarInfo.VarType
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ if IntDecStyle:
+ if MinNegative:
+ if Min > 0x8000000000000000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
+ else:
+ if Min > 0x7FFFFFFFFFFFFFFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
+ if MinNegative:
+ Min = ~Min + 1
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ if IntDecStyle:
+ if MinNegative:
+ if Min > 0x80000000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
+ else:
+ if Min > 0x7FFFFFFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
+ if MinNegative:
+ Min = ~Min + 1
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ if IntDecStyle:
+ if MinNegative:
+ if Min > 0x8000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
+ else:
+ if Min > 0x7FFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
+ if MinNegative:
+ Min = ~Min + 1
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ if IntDecStyle:
+ if MinNegative:
+ if Min > 0x80:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
+ else:
+ if Min > 0x7F:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
+ if MinNegative:
+ Min = ~Min + 1
+
+ if ctx.N2 != None:
+ MaxNegative = True
+ if IntDecStyle == False and MaxNegative == True:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, ' \'-\' can\'t be used when not in int decimal type.')
+ if self.__CurrQestVarInfo.IsBitVar:
+ if (IntDecStyle == False) and (Max > (1 << self.__CurrQestVarInfo.VarTotalSize) - 1):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'BIT type maximum can\'t be bigger than 2^BitWidth -1')
+ else:
+ Type = self.__CurrQestVarInfo.VarType
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ if IntDecStyle:
+ if MaxNegative:
+ if Max > 0x8000000000000000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
+ else:
+ if Max > 0x7FFFFFFFFFFFFFFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
+ if MaxNegative:
+ Max = ~Max + 1
+
+ if Max < Min: #
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
+
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ if IntDecStyle:
+ if MaxNegative:
+ if Max > 0x80000000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
+ else:
+ if Max > 0x7FFFFFFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
+ if MaxNegative:
+ Max = ~Max + 1
+
+ if Max < Min: #
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
+
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ if IntDecStyle:
+ if MaxNegative:
+ if Max > 0x8000:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
+ else:
+ if Max > 0x7FFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
+ if MaxNegative:
+ Max = ~Max + 1
+
+ if Max < Min: #
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
+
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ if IntDecStyle:
+ if MaxNegative:
+ if Max > 0x80:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
+ else:
+ if Max > 0x7F:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
+ if MaxNegative:
+ Max = ~Max + 1
+
+ if Max < Min: #
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
+
+ if self.__CurrQestVarInfo.IsBitVar:
+ ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_32)
+ else:
+ Type = self.__CurrQestVarInfo.VarType
+ if Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_64)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_32)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_16)
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_8)
+
+ return ctx.OpObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrNumericFlags.
+ def visitVfrNumericFlags(self, ctx:VfrSyntaxParser.VfrNumericFlagsContext):
+
+ ctx.LFlags = self.__CurrQestVarInfo.VarType & EFI_IFR_NUMERIC_SIZE
+ VarStoreType = gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId)
+ Line = ctx.start.line
+ IsSetType = False
+ self.visitChildren(ctx)
+
+ for FlagsFieldCtx in ctx.numericFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+ ctx.IsDisplaySpecified = FlagsFieldCtx.IsDisplaySpecified
+ IsSetType |= FlagsFieldCtx.IsSetType
+ if FlagsFieldCtx.NumericSizeOne() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1
+
+ if FlagsFieldCtx.NumericSizeTwo() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2
+
+ if FlagsFieldCtx.NumericSizeFour() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4
+
+ if FlagsFieldCtx.NumericSizeEight() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8
+
+ if FlagsFieldCtx.DisPlayIntDec() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC
+ else:
+ ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_INT_DEC_BIT
+
+ if FlagsFieldCtx.DisPlayUIntHex() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC
+ else:
+ ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_DEC_BIT
+
+ if FlagsFieldCtx.DisPlayUIntHex() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX
+ else:
+ ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_HEX_BIT
+
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
+ if self.__CurrQestVarInfo.VarType != (ctx.LFlags & EFI_IFR_NUMERIC_SIZE):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric Flag is not same to Numeric VarData type')
+ else:
+ # update data type for name/value store
+ self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
+ Size, _ = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
+ self.__CurrQestVarInfo.VarTotalSize = Size
+ elif IsSetType:
+ self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
+
+ elif self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID and self.__CurrQestVarInfo.IsBitVar:
+ ctx.LFlags &= EDKII_IFR_DISPLAY_BIT
+ ctx.LFlags |= EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
+
+ return ctx.HFlags, ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#numericFlagsField.
+ def visitNumericFlagsField(self, ctx:VfrSyntaxParser.NumericFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ Line = ctx.start.line
+ if ctx.Number() != None:
+ if self.__TransNum(ctx.N.text) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line)
+
+ if ctx.NumericSizeOne() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.IsSetType = True
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
+
+ if ctx.NumericSizeTwo() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.IsSetType = True
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
+
+ if ctx.NumericSizeFour() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.IsSetType = True
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
+
+ if ctx.NumericSizeEight() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.IsSetType = True
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
+
+ if ctx.DisPlayIntDec() != None:
+ ctx.IsDisplaySpecified = True
+
+ if ctx.DisPlayUIntHex() != None:
+ ctx.IsDisplaySpecified = True
+
+ if ctx.DisPlayUIntHex() != None:
+ ctx.IsDisplaySpecified = True
+
+ if ctx.questionheaderFlagsField() != None:
+ ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
+
+ return ctx.HFlag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOneOf.
+ def visitVfrStatementOneOf(self, ctx:VfrSyntaxParser.VfrStatementOneOfContext):
+
+ OObj = ctx.OpObj
+ Line = ctx.start.line
+ OObj.SetLineNo(Line)
+ self.__CurrentQuestion = OObj.GetQuestion()
+ self.visitChildren(ctx)
+ if self.__CurrQestVarInfo.IsBitVar:
+ GuidObj = CIfrGuid(0)
+ GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
+ GuidObj.SetLineNo(ctx.start.line)
+ GuidObj.SetScope(1) # pos
+
+ # check data type
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ if self.__CurrQestVarInfo.IsBitVar:
+ LFlags = EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
+ self.__ErrorHandler(OObj.SetFlagsForBitField(OObj.GetFlags(),LFlags), Line)
+ else:
+ DataTypeSize, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, 'OneOf varid is not the valid data type')
+ if DataTypeSize != 0 and DataTypeSize != self.__CurrQestVarInfo.VarTotalSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'OneOf varid doesn\'t support array')
+ self.__ErrorHandler(OObj.SetFlags(OObj.GetFlags(), self.__CurrQestVarInfo.VarType), Line)
+
+ if ctx.FLAGS() != None:
+ if self.__CurrQestVarInfo.IsBitVar:
+ self.__ErrorHandler(OObj.SetFlagsForBitField(ctx.vfrOneofFlagsField().HFlags,ctx.vfrOneofFlagsField().LFlags), ctx.F.line)
+ else:
+ self.__ErrorHandler(OObj.SetFlags(ctx.vfrOneofFlagsField().HFlags, ctx.vfrOneofFlagsField().LFlags), ctx.F.line)
+
+ ShrinkSize = 0
+ IsSupported = True
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ Type = self.__CurrQestVarInfo.VarType
+ # Base on the type to know the actual used size, shrink the buffer size allocate before.
+ if Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ ShrinkSize = 21
+ elif Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ ShrinkSize = 18
+ elif Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ ShrinkSize = 12
+ elif Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ ShrinkSize = 0 #
+ else:
+ IsSupported = False
+ else:
+ # Question stored in bit fields saved as UINT32 type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
+ ShrinkSize = 12
+
+ # OObj.ShrinkBinSize(ShrinkSize)
+ if IsSupported == False:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type.')
+
+ ctx.Node.Data = OObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrOneofFlagsField.
+ def visitVfrOneofFlagsField(self, ctx:VfrSyntaxParser.VfrOneofFlagsFieldContext):
+
+ ctx.LFlags = self.__CurrQestVarInfo.VarType & EFI_IFR_NUMERIC_SIZE
+ VarStoreType = gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId)
+ Line = ctx.start.line
+ IsSetType = False
+ self.visitChildren(ctx)
+
+ for FlagsFieldCtx in ctx.numericFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+ ctx.IsDisplaySpecified = FlagsFieldCtx.IsDisplaySpecified
+ IsSetType |= FlagsFieldCtx.IsSetType
+ if FlagsFieldCtx.NumericSizeOne() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1
+
+ if FlagsFieldCtx.NumericSizeTwo() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2
+
+ if FlagsFieldCtx.NumericSizeFour() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4
+
+ if FlagsFieldCtx.NumericSizeEight() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8
+
+ if FlagsFieldCtx.DisPlayIntDec() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC
+ else:
+ ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_INT_DEC_BIT
+
+ if FlagsFieldCtx.DisPlayUIntHex() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC
+ else:
+ ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_DEC_BIT
+
+ if FlagsFieldCtx.DisPlayUIntHex() != None:
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX
+ else:
+ ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_HEX_BIT
+
+ if self.__CurrQestVarInfo.IsBitVar == False:
+ if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
+ if self.__CurrQestVarInfo.VarType != (ctx.LFlags & EFI_IFR_NUMERIC_SIZE):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric Flag is not same to Numeric VarData type')
+ else:
+ # update data type for name/value store
+ self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
+ Size, _ = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
+ self.__CurrQestVarInfo.VarTotalSize = Size
+ elif IsSetType:
+ self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
+
+ elif self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
+ ctx.LFlags &= EDKII_IFR_DISPLAY_BIT
+ ctx.LFlags |= EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
+
+ return ctx.HFlags, ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStringType.
+ def visitVfrStatementStringType(self, ctx:VfrSyntaxParser.VfrStatementStringTypeContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementPassword() != None:
+ ctx.Node = ctx.vfrStatementPassword().Node
+ elif ctx.vfrStatementString() != None:
+ ctx.Node = ctx.vfrStatementString().Node
+ return ctx.Node
+
+ def _GET_CURRQEST_ARRAY_SIZE(self):
+
+ Size = 1
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_8:
+ Size = 1
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_16:
+ Size = 2
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_32:
+ Size = 4
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_64:
+ Size = 8
+
+ return int(self.__CurrQestVarInfo.VarTotalSize / Size)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementString.
+ def visitVfrStatementString(self, ctx:VfrSyntaxParser.VfrStatementStringContext):
+
+ self.__IsStringOp = True
+ SObj = ctx.OpObj
+ SObj.SetLineNo(ctx.start.line)
+ self.__CurrentQuestion = SObj.GetQuestion()
+
+ self.visitChildren(ctx)
+
+ if ctx.FLAGS() != None:
+ HFlags = ctx.vfrStringFlagsField().HFlags
+ LFlags = ctx.vfrStringFlagsField().LFlags
+ self.__ErrorHandler(SObj.SetFlags(HFlags, LFlags), ctx.F.line)
+
+ if ctx.Key() != None:
+ Key = self.__TransNum(ctx.Number(0))
+ self.__AssignQuestionKey(SObj, Key)
+ StringMinSize = self.__TransNum(ctx.Number(1))
+ StringMaxSize = self.__TransNum(ctx.Number(2))
+ else:
+ StringMinSize = self.__TransNum(ctx.Number(0))
+ StringMaxSize = self.__TransNum(ctx.Number(1))
+
+ VarArraySize = self._GET_CURRQEST_ARRAY_SIZE()
+ if StringMinSize > 0xFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize takes only one byte, which can't be larger than 0xFF.")
+ if VarArraySize != 0 and StringMinSize > VarArraySize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize can't be larger than the max number of elements in string array.")
+ SObj.SetMinSize(StringMinSize)
+
+ if StringMaxSize > 0xFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize takes only one byte, which can't be larger than 0xFF.")
+ elif VarArraySize != 0 and StringMaxSize > VarArraySize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be larger than the max number of elements in string array.")
+ elif StringMaxSize < StringMinSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be less than String MinSize.")
+ SObj.SetMaxSize(StringMaxSize)
+
+ ctx.Node.Data = SObj
+
+ self.__IsStringOp = False
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStringFlagsField.
+ def visitVfrStringFlagsField(self, ctx:VfrSyntaxParser.VfrStringFlagsFieldContext):
+
+ self.visitChildren(ctx)
+ for FlagsFieldCtx in ctx.stringFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+ ctx.LFlags |= FlagsFieldCtx.LFlag
+
+ return ctx.HFlags, ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#stringFlagsField.
+ def visitStringFlagsField(self, ctx:VfrSyntaxParser.StringFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ if self.__TransNum(ctx.Number()) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
+ elif ctx.questionheaderFlagsField() != None:
+
+ ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
+ else:
+ ctx.LFlag = 0x01
+
+ return ctx.HFlag, ctx.LFlag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementPassword.
+ def visitVfrStatementPassword(self, ctx:VfrSyntaxParser.VfrStatementPasswordContext):
+
+ PObj = ctx.OpObj
+ PObj.SetLineNo(ctx.start.line)
+ self.__CurrentQuestion = PObj.GetQuestion()
+
+ self.visitChildren(ctx)
+
+ if ctx.Key() != None:
+ Key = self.__TransNum(ctx.Number(0))
+ self.__AssignQuestionKey(PObj, Key)
+ PassWordMinSize = self.__TransNum(ctx.Number(1))
+ PasswordMaxSize = self.__TransNum(ctx.Number(2))
+ else:
+ PassWordMinSize = self.__TransNum(ctx.Number(0))
+ PasswordMaxSize = self.__TransNum(ctx.Number(1))
+
+ if ctx.FLAGS() != None:
+ HFlags = ctx.vfrPasswordFlagsField().HFlags
+ self.__ErrorHandler(PObj.SetFlags(HFlags), ctx.F.line)
+
+ VarArraySize = self._GET_CURRQEST_ARRAY_SIZE()
+ if PassWordMinSize > 0xFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize takes only one byte, which can't be larger than 0xFF.")
+ if VarArraySize != 0 and PassWordMinSize > VarArraySize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize can't be larger than the max number of elements in string array.")
+ PObj.SetMinSize(PassWordMinSize)
+
+ if PasswordMaxSize > 0xFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize takes only one byte, which can't be larger than 0xFF.")
+ elif VarArraySize != 0 and PasswordMaxSize > VarArraySize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be larger than the max number of elements in string array.")
+ elif PasswordMaxSize < PassWordMinSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be less than String MinSize.")
+ PObj.SetMaxSize(PasswordMaxSize)
+
+ ctx.Node.Data = PObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrPasswordFlagsField.
+ def visitVfrPasswordFlagsField(self, ctx:VfrSyntaxParser.VfrPasswordFlagsFieldContext):
+
+ self.visitChildren(ctx)
+ for FlagsFieldCtx in ctx.passwordFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+
+ return ctx.HFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#passwordFlagsField.
+ def visitPasswordFlagsField(self, ctx:VfrSyntaxParser.PasswordFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ if self.__TransNum(ctx.Number()) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
+ else:
+ ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
+
+ return ctx.HFlag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOrderedList.
+ def visitVfrStatementOrderedList(self, ctx:VfrSyntaxParser.VfrStatementOrderedListContext):
+
+ OLObj = ctx.OpObj
+ OLObj.SetLineNo(ctx.start.line)
+ self.__CurrentQuestion = OLObj.GetQuestion()
+ self.__IsOrderedList = True
+
+ self.visitChildren(ctx)
+
+ VarArraySize = self._GET_CURRQEST_ARRAY_SIZE()
+ if VarArraySize > 0xFF:
+ OLObj.SetMaxContainers(0xFF)
+ else:
+ OLObj.SetMaxContainers(VarArraySize)
+
+ if ctx.MaxContainers() != None:
+ MaxContainers = self.__TransNum(ctx.Number())
+ if MaxContainers > 0xFF:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.M.line, "OrderedList MaxContainers takes only one byte, which can't be larger than 0xFF.")
+ elif VarArraySize != 0 and MaxContainers > VarArraySize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.M.line,"OrderedList MaxContainers can't be larger than the max number of elements in array.")
+ OLObj.SetMaxContainers(MaxContainers)
+
+ if ctx.FLAGS() != None:
+ HFlags = ctx.vfrOrderedListFlags().HFlags
+ LFlags = ctx.vfrOrderedListFlags().LFlags
+ self.__ErrorHandler(OLObj.SetFlags(HFlags, LFlags), ctx.F.line)
+
+ ctx.Node.Data = OLObj
+
+ self.__IsOrderedList = False
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrOrderedListFlags.
+ def visitVfrOrderedListFlags(self, ctx:VfrSyntaxParser.VfrOrderedListFlagsContext):
+
+ self.visitChildren(ctx)
+
+ for FlagsFieldCtx in ctx.orderedlistFlagsField():
+ ctx.HFlags |= FlagsFieldCtx.HFlag
+ ctx.LFlags |= FlagsFieldCtx.LFlag
+
+ return ctx.HFlags, ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#orderedlistFlagsField.
+ def visitOrderedlistFlagsField(self, ctx:VfrSyntaxParser.OrderedlistFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ if self.__TransNum(ctx.Number()) != 0:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
+ elif ctx.questionheaderFlagsField() != None:
+ ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
+ elif ctx.UniQueFlag() != None:
+ ctx.LFlag = 0x01
+ elif ctx.NoEmptyFlag() != None:
+ ctx.LFlag = 0x02
+
+ return ctx.HFlag, ctx.LFlag
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDate.
+ def visitVfrStatementDate(self, ctx:VfrSyntaxParser.VfrStatementDateContext):
+
+ DObj = ctx.OpObj
+ Line = ctx.start.line
+ DObj.SetLineNo(Line)
+
+ self.visitChildren(ctx)
+
+ if ctx.vfrQuestionHeader() != None:
+
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
+ self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_DATE
+
+ if ctx.FLAGS() != None:
+ self.__ErrorHandler(DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrDateFlags().LFlags), ctx.F1.line)
+
+ else:
+
+ Year = self.__TransId(ctx.StringIdentifier(0))
+ Year += '.'
+ Year += self.__TransId(ctx.StringIdentifier(1))
+
+ Month = self.__TransId(ctx.StringIdentifier(2))
+ Month += '.'
+ Month += self.__TransId(ctx.StringIdentifier(3))
+
+ Day = self.__TransId(ctx.StringIdentifier(4))
+ Day += '.'
+ Day += self.__TransId(ctx.StringIdentifier(5))
+
+ if ctx.FLAGS() != None:
+ self.__ErrorHandler(DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrDateFlags().LFlags), ctx.F2.line)
+
+ QId, _ = self.__CVfrQuestionDB.RegisterOldDateQuestion(Year, Month, Day, EFI_QUESTION_ID_INVALID)
+ DObj.SetQuestionId(QId)
+ DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, QF_DATE_STORAGE_TIME)
+ DObj.SetPrompt(self.__TransNum(ctx.Number(0)))
+ DObj.SetHelp(self.__TransNum(ctx.Number(1)))
+
+ Size = EFI_IFR_DEFAULT.Value.offset + sizeof (EFI_HII_DATE)
+ DefaultObj = CIfrDefault(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, ctx.Val)
+ DefaultObj.SetLineNo(Line)
+
+ ctx.Node.Data = DObj
+ for Ctx in ctx.vfrStatementInconsistentIf():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#minMaxDateStepDefault.
+ def visitMinMaxDateStepDefault(self, ctx:VfrSyntaxParser.MinMaxDateStepDefaultContext):
+
+ if ctx.Default() != None:
+ Minimum = self.__TransNum(ctx.Number(0))
+ Maximum = self.__TransNum(ctx.Number(1))
+ if ctx.KeyValue == 0:
+ ctx.Date.Year = self.__TransNum(ctx.N.text)
+ if ctx.Date.Year < Minimum or ctx.Date.Year > Maximum:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Year default value must be between Min year and Max year.")
+ if ctx.KeyValue == 1:
+ ctx.Date.Month = self.__TransNum(ctx.N.text)
+ if ctx.Date.Month < 1 or ctx.Date.Month > 12:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.D.line, "Month default value must be between Min 1 and Max 12.")
+ if ctx.KeyValue == 2:
+ ctx.Date.Day = self.__TransNum(ctx.N.text)
+ if ctx.Date.Day < 1 or ctx.Date.Day > 31:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.D.line, "Day default value must be between Min 1 and Max 31.")
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrDateFlags.
+ def visitVfrDateFlags(self, ctx:VfrSyntaxParser.VfrDateFlagsContext):
+
+ self.visitChildren(ctx)
+
+ for FlagsFieldCtx in ctx.dateFlagsField():
+ ctx.LFlags |= FlagsFieldCtx.LFlag
+
+ return ctx.LFlags
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dateFlagsField.
+ def visitDateFlagsField(self, ctx:VfrSyntaxParser.DateFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ ctx.LFlag = self.__TransNum(ctx.Number())
+ if ctx.YearSupppressFlag() != None:
+ ctx.LFlag = 0x01
+ if ctx.MonthSuppressFlag() != None:
+ ctx.LFlag = 0x02
+ if ctx.DaySuppressFlag() != None:
+ ctx.LFlag = 0x04
+ if ctx.StorageNormalFlag() != None:
+ ctx.LFlag = 0x00
+ if ctx.StorageTimeFlag() != None:
+ ctx.LFlag = 0x010
+ if ctx.StorageWakeUpFlag() != None:
+ ctx.LFlag = 0x20
+
+ return ctx.LFlag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementTime.
+ def visitVfrStatementTime(self, ctx:VfrSyntaxParser.VfrStatementTimeContext):
+
+ TObj = ctx.OpObj
+ Line = ctx.start.line
+ TObj.SetLineNo(Line)
+
+ self.visitChildren(ctx)
+
+ if ctx.vfrQuestionHeader() != None:
+
+ if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
+ self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_TIME
+
+ if ctx.FLAGS() != None:
+ self.__ErrorHandler(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrTimeFlags().LFlags), ctx.F1.line)
+ else:
+
+ Hour = self.__TransId(ctx.StringIdentifier(0))
+ Hour += '.'
+ Hour += self.__TransId(ctx.StringIdentifier(1))
+
+ Minute = self.__TransId(ctx.StringIdentifier(2))
+ Minute += '.'
+ Minute += self.__TransId(ctx.StringIdentifier(3))
+
+ Second = self.__TransId(ctx.StringIdentifier(4))
+ Second += '.'
+ Second += self.__TransId(ctx.StringIdentifier(5))
+
+ if ctx.FLAGS() != None:
+ self.__ErrorHandler(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrTimeFlags().LFlags), ctx.F2.line)
+
+ QId, _ = self.__CVfrQuestionDB.RegisterOldTimeQuestion(Hour, Minute, Second, EFI_QUESTION_ID_INVALID)
+ TObj.SetQuestionId(QId)
+ TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, QF_TIME_STORAGE_TIME)
+ TObj.SetPrompt(self.__TransNum(ctx.Number(0)))
+ TObj.SetHelp(self.__TransNum(ctx.Number(1)))
+
+ Size = EFI_IFR_DEFAULT.Value.offset + sizeof (EFI_HII_TIME)
+ DefaultObj = CIfrDefault(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, ctx.Val)
+ DefaultObj.SetLineNo(Line)
+
+ ctx.Node.Data = TObj
+ for Ctx in ctx.vfrStatementInconsistentIf():
+ self.__InsertChild(ctx.Node, Ctx)
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#minMaxTimeStepDefault.
+ def visitMinMaxTimeStepDefault(self, ctx:VfrSyntaxParser.MinMaxTimeStepDefaultContext):
+
+ if ctx.Default() != None:
+ Minimum = self.__TransNum(ctx.Number(0))
+ Maximum = self.__TransNum(ctx.Number(1))
+ if ctx.KeyValue == 0:
+ ctx.Time.Hour = self.__TransNum(ctx.Number(len(ctx.Number())-1))
+ if ctx.Time.Hour > 23:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Hour default value must be between 0 and 23.")
+ if ctx.KeyValue == 1:
+ ctx.Time.Minute = self.__TransNum(ctx.Number(len(ctx.Number())-1))
+ if ctx.Time.Minute > 59:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Minute default value must be between 0 and 59.")
+ if ctx.KeyValue == 2:
+ ctx.Time.Second = self.__TransNum(ctx.Number(len(ctx.Number())-1))
+ if ctx.Time.Second > 59:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Second default value must be between 0 and 59.")
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrTimeFlags.
+ def visitVfrTimeFlags(self, ctx:VfrSyntaxParser.VfrTimeFlagsContext):
+
+ self.visitChildren(ctx)
+
+ for FlagsFieldCtx in ctx.timeFlagsField():
+ ctx.LFlags |= FlagsFieldCtx.LFlag
+
+ return ctx.LFlags
+
+ # Visit a parse tree produced by VfrSyntaxParser#timeFlagsField.
+ def visitTimeFlagsField(self, ctx:VfrSyntaxParser.TimeFlagsFieldContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Number() != None:
+ ctx.LFlag = self.__TransNum(ctx.Number())
+ if ctx.HourSupppressFlag() != None:
+ ctx.LFlag = 0x01
+ if ctx.MinuteSuppressFlag() != None:
+ ctx.LFlag = 0x02
+ if ctx.SecondSuppressFlag() != None:
+ ctx.LFlag = 0x04
+ if ctx.StorageNormalFlag() != None:
+ ctx.LFlag = 0x00
+ if ctx.StorageTimeFlag() != None:
+ ctx.LFlag = 0x10
+ if ctx.StorageWakeUpFlag() != None:
+ ctx.LFlag = 0x20
+
+ return ctx.LFlag
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementConditional.
+ def visitVfrStatementConditional(self, ctx:VfrSyntaxParser.VfrStatementConditionalContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementDisableIfStat()!= None:
+ ctx.Node = ctx.vfrStatementDisableIfStat().Node
+ if ctx.vfrStatementSuppressIfStat()!= None:
+ ctx.Node = ctx.vfrStatementSuppressIfStat().Node
+ if ctx.vfrStatementGrayOutIfStat()!= None:
+ ctx.Node = ctx.vfrStatementGrayOutIfStat().Node
+ if ctx.vfrStatementInconsistentIfStat()!= None:
+ ctx.Node = ctx.vfrStatementInconsistentIfStat().Node
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementConditionalNew.
+ def visitVfrStatementConditionalNew(self, ctx:VfrSyntaxParser.VfrStatementConditionalNewContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfStat.
+ def visitVfrStatementSuppressIfStat(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfStatContext):
+
+ self.visitChildren(ctx)
+ ctx.Node = ctx.vfrStatementSuppressIfStatNew().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGrayOutIfStat.
+ def visitVfrStatementGrayOutIfStat(self, ctx:VfrSyntaxParser.VfrStatementGrayOutIfStatContext):
+
+ self.visitChildren(ctx)
+ ctx.Node = ctx.vfrStatementGrayOutIfStatNew().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatList.
+ def visitVfrStatementStatList(self, ctx:VfrSyntaxParser.VfrStatementStatListContext):
+
+ self.visitChildren(ctx)
+ if ctx.vfrStatementStat() != None:
+ ctx.Node = ctx.vfrStatementStat().Node
+ if ctx.vfrStatementQuestions() != None:
+ ctx.Node = ctx.vfrStatementQuestions().Node
+ if ctx.vfrStatementConditional() != None:
+ ctx.Node = ctx.vfrStatementConditional().Node
+ if ctx.vfrStatementLabel() != None:
+ ctx.Node = ctx.vfrStatementLabel().Node
+ if ctx.vfrStatementExtension() != None:
+ ctx.Node = ctx.vfrStatementExtension().Node
+ if ctx.vfrStatementInvalid() != None:
+ ctx.Node = ctx.vfrStatementInvalid().Node
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatListOld.
+ def visitVfrStatementStatListOld(self, ctx:VfrSyntaxParser.VfrStatementStatListOldContext):
+ return self.visitChildren(ctx)
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDisableIfStat.
+ def visitVfrStatementDisableIfStat(self, ctx:VfrSyntaxParser.VfrStatementDisableIfStatContext):
+
+ DIObj = CIfrDisableIf()
+ DIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = DIObj
+ ctx.Node.Condition = 'disableif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrStatementStatList():
+ self.__InsertChild(ctx.Node, Ctx)
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfStatNew.
+ def visitVfrStatementSuppressIfStatNew(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfStatNewContext):
+
+ SIObj = CIfrSuppressIf()
+ SIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = SIObj
+ ctx.Node.Condition = 'suppressif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrStatementStatList():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGrayOutIfStatNew.
+ def visitVfrStatementGrayOutIfStatNew(self, ctx:VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext):
+
+ GOIObj = CIfrGrayOutIf()
+ GOIObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = GOIObj
+ ctx.Node.Condition = 'grayoutif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+ self.visitChildren(ctx)
+ for Ctx in ctx.vfrStatementStatList():
+ self.__InsertChild(ctx.Node, Ctx)
+
+ return ctx.Node
+
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInconsistentIfStat.
+ def visitVfrStatementInconsistentIfStat(self, ctx:VfrSyntaxParser.VfrStatementInconsistentIfStatContext):
+
+ IIObj = CIfrInconsistentIf()
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
+ IIObj.SetLineNo(ctx.start.line)
+ self.visitChildren(ctx)
+ IIObj.SetError(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = IIObj
+ ctx.Node.Condition = 'inconsistentif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalid.
+ def visitVfrStatementInvalid(self, ctx:VfrSyntaxParser.VfrStatementInvalidContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalidHidden.
+ def visitVfrStatementInvalidHidden(self, ctx:VfrSyntaxParser.VfrStatementInvalidHiddenContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalidInventory.
+ def visitVfrStatementInvalidInventory(self, ctx:VfrSyntaxParser.VfrStatementInvalidInventoryContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalidSaveRestoreDefaults.
+ def visitVfrStatementInvalidSaveRestoreDefaults(self, ctx:VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementLabel.
+ def visitVfrStatementLabel(self, ctx:VfrSyntaxParser.VfrStatementLabelContext):
+
+ LObj = CIfrLabel()
+ self.visitChildren(ctx)
+ LObj.SetLineNo(ctx.start.line)
+ LObj.SetNumber(self.__TransNum(ctx.Number()))
+ ctx.Node.Data = LObj
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatemex.BObjntBanner.
+ def visitVfrStatementBanner(self, ctx:VfrSyntaxParser.VfrStatementBannerContext):
+
+ self.visitChildren(ctx)
+
+ if ctx.Line() != None:
+ BObj = CIfrBanner()
+ BObj.SetLineNo(ctx.start.line)
+ BObj.SetTitle(self.__TransNum(ctx.Number(0)))
+ BObj.SetLine(self.__TransNum(ctx.Number(1)))
+ if ctx.Left() != None: BObj.SetAlign(0)
+ if ctx.Center() != None: BObj.SetAlign(1)
+ if ctx.Right() != None: BObj.SetAlign(2)
+ ctx.Node.Data = BObj
+ elif ctx.Timeout() != None:
+ TObj = CIfrTimeout()
+ TObj.SetLineNo(ctx.start.line)
+ TObj.SetTimeout(self.__TransNum(ctx.Number(2)))
+ ctx.Node.Data = TObj
+
+ return ctx.Node
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementExtension.
+ def visitVfrStatementExtension(self, ctx:VfrSyntaxParser.VfrStatementExtensionContext):
+
+ ctx.IsStruct = False
+ if ctx.DataType() != None:
+ if ctx.Uint64() != None:
+ ctx.TypeName = 'UINT64'
+ elif ctx.Uint32() != None:
+ ctx.TypeName = 'UINT32'
+ elif ctx.Uint16() != None:
+ ctx.TypeName = 'UINT16'
+ elif ctx.Uint8() != None:
+ ctx.TypeName = 'UINT8'
+ elif ctx.Boolean() != None:
+ ctx.TypeName = 'BOOLEAN'
+ elif ctx.EFI_STRING_ID() != None:
+ ctx.TypeName = 'EFI_STRING_ID'
+ elif ctx.EFI_HII_DATE() != None:
+ ctx.TypeName = 'EFI_HII_DATE'
+ ctx.IsStruct = True
+ elif ctx.EFI_HII_TIME() != None:
+ ctx.TypeName = 'EFI_HII_TIME'
+ ctx.IsStruct = True
+ elif ctx.EFI_HII_REF() != None:
+ ctx.TypeName = 'EFI_HII_REF'
+ ctx.IsStruct = True
+ else:
+ ctx.TypeName = self.__TransId(ctx.StringIdentifier())
+ ctx.IsStruct = True
+ ctx.ArrayNum = self.__TransNum(ctx.Number())
+ ctx.TypeSize, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(ctx.TypeName)
+ self.__ErrorHandler(ReturnCode, ctx.D.line)
+ ctx.Size = ctx.TypeSize * ctx.ArrayNum if ctx.ArrayNum > 0 else ctx.TypeSize
+ ArrayType = ctypes.c_ubyte * ctx.Size
+ ctx.DataBuff = ArrayType()
+ for i in range(0, ctx.Size):
+ ctx.DataBuff[i] = 0
+ self.visitChildren(ctx)
+
+ Line = ctx.start.line
+ GuidObj = CIfrGuid(ctx.Size)
+ GuidObj.SetLineNo(Line)
+ GuidObj.SetGuid(ctx.guidDefinition().Guid)
+ if ctx.TypeName != None:
+ GuidObj.SetData(ctx.DataBuff)
+ # vfrStatementExtension
+ GuidObj.SetScope(1)
+ ctx.Node.Data = GuidObj
+ for Ctx in ctx.vfrStatementExtension():
+ self.__InsertChild(ctx.Node, Ctx)
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExtensionData.
+ def visitVfrExtensionData(self, ctx:VfrSyntaxParser.VfrExtensionDataContext):
+ '''
+ TFName = ''
+ IsArray = False if ctx.OpenBracket() == None else True
+ ArrayIdx = 0
+ ctx.IsStruct = ctx.parentCtx.IsStruct
+ ctx.DataBuff = ctx.parentCtx.DataBuff
+
+ self.visitChildren(ctx)
+
+ Data = self.__TransNum(ctx.N.text)
+ if IsArray == True:
+ ArrayIdx = self.__TransNum(self.__TransNum(ctx.Number(0)))
+ ByteOffset = ArrayIdx * ctx.parentCtx.TypeSize
+ if ctx.IsStruct == True:
+ TFName += ctx.parentCtx.TypeName
+ for i in range(0, len(ctx.arrayName())):
+ TFName += '.'
+ TFName += ctx.arrayName(i).SubStrZ
+ FieldOffset, FieldType, FieldSize, BitField, _ = gCVfrVarDataTypeDB.GetDataFieldInfo(TFName)
+ if BitField:
+ Mask = (1 << FieldSize) - 1
+ Offset = int(FieldOffset / 8)
+ PreBits = FieldOffset % 8
+ Mask <<= PreBits
+ Begin = 0
+ End = 0
+ if FieldType == EFI_IFR_TYPE_NUM_SIZE_8:
+ Data = ctypes.c_ubyte(Data)
+ if BitField:
+ # Set the value to the bit fileds.
+ Data <<= PreBits
+ Value = (Value & (~Mask)) | Data
+ Begin = ByteOffset + Offset
+ End = ByteOffset + Offset + sizeof (ctypes.c_ubyte)
+ ctx.DataBuff[Begin: End] = Value
+ else:
+ Begin = ByteOffset + FieldOffset
+ End = ByteOffset + FieldOffset + FieldSize
+ ctx.DataBuff[Begin: End] = Data
+
+
+ if FieldType == EFI_IFR_TYPE_NUM_SIZE_16:
+ Data = ctypes.c_ushort(Data)
+ if BitField:
+ # Set the value to the bit fileds.
+ Data <<= PreBits
+ Value = (Value & (~Mask)) | Data
+ Begin = ByteOffset + Offset
+ End = ByteOffset + Offset + sizeof (ctypes.c_ushort)
+ ctx.DataBuff[Begin: End] = Value
+ else:
+ Begin = ByteOffset + FieldOffset
+ End = ByteOffset + FieldOffset + FieldSize
+ ctx.DataBuff[Begin: End] = Data
+
+
+ if FieldType == EFI_IFR_TYPE_NUM_SIZE_32:
+ Data = ctypes.c_ulong(Data)
+ if BitField:
+ # Set the value to the bit fileds.
+ Data <<= PreBits
+ Value = (Value & (~Mask)) | Data
+ Begin = ByteOffset + Offset
+ End = ByteOffset + Offset + sizeof (ctypes.c_ulong)
+ ctx.DataBuff[Begin: End] = Value
+ else:
+ Begin = ByteOffset + FieldOffset
+ End = ByteOffset + FieldOffset + FieldSize
+ ctx.DataBuff[Begin: End] = Data
+
+ if FieldType == EFI_IFR_TYPE_NUM_SIZE_64:
+ Data = ctypes.c_ulonglong(Data)
+ if BitField:
+ # Set the value to the bit fileds.
+ Data <<= PreBits
+ Value = (Value & (~Mask)) | Data
+ Begin = ByteOffset + Offset
+ End = ByteOffset + Offset + sizeof (ctypes.c_ulonglong)
+ ctx.DataBuff[Begin: End] = Value
+ else:
+ Begin = ByteOffset + FieldOffset
+ End = ByteOffset + FieldOffset + FieldSize
+ ctx.DataBuff[Begin: End] = Data
+
+ else:
+ ctx.DataBuff[ByteOffset, ByteOffset + ctx.parentCtx.TypeSize] = Data
+ '''
+ return self.visitChildren(ctx)
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementModal.
+ def visitVfrStatementModal(self, ctx:VfrSyntaxParser.VfrStatementModalContext):
+
+ self.visitChildren(ctx)
+ ctx.Node = ctx.vfrModalTag().Node
+ return ctx.Node
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrModalTag.
+ def visitVfrModalTag(self, ctx:VfrSyntaxParser.VfrModalTagContext):
+
+ MObj = CIfrModal()
+ self.visitChildren(ctx)
+ MObj.SetLineNo(ctx.start.line)
+ ctx.Node.Data = MObj
+
+ return ctx.Node
+
+ def __SaveOpHdrCond(self, OpHdr, Cond, LineNo=0):
+ if Cond == True:
+ if self.__CIfrOpHdr[self.__CIfrOpHdrIndex] != None:
+ return
+ self.__CIfrOpHdr[self.__CIfrOpHdrIndex] = CIfrOpHeader(OpHdr) #
+ self.__CIfrOpHdrLineNo[self.__CIfrOpHdrIndex] = LineNo
+
+
+ def __InitOpHdrCond(self):
+ self.__CIfrOpHdr.append(None)
+ self.__CIfrOpHdrLineNo.append(0)
+
+ def __SetSavedOpHdrScope(self):
+ if self.__CIfrOpHdr[self.__CIfrOpHdrIndex] != None:
+ self.__CIfrOpHdr[self.__CIfrOpHdrIndex].SetScope(1)
+ return True
+ return False
+
+ def __ClearSavedOPHdr(self):
+ self.__CIfrOpHdr[self.__CIfrOpHdrIndex] = None
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementExpression.
+ def visitVfrStatementExpression(self, ctx:VfrSyntaxParser.VfrStatementExpressionContext):
+
+ # Root expression extension function called by other function. ##
+ if ctx.ExpInfo.RootLevel == 0:
+ self.__CIfrOpHdrIndex += 1
+ if self.__CIfrOpHdrIndex >= MAX_IFR_EXPRESSION_DEPTH:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, 'The depth of expression exceeds the max supported level 8!')
+ self.__InitOpHdrCond()
+
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ for i in range(0, len(ctx.OR())):
+ ctx.ExpInfo.ExpOpCount += 1
+ OObj = CIfrOr(Line)
+
+ # Extend OpCode Scope only for the root expression.
+ if ctx.ExpInfo.ExpOpCount > 1 and ctx.ExpInfo.RootLevel == 0:
+ if self.__SetSavedOpHdrScope():
+ EObj = CIfrEnd()
+ if self.__CIfrOpHdrLineNo[self.__CIfrOpHdrIndex] != 0:
+ EObj.SetLineNo(self.__CIfrOpHdrLineNo[self.__CIfrOpHdrIndex])
+
+ if ctx.ExpInfo.RootLevel == 0:
+ self.__ClearSavedOPHdr()
+ self.__CIfrOpHdrIndex = self.__CIfrOpHdrIndex - 1
+
+ self.__ConstantOnlyInExpression = False
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementExpressionSub.
+ def visitVfrStatementExpressionSub(self, ctx:VfrSyntaxParser.VfrStatementExpressionSubContext):
+
+ ctx.ExpInfo.RootLevel = ctx.parentCtx.ExpInfo.RootLevel + 1
+ ctx.ExpInfo.ExpOpCount = ctx.parentCtx.ExpInfo.ExpOpCount
+
+ self.visitChildren(ctx)
+
+ ctx.parentCtx.ExpInfo.ExpOpCount = ctx.ExpInfo.ExpOpCount
+
+ return ctx.ExpInfo
+
+ # Visit a parse tree produced by VfrSyntaxParser#andTerm.
+ def visitAndTerm(self, ctx:VfrSyntaxParser.AndTermContext):
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ for i in range(0, len(ctx.AND())):
+ ctx.ExpInfo.ExpOpCount += 1
+ AObj = CIfrAnd(Line)
+ ctx.CIfrAndList.append(AObj)
+
+ return ctx.ExpInfo, ctx.CIfrAndList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#bitwiseorTerm.
+ def visitBitwiseorTerm(self, ctx:VfrSyntaxParser.BitwiseorTermContext):
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ for i in range(0, len(ctx.BitWiseOr())):
+ ctx.ExpInfo.ExpOpCount += 1
+ BWOObj = CIfrBitWiseOr(Line)
+ ctx.CIfrBitWiseOrList.append(BWOObj)
+
+ return ctx.ExpInfo, ctx.CIfrBitWiseOrList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#bitwiseandTerm.
+ def visitBitwiseandTerm(self, ctx:VfrSyntaxParser.BitwiseandTermContext):
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ for i in range(0, len(ctx.BitWiseAnd())):
+ ctx.ExpInfo.ExpOpCount += 1
+ BWAObj = CIfrBitWiseAnd(Line)
+ ctx.CIfrBitWiseAndList.append(BWAObj)
+
+ return ctx.ExpInfo, ctx.CIfrBitWiseAndList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#equalTerm.
+ def visitEqualTerm(self, ctx:VfrSyntaxParser.EqualTermContext):
+ self.visitChildren(ctx)
+ for i in range(0, len(ctx.equalTermSupplementary())):
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo, ctx.CIfrEqualList, ctx.CIfrNotEqualList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#equalTermEqualRule.
+ def visitEqualTermEqualRule(self, ctx:VfrSyntaxParser.EqualTermEqualRuleContext):
+ self.visitChildren(ctx)
+ EObj = CIfrEqual(ctx.start.line)
+ ctx.CIfrEqualList.append(EObj)
+
+ return EObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#equalTermNotEqualRule.
+ def visitEqualTermNotEqualRule(self, ctx:VfrSyntaxParser.EqualTermNotEqualRuleContext):
+ self.visitChildren(ctx)
+ NEObj = CIfrNotEqual(ctx.start.line)
+ ctx.CIfrNotEqualList.append(NEObj)
+ return NEObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#compareTerm.
+ def visitCompareTerm(self, ctx:VfrSyntaxParser.CompareTermContext):
+ self.visitChildren(ctx)
+ for i in range(0, len(ctx.compareTermSupplementary())):
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.ExpInfo, ctx.CIfrLessThanList, ctx.CIfrLessEqualList, ctx.CIfrGreaterThanList, ctx.CIfrGreaterEqualList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#compareTermLessRule.
+ def visitCompareTermLessRule(self, ctx:VfrSyntaxParser.CompareTermLessRuleContext):
+ self.visitChildren(ctx)
+ LTObj = CIfrLessThan(ctx.start.line)
+ ctx.CIfrLessThanList.append(LTObj)
+ return LTObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#compareTermLessEqualRule.
+ def visitCompareTermLessEqualRule(self, ctx:VfrSyntaxParser.CompareTermLessEqualRuleContext):
+ self.visitChildren(ctx)
+ LEObj = CIfrLessEqual(ctx.start.line)
+ ctx.CIfrLessEqualList.append(LEObj)
+ return LEObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#compareTermGreaterRule.
+ def visitCompareTermGreaterRule(self, ctx:VfrSyntaxParser.CompareTermGreaterRuleContext):
+ self.visitChildren(ctx)
+ GTObj = CIfrGreaterThan(ctx.start.line)
+ ctx.CIfrGreaterThanList.append(GTObj)
+ return GTObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#compareTermGreaterEqualRule.
+ def visitCompareTermGreaterEqualRule(self, ctx:VfrSyntaxParser.CompareTermGreaterEqualRuleContext):
+ self.visitChildren(ctx)
+ GEObj = CIfrGreaterEqual(ctx.start.line)
+ ctx.CIfrGreaterEqualList.append(GEObj)
+ return GEObj
+
+ # Visit a parse tree produced by VfrSyntaxParser#shiftTerm.
+ def visitShiftTerm(self, ctx:VfrSyntaxParser.ShiftTermContext):
+ self.visitChildren(ctx)
+ for i in range(0, len(ctx.shiftTermSupplementary())):
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.ExpInfo, ctx.CIfrShiftLeftList, ctx.CIfrShiftRightList
+
+ # Visit a parse tree produced by VfrSyntaxParser#shiftTermLeft.
+ def visitShiftTermLeft(self, ctx:VfrSyntaxParser.ShiftTermLeftContext):
+ self.visitChildren(ctx)
+ SLObj = CIfrShiftLeft(ctx.start.line)
+ ctx.CIfrShiftLeftList.append(SLObj)
+ return SLObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#shiftTermRight.
+ def visitShiftTermRight(self, ctx:VfrSyntaxParser.ShiftTermRightContext):
+ self.visitChildren(ctx)
+ SRObj = CIfrShiftRight(ctx.start.line)
+ ctx.CIfrShiftRightList.append(SRObj)
+ return SRObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#addMinusTerm.
+ def visitAddMinusTerm(self, ctx:VfrSyntaxParser.AddMinusTermContext):
+ self.visitChildren(ctx)
+ for i in range(0, len(ctx.addMinusTermSupplementary())):
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.ExpInfo, ctx.CIfrAddList, ctx.CIfrSubtractList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#addMinusTermpAdd.
+ def visitAddMinusTermpAdd(self, ctx:VfrSyntaxParser.AddMinusTermpAddContext):
+ self.visitChildren(ctx)
+ AObj = CIfrAdd(ctx.start.line)
+ ctx.CIfrAddList.append(AObj)
+ return AObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#addMinusTermSubtract.
+ def visitAddMinusTermSubtract(self, ctx:VfrSyntaxParser.AddMinusTermSubtractContext):
+ self.visitChildren(ctx)
+ SObj = CIfrSubtract(ctx.start.line)
+ ctx.CIfrSubtractList.append(SObj)
+ return SObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#multdivmodTerm.
+ def visitMultdivmodTerm(self, ctx:VfrSyntaxParser.MultdivmodTermContext):
+ self.visitChildren(ctx)
+ for i in range(0, len(ctx.multdivmodTermSupplementary())):
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.ExpInfo, ctx.CIfrMultiplyList, ctx.CIfrDivideList, ctx.CIfrModuloList
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermMul.
+ def visitMultdivmodTermMul(self, ctx:VfrSyntaxParser.MultdivmodTermMulContext):
+ self.visitChildren(ctx)
+ MObj = CIfrMultiply(ctx.start.line)
+ ctx.CIfrMultiplyList.append(MObj)
+ return MObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermDiv.
+ def visitMultdivmodTermDiv(self, ctx:VfrSyntaxParser.MultdivmodTermDivContext):
+ self.visitChildren(ctx)
+ DObj = CIfrDivide(ctx.start.line)
+ ctx.CIfrDivideList.append(DObj)
+ return DObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermRound.
+ def visitMultdivmodTermModulo(self, ctx:VfrSyntaxParser.MultdivmodTermModuloContext):
+ self.visitChildren(ctx)
+ ctx.Line = ctx.start.line
+ MObj = CIfrModulo(ctx.Line)
+ ctx.CIfrModuloList.append(MObj)
+ return MObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#castTerm.
+ def visitCastTerm(self, ctx:VfrSyntaxParser.CastTermContext):
+ self.visitChildren(ctx) ##
+ CastType = 0xFF
+ if ctx.Boolean() != []:
+ CastType = 0
+ elif ctx.Uint64() != []:
+ CastType = 1
+ elif ctx.Uint32() != []:
+ CastType = 1
+ elif ctx.Uint16() != []:
+ CastType = 1
+ elif ctx.Uint8() != []:
+ CastType = 1
+
+ Line = ctx.start.line
+ if CastType == 0:
+ ctx.TBObj = CIfrToBoolean(Line)
+ elif CastType == 1:
+ ctx.TUObj = CIfrToUint(Line)
+
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TBObj, ctx.TUObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#atomTerm.
+ def visitAtomTerm(self, ctx:VfrSyntaxParser.AtomTermContext):
+ self.visitChildren(ctx)
+ if ctx.NOT() != None:
+ Line = ctx.start.line
+ NObj = CIfrNot(Line)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionCatenate.
+ def visitVfrExpressionCatenate(self, ctx:VfrSyntaxParser.VfrExpressionCatenateContext):
+ ctx.ExpInfo.RootLevel += 1
+ self.visitChildren(ctx)
+
+ Line = ctx.start.line
+ ctx.CObj = CIfrCatenate(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.CObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionMatch.
+ def visitVfrExpressionMatch(self, ctx:VfrSyntaxParser.VfrExpressionMatchContext):
+ ctx.ExpInfo.RootLevel += 1
+ self.visitChildren(ctx)
+
+ Line = ctx.start.line
+ ctx.MObj = CIfrMatch(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.MObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionMatch2.
+ def visitVfrExpressionMatch2(self, ctx:VfrSyntaxParser.VfrExpressionMatch2Context):
+ self.visitChildren(ctx)
+
+ Line = ctx.start.line
+ Guid = ctx.guidDefinition().Guid
+ ctx.M2Obj = CIfrMatch2(Line, Guid)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.M2Obj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionParen.
+ def visitVfrExpressionParen(self, ctx:VfrSyntaxParser.VfrExpressionParenContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionBuildInFunction.
+ def visitVfrExpressionBuildInFunction(self, ctx:VfrSyntaxParser.VfrExpressionBuildInFunctionContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#dupExp.
+ def visitDupExp(self, ctx:VfrSyntaxParser.DupExpContext):
+
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ DObj = CIfrDup(Line)
+ self.__SaveOpHdrCond(DObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line) #
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vareqvalExp.
+ def visitVareqvalExp(self, ctx:VfrSyntaxParser.VareqvalExpContext):
+
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+
+ ReturnCode = VfrReturnCode.VFR_RETURN_UNSUPPORTED
+ VarIdStr = 'var'
+ VarIdStr += str(ctx.Number(0))
+ VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(VarIdStr)
+ if ReturnCode == VfrReturnCode.VFR_RETURN_UNDEFINED:
+ pass
+ else:
+ pass
+ QId, Mask, _ = self.__CVfrQuestionDB.GetQuestionId(None, VarIdStr)
+ ConstVal = self.__TransNum(ctx.Number(1))
+ if ctx.Equal() != None:
+ if Mask == 0:
+ EIVObj = CIfrEqIdVal(Line)
+ self.__SaveOpHdrCond(EIVObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ EIVObj.SetQuestionId(QId, VarIdStr, Line)
+ EIVObj.SetValue(ConstVal)
+ ctx.ExpInfo.ExpOpCount += 1
+ else:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.EQUAL)
+ elif ctx.LessEqual() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_EQUAL)
+
+ elif ctx.Less() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_THAN)
+
+ elif ctx.GreaterEqual() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_EQUAL)
+
+ elif ctx.Greater() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_THAN)
+
+
+ return ctx.ExpInfo
+
+
+ def ConvertIdExpr(self, ExpInfo, LineNo, QId, VarIdStr, BitMask):
+
+ QR1Obj = CIfrQuestionRef1(LineNo)
+ QR1Obj.SetQuestionId(QId, VarIdStr, LineNo)
+ self.__SaveOpHdrCond(QR1Obj.GetHeader(), (ExpInfo.ExpOpCount == 0))
+ if BitMask != 0:
+ U32Obj = CIfrUint32(LineNo)
+ U32Obj.SetValue(BitMask)
+
+ BWAObj = CIfrBitWiseAnd(LineNo)
+
+ U8Obj = CIfrUint8(LineNo)
+ if BitMask == DATE_YEAR_BITMASK:
+ U8Obj.SetValue (0)
+ elif BitMask == TIME_SECOND_BITMASK:
+ U8Obj.SetValue (0x10)
+ elif BitMask == DATE_DAY_BITMASK:
+ U8Obj.SetValue (0x18)
+ elif BitMask == TIME_HOUR_BITMASK:
+ U8Obj.SetValue (0)
+ elif BitMask == TIME_MINUTE_BITMASK:
+ U8Obj.SetValue (0x8)
+
+ SRObj = CIfrShiftRight(LineNo)
+
+ ExpInfo.ExpOpCount += 4
+
+
+ def IdEqValDoSpecial(self, ExpInfo, LineNo, QId, VarIdStr, BitMask, ConstVal, CompareType):
+
+ self.ConvertIdExpr(ExpInfo, LineNo, QId, VarIdStr, BitMask)
+ if ConstVal > 0xFF:
+ U16Obj = CIfrUint16(LineNo)
+ U16Obj.SetValue(ConstVal)
+ else:
+ U8Obj = CIfrUint8(LineNo)
+ U8Obj.SetValue(ConstVal)
+
+
+ if CompareType == EFI_COMPARE_TYPE.EQUAL:
+ EObj = CIfrEqual(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.LESS_EQUAL:
+ LEObj = CIfrLessEqual(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.LESS_THAN:
+ LTObj = CIfrLessThan(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.GREATER_EQUAL:
+ GEObj = CIfrGreaterEqual(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.GREATER_THAN:
+ GTObj = CIfrGreaterThan(LineNo)
+
+ ExpInfo.ExpOpCount += 2
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#ideqvalExp.
+ def visitIdeqvalExp(self, ctx:VfrSyntaxParser.IdeqvalExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ Mask = ctx.vfrQuestionDataFieldName().Mask
+ QId = ctx.vfrQuestionDataFieldName().QId
+ VarIdStr = ctx.vfrQuestionDataFieldName().VarIdStr
+ LineNo = ctx.vfrQuestionDataFieldName().Line
+ ConstVal = self.__TransNum(ctx.Number())
+ if ctx.Equal() != None:
+ if Mask == 0:
+ EIVObj = CIfrEqIdVal(Line)
+ self.__SaveOpHdrCond(EIVObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ EIVObj.SetQuestionId(QId, VarIdStr, LineNo)
+ EIVObj.SetValue(ConstVal)
+ ctx.ExpInfo.ExpOpCount += 1
+ else:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.EQUAL)
+
+ elif ctx.LessEqual() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_EQUAL)
+
+ elif ctx.Less() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_THAN)
+
+ elif ctx.GreaterEqual() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_EQUAL)
+
+ elif ctx.Greater() != None:
+ self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_THAN)
+
+ return ctx.ExpInfo
+
+
+ def IdEqIdDoSpecial(self, ExpInfo, LineNo, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, CompareType):
+
+ self.ConvertIdExpr(ExpInfo, LineNo, QId1, VarIdStr1, Mask1)
+ self.ConvertIdExpr(ExpInfo, LineNo, QId2, VarIdStr2, Mask2)
+
+ if CompareType == EFI_COMPARE_TYPE.EQUAL:
+ EObj = CIfrEqual(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.LESS_EQUAL:
+ LEObj = CIfrLessEqual(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.LESS_THAN:
+ LTObj = CIfrLessThan(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.GREATER_EQUAL:
+ GEObj = CIfrGreaterEqual(LineNo)
+
+ if CompareType == EFI_COMPARE_TYPE.GREATER_THAN:
+ GTObj = CIfrGreaterThan(LineNo)
+
+ ExpInfo.ExpOpCount += 1
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#ideqidExp.
+ def visitIdeqidExp(self, ctx:VfrSyntaxParser.IdeqidExpContext):
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ Mask1 = ctx.vfrQuestionDataFieldName(0).Mask
+ QId1 = ctx.vfrQuestionDataFieldName(0).QId
+ VarIdStr1 = ctx.vfrQuestionDataFieldName(0).VarIdStr
+ LineNo1 = ctx.vfrQuestionDataFieldName(0).Line
+
+ Mask2 = ctx.vfrQuestionDataFieldName(1).Mask
+ QId2 = ctx.vfrQuestionDataFieldName(1).QId
+ VarIdStr2 = ctx.vfrQuestionDataFieldName(1).VarIdStr
+ LineNo2 = ctx.vfrQuestionDataFieldName(1).Line
+
+ if ctx.Equal() != None:
+ if Mask1 & Mask2:
+ self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.EQUAL)
+ else:
+ EIIObj = CIfrEqIdId(Line)
+ self.__SaveOpHdrCond(EIIObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ EIIObj.SetQuestionId1(QId1, VarIdStr1, LineNo1)
+ EIIObj.SetQuestionId1(QId2, VarIdStr2, LineNo2)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ elif ctx.LessEqual() != None:
+ self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.LESS_EQUAL)
+
+ elif ctx.Less() != None:
+ self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.LESS_THAN)
+
+ elif ctx.GreaterEqual() != None:
+ self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.GREATER_EQUAL)
+
+ elif ctx.Greater() != None:
+ self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.GREATER_THAN)
+ return ctx.ExpInfo
+
+
+ def IdEqListDoSpecial(self, ExpInfo, LineNo, QId, VarIdStr, Mask, ListLen, ValueList):
+ if ListLen == 0:
+ return
+
+ self.IdEqValDoSpecial(ExpInfo, LineNo, QId, VarIdStr, Mask, ValueList[0], EFI_COMPARE_TYPE.EQUAL)
+ for i in range(1, ListLen):
+ self.IdEqValDoSpecial(ExpInfo, LineNo, QId, VarIdStr, Mask, ValueList[i], EFI_COMPARE_TYPE.EQUAL)
+ OObj = CIfrOr(LineNo)
+ ExpInfo.ExpOpCount += 1
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#ideqvallistExp.
+ def visitIdeqvallistExp(self, ctx:VfrSyntaxParser.IdeqvallistExpContext):
+ self.visitChildren(ctx)
+ Line = ctx.start.line
+ Mask = ctx.vfrQuestionDataFieldName().Mask
+ QId = ctx.vfrQuestionDataFieldName().QId
+ VarIdStr = ctx.vfrQuestionDataFieldName().VarIdStr
+ LineNo = ctx.vfrQuestionDataFieldName().Line
+ ValueList = []
+ for i in range(0, len(ctx.Number())):
+ ValueList.append(self.__TransNum(ctx.Number(i)))
+
+ ListLen = len(ValueList)
+
+ if Mask != 0:
+ self.IdEqListDoSpecial(ctx.ExpInfo, LineNo, QId, VarIdStr, Mask, ListLen, ValueList)
+ else:
+ EILObj = CIfrEqIdList(Line, ListLen)
+ if QId != EFI_QUESTION_ID_INVALID:
+ EILObj.SetQuestionId(QId, VarIdStr, LineNo)
+ EILObj.SetListLength(ListLen)
+ EILObj.SetValueList(ValueList)
+ self.__SaveOpHdrCond(EILObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ if QId == EFI_QUESTION_ID_INVALID:
+ EILObj.SetQuestionId(QId, VarIdStr, LineNo)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.ExpInfo
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionDataFieldNameRule1.
+ def visitVfrQuestionDataFieldNameRule1(self, ctx:VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context):
+ ctx.Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.VarIdStr += ctx.SN1.text
+ ctx.VarIdStr += '['
+ ctx.VarIdStr += ctx.I.text
+ ctx.VarIdStr += ']'
+ ctx.QId, ctx.Mask, _ = self.__CVfrQuestionDB.GetQuestionId(None, ctx.VarIdStr)
+ if self.__ConstantOnlyInExpression:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_CONSTANT_ONLY, ctx.SN1.line)
+ return ctx.QId, ctx.Mask, ctx.VarIdStr
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionDataFieldNameRule2.
+ def visitVfrQuestionDataFieldNameRule2(self, ctx:VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context):
+ ctx.Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.VarIdStr += ctx.SN2.text
+ for i in range(0, len(ctx.arrayName())):
+ ctx.VarIdStr += '.'
+ if self.__ConstantOnlyInExpression:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_CONSTANT_ONLY, ctx.SN2.line)
+ ctx.VarIdStr += ctx.arrayName(i).SubStrZ
+
+ ctx.QId, ctx.Mask, _ = self.__CVfrQuestionDB.GetQuestionId(None, ctx.VarIdStr)
+ return ctx.QId, ctx.Mask, ctx.VarIdStr
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#arrayName.
+ def visitArrayName(self, ctx:VfrSyntaxParser.ArrayNameContext):
+
+ self.visitChildren(ctx)
+ ctx.SubStr += self.__TransId(ctx.StringIdentifier())
+ ctx.SubStrZ += self.__TransId(ctx.StringIdentifier())
+ if ctx.N != None:
+ Idx = self.__TransNum(ctx.N.text)
+ if Idx > 0:
+ ctx.SubStr += '['
+ ctx.SubStr += str(Idx)
+ ctx.SubStr += ']'
+
+ ctx.SubStrZ += '['
+ ctx.SubStrZ += str(Idx)
+ ctx.SubStrZ += ']'
+
+ return ctx.SubStr, ctx.SubStrZ
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#questionref1Exp.
+ def visitQuestionref1Exp(self, ctx:VfrSyntaxParser.Questionref1ExpContext):
+ Line = ctx.start.line #
+ QName = None #
+ QId = EFI_QUESTION_ID_INVALID
+ self.visitChildren(ctx)
+ if ctx.StringIdentifier() != None:
+ QName = self.__TransId(ctx.StringIdentifier())
+ QId, _ , _ = self.__CVfrQuestionDB.GetQuestionId(QName)
+
+ elif ctx.Number() != None:
+ QId = self.__TransNum(ctx.Number())
+
+ QR1Obj = CIfrQuestionRef1(Line)
+ self.__SaveOpHdrCond(QR1Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ QR1Obj.SetQuestionId(QId, QName, Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#rulerefExp.
+ def visitRulerefExp(self, ctx:VfrSyntaxParser.RulerefExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ RRObj = CIfrRuleRef(Line)
+ self.__SaveOpHdrCond(RRObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ RuleId = self.__CVfrRulesDB.GetRuleId(self.__TransId(ctx.StringIdentifier()))
+ RRObj.SetRuleId(RuleId)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#stringref1Exp.
+ def visitStringref1Exp(self, ctx:VfrSyntaxParser.Stringref1ExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ RefStringId = self.__TransNum(ctx.Number())
+ SR1Obj = CIfrStringRef1(Line)
+ self.__SaveOpHdrCond(SR1Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ SR1Obj.SetStringId(RefStringId)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#pushthisExp.
+ def visitPushthisExp(self, ctx:VfrSyntaxParser.PushthisExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ TObj = CIfrThis(Line)
+ self.__SaveOpHdrCond(TObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+ # Visit a parse tree produced by VfrSyntaxParser#securityExp.
+ def visitSecurityExp(self, ctx:VfrSyntaxParser.SecurityExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ SObj = CIfrSecurity(Line)
+ self.__SaveOpHdrCond(SObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ SObj.SetPermissions(ctx.guidDefinition().Guid)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+ # Visit a parse tree produced by VfrSyntaxParser#numericVarStoreType.
+ def visitNumericVarStoreType(self, ctx:VfrSyntaxParser.NumericVarStoreTypeContext):
+ self.visitChildren(ctx)
+ if ctx.NumericSizeOne() != None:
+ ctx.VarType = EFI_IFR_NUMERIC_SIZE_1
+ if ctx.NumericSizeTwo() != None:
+ ctx.VarType = EFI_IFR_NUMERIC_SIZE_2
+ if ctx.NumericSizeFour() != None:
+ ctx.VarType = EFI_IFR_NUMERIC_SIZE_4
+ if ctx.NumericSizeEight() != None:
+ ctx.VarType = EFI_IFR_NUMERIC_SIZE_8
+
+ return ctx.VarType
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#getExp.
+ def visitGetExp(self, ctx:VfrSyntaxParser.GetExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ if ctx.BaseInfo.VarStoreId == 0:
+ # support Date/Time question
+ VarIdStr = ctx.vfrStorageVarId().VarIdStr
+ QId, Mask, QType = self.__CVfrQuestionDB.GetQuestionId(None, VarIdStr, EFI_QUESION_TYPE.QUESTION_NORMAL)
+ if (QId == EFI_QUESTION_ID_INVALID) or (Mask == 0) or (QType == EFI_QUESION_TYPE.QUESTION_NORMAL):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
+ if QType == EFI_QUESION_TYPE.QUESTION_DATE:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
+ elif QType == EFI_QUESION_TYPE.QUESTION_TIME:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
+
+ if Mask == DATE_YEAR_BITMASK:
+ ctx.BaseInfo.VarOffset = 0
+ elif Mask == DATE_DAY_BITMASK:
+ ctx.BaseInfo.VarOffset = 3
+ elif Mask == TIME_HOUR_BITMASK:
+ ctx.BaseInfo.VarOffset = 0
+ elif Mask == TIME_MINUTE_BITMASK:
+ ctx.BaseInfo.VarOffset = 1
+ elif Mask == TIME_SECOND_BITMASK:
+ ctx.BaseInfo.VarOffset = 2
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
+
+ else:
+ VarType = EFI_IFR_TYPE_UNDEFINED
+ if ctx.FLAGS() != None:
+ VarType = ctx.numericVarStoreType().VarType
+
+ if (gCVfrDataStorage.GetVarStoreType(ctx.BaseInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_NAME) and (VarType == EFI_IFR_TYPE_UNDEFINED):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support name string")
+
+ if VarType != EFI_IFR_TYPE_UNDEFINED:
+ ctx.BaseInfo.VarType = VarType
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
+ ctx.BaseInfo.VarTotalSize = Size
+
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
+
+ if Size != ctx.BaseInfo.VarTotalSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support data array")
+
+ ctx.GObj = CIfrGet(Line)
+ self.__SaveOpHdrCond(ctx.GObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.GObj.SetVarInfo(ctx.BaseInfo)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.GObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionConstant.
+ def visitVfrExpressionConstant(self, ctx:VfrSyntaxParser.VfrExpressionConstantContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ if ctx.TrueSymbol() != None:
+ TObj = CIfrTrue(Line)
+ self.__SaveOpHdrCond(TObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.FalseSymbol() != None:
+ FObj = CIfrFalse(Line)
+ self.__SaveOpHdrCond(FObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.One() != None:
+ OObj = CIfrOne(Line)
+ self.__SaveOpHdrCond(OObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.Ones() != None:
+ OObj = CIfrOnes(Line)
+ self.__SaveOpHdrCond(OObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.Zero() != None:
+ ZObj = CIfrZero(Line)
+ self.__SaveOpHdrCond(ZObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.Undefined() != None:
+ UObj = CIfrUndefined(Line)
+ self.__SaveOpHdrCond(UObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.Version() != None:
+ VObj = CIfrVersion(Line)
+ self.__SaveOpHdrCond(VObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ if ctx.Number() != None:
+ U64Obj = CIfrUint64(Line)
+ U64Obj.SetValue(self.__TransNum(ctx.Number()))
+ self.__SaveOpHdrCond(U64Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionUnaryOp.
+ def visitVfrExpressionUnaryOp(self, ctx:VfrSyntaxParser.VfrExpressionUnaryOpContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#lengthExp.
+ def visitLengthExp(self, ctx:VfrSyntaxParser.LengthExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.LObj = CIfrLength(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.LObj
+
+ # Visit a parse tree produced by VfrSyntaxParser#bitwisenotExp.
+ def visitBitwisenotExp(self, ctx:VfrSyntaxParser.BitwisenotExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.BWNObj = CIfrBitWiseNot(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.BWNObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#question23refExp.
+ def visitQuestion23refExp(self, ctx:VfrSyntaxParser.Question23refExpContext):
+ Line = ctx.start.line
+ Type = 0x1
+ DevicePath = EFI_STRING_ID_INVALID
+ self.visitChildren(ctx)
+ if ctx.DevicePath() != None:
+ Type = 0x2
+ DevicePath = self.__TransNum(ctx.Number())
+
+ if ctx.Uuid() != None:
+ Type = 0x3
+
+ if Type == 0x1:
+ QR2Obj = CIfrQuestionRef2(Line)
+ self.__SaveOpHdrCond(QR2Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+
+ if Type == 0x2:
+ QR3_2Obj = CIfrQuestionRef3_2(Line)
+ self.__SaveOpHdrCond(QR3_2Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ QR3_2Obj.SetDevicePath(DevicePath)
+
+ if Type == 0x3:
+ QR3_3Obj = CIfrQuestionRef3_3(Line)
+ self.__SaveOpHdrCond(QR3_3Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ QR3_3Obj.SetDevicePath(DevicePath)
+ QR3_3Obj.SetGuid(ctx.guidDefinition().Guid)
+
+ ctx.ExpInfo.ExpOpCount += 1
+
+
+ return ctx.ExpInfo
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#stringref2Exp.
+ def visitStringref2Exp(self, ctx:VfrSyntaxParser.Stringref2ExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.SR2Obj = CIfrStringRef2(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.SR2Obj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#toboolExp.
+ def visitToboolExp(self, ctx:VfrSyntaxParser.ToboolExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.TBObj = CIfrToBoolean(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TBObj
+
+ # Visit a parse tree produced by VfrSyntaxParser#tostringExp.
+ def visitTostringExp(self, ctx:VfrSyntaxParser.TostringExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.TSObj = CIfrToString(Line)
+ Fmt = self.__TransNum(ctx.Number())
+ ctx.TSObj.SetFormat(Fmt)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TSObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#unintExp.
+ def visitUnintExp(self, ctx:VfrSyntaxParser.UnintExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.TUObj = CIfrToUint(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TUObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#toupperExp.
+ def visitToupperExp(self, ctx:VfrSyntaxParser.ToupperExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.TUObj = CIfrToUpper(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TUObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#tolwerExp.
+ def visitTolwerExp(self, ctx:VfrSyntaxParser.TolwerExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.TLObj = CIfrToLower(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TLObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#setExp.
+ def visitSetExp(self, ctx:VfrSyntaxParser.SetExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ if ctx.BaseInfo.VarStoreId == 0:
+ # support Date/Time question
+ VarIdStr = ctx.vfrStorageVarId().VarIdStr
+ QId, Mask, QType = self.__CVfrQuestionDB.GetQuestionId(None, VarIdStr, EFI_QUESION_TYPE.QUESTION_NORMAL)
+ if (QId == EFI_QUESTION_ID_INVALID) or (Mask == 0) or (QType == EFI_QUESION_TYPE.QUESTION_NORMAL):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
+ if QType == EFI_QUESION_TYPE.QUESTION_DATE:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
+ elif QType == EFI_QUESION_TYPE.QUESTION_TIME:
+ ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
+
+ if Mask == DATE_YEAR_BITMASK:
+ ctx.BaseInfo.VarOffset = 0
+ elif Mask == DATE_DAY_BITMASK:
+ ctx.BaseInfo.VarOffset = 3
+ elif Mask == TIME_HOUR_BITMASK:
+ ctx.BaseInfo.VarOffset = 0
+ elif Mask == TIME_MINUTE_BITMASK:
+ ctx.BaseInfo.VarOffset = 1
+ elif Mask == TIME_SECOND_BITMASK:
+ ctx.BaseInfo.VarOffset = 2
+ else:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
+
+ else:
+ VarType = EFI_IFR_TYPE_UNDEFINED
+ if ctx.FLAGS() != None:
+ VarType = ctx.numericVarStoreType().VarType
+
+ if (gCVfrDataStorage.GetVarStoreType(ctx.BaseInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_NAME) and (VarType == EFI_IFR_TYPE_UNDEFINED):
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support name string")
+
+ if VarType != EFI_IFR_TYPE_UNDEFINED:
+ ctx.BaseInfo.VarType = VarType
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
+ ctx.BaseInfo.VarTotalSize = Size
+
+ Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
+ self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
+
+ if Size != ctx.BaseInfo.VarTotalSize:
+ self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support data array")
+
+ ctx.TSObj = CIfrSet(Line)
+ self.__SaveOpHdrCond(ctx.TSObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
+ ctx.TSObj.SetVarInfo(ctx.BaseInfo)
+ ctx.ExpInfo.ExpOpCount += 1
+
+ return ctx.TSObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionTernaryOp.
+ def visitVfrExpressionTernaryOp(self, ctx:VfrSyntaxParser.VfrExpressionTernaryOpContext):
+ return self.visitChildren(ctx)
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#conditionalExp.
+ def visitConditionalExp(self, ctx:VfrSyntaxParser.ConditionalExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.CObj = CIfrConditional(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.CObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#findExp.
+ def visitFindExp(self, ctx:VfrSyntaxParser.FindExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ FObj = CIfrFind(Line)
+ Format = 0
+ for i in range(0, len(ctx.findFormat())):
+ Format = ctx.findFormat(i).Format
+
+ FObj.SetFormat(Format)
+ ctx.ExpInfo.ExpOpCount += 1
+ return FObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#findFormat.
+ def visitFindFormat(self, ctx:VfrSyntaxParser.FindFormatContext):
+ self.visitChildren(ctx)
+ if ctx.Sensitive() != None:
+ ctx.Format = 0x00
+ elif ctx.Insensitive() != None:
+ ctx.Format = 0x01
+ return ctx.Format
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#midExp.
+ def visitMidExp(self, ctx:VfrSyntaxParser.MidExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.MObj = CIfrMid(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.MObj
+
+ # Visit a parse tree produced by VfrSyntaxParser#tokenExp.
+ def visitTokenExp(self, ctx:VfrSyntaxParser.TokenExpContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.TObj = CIfrToken(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.TObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#spanExp.
+ def visitSpanExp(self, ctx:VfrSyntaxParser.SpanExpContext):
+ Line = ctx.start.line
+ Flags = 0
+ self.visitChildren(ctx)
+ for FlagsCtx in ctx.spanFlags():
+ Flags |= FlagsCtx.Flag
+ ctx.SObj = CIfrSpan(Line)
+ ctx.SObj.SetFlags(Flags)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.SObj
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#spanFlags.
+ def visitSpanFlags(self, ctx:VfrSyntaxParser.SpanFlagsContext):
+ self.visitChildren(ctx)
+ if ctx.Number() != None:
+ ctx.Flag = self.__TransNum(ctx.Number())
+ elif ctx.LastNonMatch() != None:
+ ctx.Flag = 0x00
+ elif ctx.FirstNonMatch() != None:
+ ctx.Flag = 0x01
+ return ctx.Flag
+
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionMap.
+ def visitVfrExpressionMap(self, ctx:VfrSyntaxParser.VfrExpressionMapContext):
+ Line = ctx.start.line
+ self.visitChildren(ctx)
+ ctx.MObj = CIfrMap(Line)
+ EObj = CIfrEnd()
+ Line = (None if ctx.stop is None else ctx.stop).line
+ EObj.SetLineNo(Line)
+ ctx.ExpInfo.ExpOpCount += 1
+ return ctx.MObj
+
+ def __GetText(self, ctx):
+ if ctx == None:
+ return None
+ else:
+ return ctx.text
+
+ def __TransId(self, StringIdentifierToken, DefaultValue=None):
+ if StringIdentifierToken == None:
+ return DefaultValue
+ else:
+ return str(StringIdentifierToken)
+
+ def __TransNum(self, NumberToken, DefaultValue=0):
+ if NumberToken == None:
+ return DefaultValue
+ else:
+ StrToken = str(NumberToken)
+ if '0x' in StrToken:
+ NumberToken = int(StrToken, 0)
+ else:
+ NumberToken = int(StrToken)
+ # error handle , value is too large to store
+ return NumberToken
+
+ def __AssignQuestionKey(self, OpObj, Key):
+
+ if Key == None:
+ return
+ if OpObj.GetFlags() & EFI_IFR_FLAG_CALLBACK:
+ # if the question is not CALLBACK ignore the key.
+ self.__CVfrQuestionDB.UpdateQuestionId(OpObj.GetQuestionId(), Key)
+ OpObj.SetQuestionId(Key)
+ return
+
+ def __ExtractOriginalText(self, ctx):
+ Source = ctx.start.getTokenSource()
+ InputStream = Source.inputStream
+ start, stop = ctx.start.start, ctx.stop.stop
+ Text = InputStream.getText(start, stop)
+ return Text.replace('\n', '')
+
+ def __CheckDuplicateDefaultValue(self, DefaultId, Line, TokenValue):
+ for i in range(0, len(self.__UsedDefaultArray)):
+ if self.__UsedDefaultArray[i] == DefaultId:
+ gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_DEFAULT_VALUE_REDEFINED, Line, TokenValue)
+
+ if len(self.__UsedDefaultArray) >= EFI_IFR_MAX_DEFAULT_TYPE - 1:
+ gCVfrErrorHandle.HandleError(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, TokenValue)
+
+ self.__UsedDefaultArray.append(DefaultId)
+
+ def __ErrorHandler(self, ReturnCode, LineNum, TokenValue=None):
+ self.__ParserStatus += gCVfrErrorHandle.HandleError(ReturnCode, LineNum, TokenValue)
+
+ def __CompareErrorHandler(self, ReturnCode, ExpectedCode, LineNum, TokenValue=None, ErrorMsg=None):
+ if ReturnCode != ExpectedCode:
+ self.__ParserStatus += 1
+ gCVfrErrorHandle.PrintMsg(LineNum, 'Error', ErrorMsg, TokenValue)
+
+ def __InsertChild(self, ParentNode: VfrTreeNode, ChildCtx):
+ if ChildCtx != None and ChildCtx.Node != None:
+ ParentNode.insertChild(ChildCtx.Node)
+
+ def GetRoot(self):
+ return self.__Root
+
+ def GetQuestionDB(self):
+ return self.__CVfrQuestionDB
+
+ def DumpJson(self, FileName):
+ try:
+ with open(FileName, 'w') as f:
+ f.write('{\n')
+ f.write(' \"DataStruct\" : {\n')
+ pNode = gCVfrVarDataTypeDB.GetDataTypeList()
+ while pNode != None:
+ f.write(' \"{}\" : [\n'.format(str(pNode.TypeName)))
+ FNode = pNode.Members
+ while FNode != None:
+ f.write(' {\n')
+ f.write(' \"Name\": \"{}\",\n'.format(str(FNode.FieldName)))
+ if FNode.ArrayNum > 0:
+ f.write(' \"Type\": \"{}[{}]\",\n'.format(str(FNode.FieldType.TypeName),str(FNode.ArrayNum)))
+ else:
+ f.write(' \"Type\": \"{}\",\n'.format(str(FNode.FieldType.TypeName)))
+ f.write(' \"Offset\": {}\n'.format(str(FNode.Offset)))
+ if FNode.Next == None:
+ f.write(' }\n')
+ else:
+ f.write(' }, \n')
+ FNode = FNode.Next
+ if pNode.Next == None:
+ f.write(' ]\n')
+ else:
+ f.write(' ],\n')
+ pNode = pNode.Next
+ f.write(' },\n')
+ f.write(' \"DataStructAttribute\": {\n')
+ pNode = gCVfrVarDataTypeDB.GetDataTypeList()
+ while pNode != None:
+ f.write(' \"{}\"'.format(str(pNode.TypeName)) + ': {\n')
+ f.write(' \"Alignment\": {},\n'.format(str(pNode.Align)))
+ f.write(' \"TotalSize\": {}\n'.format(str(pNode.TotalSize)))
+ if pNode.Next == None:
+ f.write(' }\n')
+ else:
+ f.write(' },\n')
+ pNode = pNode.Next
+ f.write(' },\n')
+ f.write(' \"VarDefine\" : {\n')
+ pVsNode = gCVfrDataStorage.GetBufferVarStoreList()
+ while pVsNode != None:
+ f.write(' \"{}\"'.format(str(pVsNode.VarStoreName)) + ': {\n')
+ f.write(' \"Type\": \"{}\",\n'.format(str(pVsNode.DataType.TypeName)))
+ f.write(' \"Attributes\": {},\n'.format(str(pVsNode.Attributes)))
+ f.write(' \"VarStoreId\": {},\n'.format(str(pVsNode.VarStoreId)))
+ f.write(' \"VendorGuid\": ' + '\"{}, {}, {},'.format('0x%x'%(pVsNode.Guid.Data1),'0x%x'%(pVsNode.Guid.Data2), '0x%x'%(pVsNode.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(pVsNode.Guid.Data4[0]), '0x%x'%(pVsNode.Guid.Data4[1]), '0x%x'%(pVsNode.Guid.Data4[2]), '0x%x'%(pVsNode.Guid.Data4[3]), \
+ '0x%x'%(pVsNode.Guid.Data4[4]), '0x%x'%(pVsNode.Guid.Data4[5]), '0x%x'%(pVsNode.Guid.Data4[6]), '0x%x'%(pVsNode.Guid.Data4[7])) + ' }}\"\n')
+ if pVsNode.Next == None:
+ f.write(' }\n')
+ else:
+ f.write(' },\n')
+
+ pVsNode = pVsNode.Next
+ f.write(' },\n')
+ f.write(' \"Data\" : [\n')
+ pVsNode = gCVfrBufferConfig.GetVarItemList()
+ while pVsNode != None:
+ if pVsNode.Id == None:
+ pVsNode = pVsNode.Next
+ continue
+ pInfoNode = pVsNode.InfoStrList
+ while pInfoNode != None:
+ f.write(' {\n')
+ f.write(' \"VendorGuid\": ' + '\"{}, {}, {},'.format('0x%x'%(pVsNode.Guid.Data1),'0x%x'%(pVsNode.Guid.Data2), '0x%x'%(pVsNode.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(pVsNode.Guid.Data4[0]), '0x%x'%(pVsNode.Guid.Data4[1]), '0x%x'%(pVsNode.Guid.Data4[2]), '0x%x'%(pVsNode.Guid.Data4[3]), \
+ '0x%x'%(pVsNode.Guid.Data4[4]), '0x%x'%(pVsNode.Guid.Data4[5]), '0x%x'%(pVsNode.Guid.Data4[6]), '0x%x'%(pVsNode.Guid.Data4[7])) + ' }}\",\n')
+ f.write(' \"VarName\": \"{}\",\n'.format(str(pVsNode.Name)))
+ f.write(' \"DefaultStore\": \"{}\",\n'.format(str(pVsNode.Id)))
+ f.write(' \"Size\": \"{}\",\n'.format(str(pInfoNode.Width)))
+ f.write(' \"Offset\": {},\n'.format(str(pInfoNode.Offset)))
+ #f.write(' \"Value\": \"{}\"\n'.format(str(pInfoNode.Value)))
+ if pInfoNode.Type == EFI_IFR_TYPE_DATE:
+ f.write(' \"Value\": \"{}/{}/{}\"\n'.format(pInfoNode.Value.date.Year, pInfoNode.Value.date.Month, pInfoNode.Value.date.Day))
+ if pInfoNode.Type == EFI_IFR_TYPE_TIME:
+ f.write(' \"Value\": \"{}:{}:{}\"\n'.format(pInfoNode.Value.time.Hour, pInfoNode.Value.time.Minute, pInfoNode.Value.time.Second))
+ if pInfoNode.Type == EFI_IFR_TYPE_REF:
+ f.write(' \"Value\": \"{};{};'.format(pInfoNode.Value.ref.QuestionId, pInfoNode.Value.ref.FormId) + '{' + '{}, {}, {},'.format('0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data1),'0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data2), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[0]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[1]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[2]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[3]), \
+ '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[4]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[5]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[6]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[7])) + ' }}' + ';{}\n'.format(pInfoNode.Value.ref.DevicePath))
+ if pInfoNode.Type == EFI_IFR_TYPE_STRING:
+ f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.string))
+ if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.u8))
+ if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.u16))
+ if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.u32))
+ if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.u64))
+ if pInfoNode.Type == EFI_IFR_TYPE_BOOLEAN:
+ f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.b))
+
+ f.write(' },\n')
+ pInfoNode = pInfoNode.Next
+ pVsNode = pVsNode.Next
+ f.write(' {\n')
+ f.write(' \"VendorGuid\": \"NA\",\n')
+ f.write(' \"VarName\": \"NA\",\n')
+ f.write(' \"DefaultStore\": \"NA\",\n')
+ f.write(' \"Size\": 0,\n')
+ f.write(' \"Offset\": 0,\n')
+ f.write(' \"Value\": \"0x00\"\n')
+ f.write(' }\n')
+ f.write(' ]\n')
+ f.write('}\n')
+
+ f.close()
+ except:
+ EdkLogger.error("VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" % FileName, None)
+
+ def DumpYaml(self, Root, FileName):
+ try:
+ with open(FileName, 'w') as f:
+ f.write('## DO NOT REMOVE -- VFR Mode\n')
+ self.DumpYamlDfs(Root, f)
+ f.close()
+ except:
+ EdkLogger.error("VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" % FileName, None)
+
+ def DumpYamlDfs(self, Root, f):
+
+ if Root.OpCode != None:
+
+ if Root.OpCode == EFI_IFR_FORM_SET_OP:
+ Info = Root.Data.GetInfo()
+ f.write('Formset:\n')
+ f.write(' Guid: {' + '{}, {}, {},'.format('0x%x'%(Info.Guid.Data1),'0x%x'%(Info.Guid.Data2), '0x%x'%(Info.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Guid.Data4[0]), '0x%x'%(Info.Guid.Data4[1]), '0x%x'%(Info.Guid.Data4[2]), '0x%x'%(Info.Guid.Data4[3]), \
+ '0x%x'%(Info.Guid.Data4[4]), '0x%x'%(Info.Guid.Data4[5]), '0x%x'%(Info.Guid.Data4[6]), '0x%x'%(Info.Guid.Data4[7])) + ' }}\n')
+ f.write(' Title: {} # Title STRING_ID\n'.format(Info.FormSetTitle))
+ f.write(' Help: {} # Help STRING_ID\n'.format(Info.Help))
+ for Guid in Root.Data.GetClassGuid():
+ f.write(' ClassGuid: {' + '{}, {}, {},'.format('0x%x'%(Guid.Data1),'0x%x'%(Guid.Data2), '0x%x'%(Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Guid.Data4[0]), '0x%x'%(Guid.Data4[1]), '0x%x'%(Guid.Data4[2]), '0x%x'%(Guid.Data4[3]), \
+ '0x%x'%(Guid.Data4[4]), '0x%x'%(Guid.Data4[5]), '0x%x'%(Guid.Data4[6]), '0x%x'%(Guid.Data4[7])) + ' }}\n')
+
+ if Root.OpCode == EFI_IFR_VARSTORE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - varstore:\n')
+ f.write(' varid: {}\n'.format(Info.VarStoreId))
+ f.write(' name: {}\n'.format(Info.Name))
+ f.write(' size: {}\n'.format(Info.Size))
+ f.write(' guid: {' + '{}, {}, {},'.format('0x%x'%(Info.Guid.Data1),'0x%x'%(Info.Guid.Data2), '0x%x'%(Info.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Guid.Data4[0]), '0x%x'%(Info.Guid.Data4[1]), '0x%x'%(Info.Guid.Data4[2]), '0x%x'%(Info.Guid.Data4[3]), \
+ '0x%x'%(Info.Guid.Data4[4]), '0x%x'%(Info.Guid.Data4[5]), '0x%x'%(Info.Guid.Data4[6]), '0x%x'%(Info.Guid.Data4[7])) + ' }}\n')
+
+ if Root.OpCode == EFI_IFR_VARSTORE_EFI_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - efivarstore:\n')
+ f.write(' varid: {}\n'.format(Info.VarStoreId))
+ f.write(' name: {}\n'.format(Info.Name))
+ f.write(' size: {}\n'.format(Info.Size))
+ f.write(' guid: {' + '{}, {}, {},'.format('0x%x'%(Info.Guid.Data1),'0x%x'%(Info.Guid.Data2), '0x%x'%(Info.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Guid.Data4[0]), '0x%x'%(Info.Guid.Data4[1]), '0x%x'%(Info.Guid.Data4[2]), '0x%x'%(Info.Guid.Data4[3]), \
+ '0x%x'%(Info.Guid.Data4[4]), '0x%x'%(Info.Guid.Data4[5]), '0x%x'%(Info.Guid.Data4[6]), '0x%x'%(Info.Guid.Data4[7])) + ' }}\n')
+ f.write(' attribute: {}\n'.format(Info.Attributes))
+
+ if Root.OpCode == EFI_IFR_VARSTORE_NAME_VALUE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - namevaluevarstore:\n')
+ f.write(' varid: {}\n'.format(Info.VarStoreId))
+ # f.write(' name: {}\n'.format(Info.Name))
+ f.write(' guid: {' + '{}, {}, {},'.format('0x%x'%(Info.Guid.Data1),'0x%x'%(Info.Guid.Data2), '0x%x'%(Info.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Guid.Data4[0]), '0x%x'%(Info.Guid.Data4[1]), '0x%x'%(Info.Guid.Data4[2]), '0x%x'%(Info.Guid.Data4[3]), \
+ '0x%x'%(Info.Guid.Data4[4]), '0x%x'%(Info.Guid.Data4[5]), '0x%x'%(Info.Guid.Data4[6]), '0x%x'%(Info.Guid.Data4[7])) + ' }}\n')
+
+ if Root.OpCode == EFI_IFR_FORM_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - form:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' FormId: {} # FormId STRING_ID\n'.format(Info.FormId))
+ f.write(' FormTitle: {} # FormTitle STRING_ID\n'.format(Info.FormTitle))
+
+ if Root.OpCode == EFI_IFR_FORM_MAP_OP:
+ Info, MethodMapList = Root.Data.GetInfo()
+ f.write(' - formmap:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' FormId: {} # FormId STRING_ID\n'.format(Info.FormId))
+ for MethodMap in MethodMapList:
+ f.write(' maptitle: {}\n'.format(MethodMap.MethodTitle))
+ f.write(' mapguid: {' + '{}, {}, {},'.format('0x%x'%(MethodMap.MethodIdentifier.Data1),'0x%x'%(MethodMap.MethodIdentifier.Data2), '0x%x'%(MethodMap.MethodIdentifier.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(MethodMap.MethodIdentifier.Data4[0]), '0x%x'%(MethodMap.MethodIdentifier.Data4[1]), '0x%x'%(MethodMap.MethodIdentifier.Data4[2]), '0x%x'%(MethodMap.MethodIdentifier.Data4[3]), \
+ '0x%x'%(MethodMap.MethodIdentifier.Data4[4]), '0x%x'%(MethodMap.MethodIdentifier.Data4[5]), '0x%x'%(MethodMap.MethodIdentifier.Data4[6]), '0x%x'%(MethodMap.MethodIdentifier.Data4[7])) + ' }}\n')
+
+ if Root.OpCode == EFI_IFR_IMAGE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - image:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' Id: {} # ImageId\n'.format(Info.Id))
+
+ if Root.OpCode == EFI_IFR_RULE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - rule:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' RuleId: {} # RuleId\n'.format(Info.RuleId))
+
+ if Root.OpCode == EFI_IFR_SUBTITLE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - subtitle:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Statement.Prompt))
+
+ if Root.OpCode == EFI_IFR_TEXT_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - text:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Statement.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Statement.Help))
+ f.write(' text: {} # Statement Help STRING_ID\n'.format(Info.TextTwo))
+
+ if Root.OpCode == EFI_IFR_ACTION_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - action:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
+ f.write(' questionconfig: {} # QuestionConfig\n'.format(Info.QuestionConfig))
+
+ if Root.OpCode == EFI_IFR_ONE_OF_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - oneof:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
+
+ if Root.OpCode == EFI_IFR_ONE_OF_OPTION_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - option: {}\n'.format(Info.Option))
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ f.write(' option flag: {}\n'.format(Info.Flags))
+ f.write(' option type: {}\n'.format(Info.Type))
+
+ if type(Root.Data) == CIfrOneOfOption:
+ if Info.Type == EFI_IFR_TYPE_DATE:
+ f.write(' option value: {}/{}/{}\n'.format(Info.Value.date.Year, Info.Value.date.Month, Info.Value.date.Day))
+ if Info.Type == EFI_IFR_TYPE_TIME:
+ f.write(' option value: {}:{}:{}\n'.format(Info.Value.time.Hour, Info.Value.time.Minute, Info.Value.time.Second))
+ if Info.Type == EFI_IFR_TYPE_REF:
+ f.write(' option value: {};{};'.format(Info.Value.ref.QuestionId, Info.Value.ref.FormId) + '{' + '{}, {}, {},'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data1),'0x%x'%(Info.Value.ref.FormSetGuid.Data2), '0x%x'%(Info.Value.ref.FormSetGuid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data4[0]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[1]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[2]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[3]), \
+ '0x%x'%(Info.Value.ref.FormSetGuid.Data4[4]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[5]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[6]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[7])) + ' }}' + ';{}\n'.format(Info.Value.ref.DevicePath))
+ if Info.Type == EFI_IFR_TYPE_STRING:
+ f.write(' option value: {}\n'.format(Info.Value.string))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ f.write(' option value: {}\n'.format(Info.Value.u8))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ f.write(' option value: {}\n'.format(Info.Value.u16))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ f.write(' option value: {}\n'.format(Info.Value.u32))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ f.write(' option value: {}\n'.format(Info.Value.u64))
+ if Info.Type == EFI_IFR_TYPE_BOOLEAN:
+ f.write(' option value: {}\n'.format(Info.Value.b))
+
+ if type(Root.Data) == CIfrOneOfOption2:
+ f.write(' value: {')
+ ValueType = Root.Data.GetValueType()
+ if ValueType == EFI_IFR_TYPE_STRING:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].string))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].string) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_8:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u8))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u8) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_16:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u16))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u16) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_32:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u32))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u32) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_64:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u64))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u64) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_BOOLEAN:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].b))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].b) + '}\n')
+
+
+ if Root.OpCode == EFI_IFR_DEFAULT_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - default:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' type: {}\n'.format(Info.Type))
+ f.write(' defaultId: {}\n'.format(Info.DefaultId))
+ if type(Root.Data) == CIfrDefault:
+ if Info.Type == EFI_IFR_TYPE_DATE:
+ f.write(' value: {}/{}/{}\n'.format(Info.Value.date.Year, Info.Value.date.Month, Info.Value.date.Day))
+ if Info.Type == EFI_IFR_TYPE_TIME:
+ f.write(' value: {}:{}:{}\n'.format(Info.Value.time.Hour, Info.Value.time.Minute, Info.Value.time.Second))
+ if Info.Type == EFI_IFR_TYPE_REF:
+ f.write(' option value: {};{};'.format(Info.Value.ref.QuestionId, Info.Value.ref.FormId) + '{' + '{}, {}, {},'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data1),'0x%x'%(Info.Value.ref.FormSetGuid.Data2), '0x%x'%(Info.Value.ref.FormSetGuid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data4[0]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[1]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[2]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[3]), \
+ '0x%x'%(Info.Value.ref.FormSetGuid.Data4[4]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[5]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[6]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[7])) + ' }}' + ';{}\n'.format(Info.Value.ref.DevicePath))
+ if Info.Type == EFI_IFR_TYPE_STRING:
+ f.write(' value: {}\n'.format(Info.Value.string))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_8:
+ f.write(' value: {}\n'.format(Info.Value.u8))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_16:
+ f.write(' value: {}\n'.format(Info.Value.u16))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_32:
+ f.write(' value: {}\n'.format(Info.Value.u32))
+ if Info.Type == EFI_IFR_TYPE_NUM_SIZE_64:
+ f.write(' value: {}\n'.format(Info.Value.u64))
+ if Info.Type == EFI_IFR_TYPE_BOOLEAN:
+ f.write(' value: {}\n'.format(Info.Value.b))
+
+ if type(Root.Data) == CIfrDefault3:
+ f.write(' value: {')
+ ValueType = Root.Data.GetValueType()
+ if ValueType == EFI_IFR_TYPE_STRING:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].string))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].string) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_8:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u8))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u8) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_16:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u16))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u16) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_32:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u32))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u32) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_NUM_SIZE_64:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].u64))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].u64) + '}\n')
+
+ if ValueType == EFI_IFR_TYPE_BOOLEAN:
+ for i in range(0, len(Info.Value)-1):
+ f.write('{},'.format(Info.Value[i].b))
+ f.write('{}'.format(Info.Value[len(Info.Value)-1].b) + '}\n')
+
+ if Root.OpCode == EFI_IFR_ORDERED_LIST_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - orderedlist:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' maxContainers: {}\n'.format(Info.MaxContainers))
+ f.write(' flags: {}\n'.format(Info.Question.Flags))
+
+ if Root.OpCode == EFI_IFR_NUMERIC_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - numeric:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
+
+ if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_64:
+ f.write(' maxvalue: {}\n'.format(Info.Data.u64.MaxValue))
+ f.write(' minvalue: {}\n'.format(Info.Data.u64.MinValue))
+ f.write(' step: {}\n'.format(Info.Data.u64.Step))
+
+ if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_32:
+ f.write(' maxvalue: {}\n'.format(Info.Data.u32.MaxValue))
+ f.write(' minvalue: {}\n'.format(Info.Data.u32.MinValue))
+ f.write(' step: {}\n'.format(Info.Data.u32.Step))
+
+ if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_16:
+ f.write(' maxvalue: {}\n'.format(Info.Data.u16.MaxValue))
+ f.write(' minvalue: {}\n'.format(Info.Data.u16.MinValue))
+ f.write(' step: {}\n'.format(Info.Data.u16.Step))
+
+ if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_8:
+ f.write(' maxvalue: {}\n'.format(Info.Data.u8.MaxValue))
+ f.write(' minvalue: {}\n'.format(Info.Data.u8.MinValue))
+ f.write(' step: {}\n'.format(Info.Data.u8.Step))
+
+ if Root.OpCode == EFI_IFR_CHECKBOX_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - checkbox:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' flags: {} # Flags\n'.format(Info.Flags))
+
+ if Root.OpCode == EFI_IFR_TIME_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - time:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' questionid: {} # Statement Prompt STRING_ID\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {}\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {}\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' flags: {}\n'.format(Info.Flags))
+
+ if Root.OpCode == EFI_IFR_DATE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - date:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' questionid: {} # Statement Prompt STRING_ID\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {}\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {}\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' flags: {}\n'.format(Info.Flags))
+
+
+ if Root.OpCode == EFI_IFR_STRING_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - string:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
+ f.write(' stringflags: {}\n'.format(Info.Flags))
+ f.write(' stringminsize: {}\n'.format(Info.MinSize))
+ f.write(' stringmaxsize: {}\n'.format(Info.MaxSize))
+
+ if Root.OpCode == EFI_IFR_PASSWORD_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - password:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
+ f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
+ f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
+ f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
+ f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
+ f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
+ f.write(' minsize: {}\n'.format(Info.MinSize))
+ f.write(' maxsize: {}\n'.format(Info.MaxSize))
+
+
+ if Root.OpCode == EFI_IFR_RESET_BUTTON_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - resetbutton:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Statement.Prompt))
+ f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Statement.Help))
+ f.write(' defaultid: {}\n'.format(Info.DefaultId))
+
+ if Root.OpCode == EFI_IFR_REF_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - goto:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ if type(Root.Data) == CIfrRef4:
+ f.write(' formid: {}\n'.format(Info.FormId))
+ f.write(' formsetid: {' + '{}, {}, {},'.format('0x%x'%(Info.FormSetId.Data1),'0x%x'%(Info.FormSetId.Data2), '0x%x'%(Info.FormSetId.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.FormSetId.Data4[0]), '0x%x'%(Info.FormSetId.Data4[1]), '0x%x'%(Info.FormSetId.Data4[2]), '0x%x'%(Info.FormSetId.Data4[3]), \
+ '0x%x'%(Info.FormSetId.Data4[4]), '0x%x'%(Info.FormSetId.Data4[5]), '0x%x'%(Info.FormSetId.Data4[6]), '0x%x'%(Info.FormSetId.Data4[7])) + ' }}\n')
+ f.write(' questionid: {}\n'.format(Info.QuestionId))
+ f.write(' devicepath: {}\n'.format(Info.DevicePath))
+
+ if type(Root.Data) == CIfrRef3:
+ f.write(' formid: {}\n'.format(Info.FormId))
+ f.write(' formsetid: {' + '{}, {}, {},'.format('0x%x'%(Info.FormSetId.Data1),'0x%x'%(Info.FormSetId.Data2), '0x%x'%(Info.FormSetId.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.FormSetId.Data4[0]), '0x%x'%(Info.FormSetId.Data4[1]), '0x%x'%(Info.FormSetId.Data4[2]), '0x%x'%(Info.FormSetId.Data4[3]), \
+ '0x%x'%(Info.FormSetId.Data4[4]), '0x%x'%(Info.FormSetId.Data4[5]), '0x%x'%(Info.FormSetId.Data4[6]), '0x%x'%(Info.FormSetId.Data4[7])) + ' }}\n')
+ f.write(' questionid: {}\n'.format(Info.QuestionId))
+
+ if type(Root.Data) == CIfrRef2:
+ f.write(' formid: {}\n'.format(Info.FormId))
+ f.write(' questionid: {}\n'.format(Info.QuestionId))
+
+ if type(Root.Data) == CIfrRef:
+ f.write(' formid: {}\n'.format(Info.FormId))
+ f.write(' questionid: {}\n'.format(Info.Question.QuestionId))
+
+ f.write(' prompt: {}\n'.format(Info.Question.Header.Prompt))
+ f.write(' help: {}\n'.format(Info.Question.Header.Help))
+
+ if Root.OpCode == EFI_IFR_REFRESH_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - refresh:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' interval: {} # RefreshInterval\n'.format(Info.RefreshInterval))
+
+ if Root.OpCode == EFI_IFR_VARSTORE_DEVICE_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - varstoredevice:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' devicepath: {} # DevicePath\n'.format(Info.DevicePath))
+
+ if Root.OpCode == EFI_IFR_REFRESH_ID_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - refreshguid:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' eventgroupid: {' + '{}, {}, {},'.format('0x%x'%(Info.RefreshEventGroupId.Data1),'0x%x'%(Info.RefreshEventGroupId.Data2), '0x%x'%(Info.RefreshEventGroupId.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.RefreshEventGroupId.Data4[0]), '0x%x'%(Info.RefreshEventGroupId.Data4[1]), '0x%x'%(Info.RefreshEventGroupId.Data4[2]), '0x%x'%(Info.RefreshEventGroupId.Data4[3]), \
+ '0x%x'%(Info.RefreshEventGroupId.Data4[4]), '0x%x'%(Info.RefreshEventGroupId.Data4[5]), '0x%x'%(Info.RefreshEventGroupId.Data4[6]), '0x%x'%(Info.RefreshEventGroupId.Data4[7])) + ' }}\n')
+
+ if Root.OpCode == EFI_IFR_WARNING_IF_OP:
+ Info = Root.Data.GetInfo()
+ f.write(' - warningif:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' warning: {}\n'.format(Info.Warning))
+ f.write(' timeOut: {}\n'.format(Info.TimeOut))
+
+ if Root.OpCode == EFI_IFR_GUID_OP:
+ Info = Root.Data.GetInfo()
+ if type(Root.Data) == CIfrLabel: # type(Info) == EFI_IFR_GUID_LABEL
+ f.write(' - label:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ f.write(' labelnumber: {} # LabelNumber\n'.format(Info.Number))
+
+ if type(Root.Data) == CIfrBanner:
+ f.write(' - banner:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ f.write(' title: {}\n'.format(Info.Title))
+ f.write(' linenumber: {}\n'.format(Info.LineNumber))
+ f.write(' align: {}\n'.format(Info.Alignment))
+
+ if type(Root.Data) == CIfrTimeout:
+ f.write(' - banner:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+
+ f.write(' timeout: {}\n'.format(Info.TimeOut))
+
+ if type(Root.Data) == CIfrClass:
+ f.write(' Class: {}\n'.format(Info.Class))
+
+ if type(Root.Data) == CIfrSubClass:
+ f.write(' SubClass: {}\n'.format(Info.SubClass))
+
+ if type(Root.Data) == CIfrGuid:
+ f.write(' - guidop:\n')
+ if Root.Condition != None:
+ f.write(' condition: {}\n'.format(Root.Condition))
+ f.write(' guid: {' + '{}, {}, {},'.format('0x%x'%(Info.Guid.Data1),'0x%x'%(Info.Guid.Data2), '0x%x'%(Info.Guid.Data3)) \
+ + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Guid.Data4[0]), '0x%x'%(Info.Guid.Data4[1]), '0x%x'%(Info.Guid.Data4[2]), '0x%x'%(Info.Guid.Data4[3]), \
+ '0x%x'%(Info.Guid.Data4[4]), '0x%x'%(Info.Guid.Data4[5]), '0x%x'%(Info.Guid.Data4[6]), '0x%x'%(Info.Guid.Data4[7])) + ' }}\n')
+
+
+ if Root.Child != []:
+ for ChildNode in Root.Child:
+ if Root.OpCode in ConditionOps:
+ if ChildNode.OpCode in ConditionOps:
+ ChildNode.Condition = Root.Condition + ' | ' + ChildNode.Condition
+ else:
+ ChildNode.Condition = Root.Condition
+
+ self.DumpYamlDfs(ChildNode, f)
+
+ return
+
+del VfrSyntaxParser
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/VfrTree.py b/edk2basetools/VfrCompiler/VfrTree.py
new file mode 100644
index 0000000..cdd5b84
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrTree.py
@@ -0,0 +1,88 @@
+from VfrCompiler.CommonCtypes import *
+from VfrCompiler.VfrFormPkg import *
+
+# Ifr related Info -> ctypes obj
+# conditional Info
+# Structure Info
+
+
+class VfrTreeNode():
+ def __init__(self, Opcode: int=None) -> None:
+
+ self.OpCode = Opcode
+ self.Data = None # save class or bytes
+ self.Condition = None
+ self.Expression = None
+ self.Parent = None
+ self.Child = []
+
+
+ def hasCondition(self) ->bool:
+ if self.Condition == None:
+ return False
+ else:
+ return True
+
+ # Get data from ctypes to bytes.
+ def struct2stream(self, s) -> bytes:
+ length = sizeof(s)
+ p = cast(pointer(s), POINTER(c_char * length))
+ return p.contents.raw
+
+ def hasChild(self) -> bool:
+ if self.Child == []:
+ return False
+ else:
+ return True
+
+ def isFinalChild(self) -> bool:
+ ParTree = self.Parent
+ if ParTree:
+ if ParTree.Child[-1] == self:
+ return True
+ return False
+
+
+ def insertChild(self, NewNode, pos: int=None) -> None:
+ if len(self.Child) == 0:
+ self.Child.append(NewNode)
+ else:
+ if not pos:
+ LastTree = self.Child[-1]
+ self.Child.append(NewNode)
+ else:
+ self.Child.insert(pos, NewNode)
+
+ NewNode.Parent = self
+
+
+ # lastNode.insertRel(newNode)
+ def insertRel(self, newNode) -> None:
+ if self.Parent:
+ parentTree = self.Parent
+ new_index = parentTree.Child.index(self) + 1
+ parentTree.Child.insert(new_index, newNode)
+ self.NextRel = newNode
+ newNode.LastRel = self
+
+
+ def deleteNode(self, deletekey: str) -> None:
+ FindStatus, DeleteTree = self.FindNode(deletekey)
+ if FindStatus:
+ parentTree = DeleteTree.Parent
+ lastTree = DeleteTree.LastRel
+ nextTree = DeleteTree.NextRel
+ if parentTree:
+ index = parentTree.Child.index(DeleteTree)
+ del parentTree.Child[index]
+ if lastTree and nextTree:
+ lastTree.NextRel = nextTree
+ nextTree.LastRel = lastTree
+ elif lastTree:
+ lastTree.NextRel = None
+ elif nextTree:
+ nextTree.LastRel = None
+ return DeleteTree
+ else:
+ print('Could not find the target tree')
+ return None
diff --git a/edk2basetools/VfrCompiler/VfrUtility.py b/edk2basetools/VfrCompiler/VfrUtility.py
new file mode 100644
index 0000000..68ccdf2
--- /dev/null
+++ b/edk2basetools/VfrCompiler/VfrUtility.py
@@ -0,0 +1,1991 @@
+from ast import Pass, Return
+from asyncio.windows_events import NULL
+from ctypes.wintypes import SIZEL
+from msilib.schema import Error
+from tkinter import N
+from turtle import goto
+from typing import List
+from unittest.mock import NonCallableMagicMock
+from xmlrpc.client import boolean
+from VfrCompiler.VfrError import *
+from VfrCompiler.CommonCtypes import *
+from abc import ABCMeta, abstractmethod
+import ctypes
+
+import sys
+
+VFR_PACK_SHOW = 0x02
+VFR_PACK_ASSIGN = 0x01
+VFR_PACK_PUSH = 0x04
+VFR_PACK_POP = 0x08
+DEFAULT_PACK_ALIGN = 0x8
+DEFAULT_ALIGN = 1
+MAX_NAME_LEN = 64
+MAX_BIT_WIDTH = 32
+EFI_VARSTORE_ID_MAX = 0xFFFF
+EFI_BITS_SHIFT_PER_UINT32 = 0x5
+EFI_BITS_PER_UINT32 = (1 << EFI_BITS_SHIFT_PER_UINT32)
+EFI_FREE_VARSTORE_ID_BITMAP_SIZE = int(
+ (EFI_VARSTORE_ID_MAX + 1) / EFI_BITS_PER_UINT32)
+
+
+class SVfrPackStackNode(object):
+
+ def __init__(self, Identifier, Number):
+ self.Identifier = Identifier
+ self.Number = Number
+ self.Next = None
+
+ def Match(self, Identifier):
+ if Identifier == None:
+ return True
+ elif self.Identifier == None:
+ return False
+ elif self.Identifier == Identifier:
+ return True
+ else:
+ return False
+
+
+class SVfrDataType(object):
+
+ def __init__(self, TypeName=''):
+ self.TypeName = TypeName
+ self.Type = 0
+ self.Align = 1
+ self.TotalSize = 0
+ self.HasBitField = False
+ self.Members = None
+ self.Next = None
+
+
+class SVfrDataField(object):
+
+ def __init__(self, FieldName=None):
+ self.FieldName = FieldName
+ self.FieldType = None
+ self.Offset = 0
+ self.ArrayNum = 0
+ self.IsBitField = False
+ self.BitWidth = 0
+ self.BitOffset = 0
+ self.Next = None
+
+class InternalTypes():
+ def __init__(self, TypeName, Type, Size, Align):
+ self.TypeName = TypeName
+ self.Type = Type
+ self.Size = Size
+ self.Align = Align
+
+gInternalTypesTable = [
+ InternalTypes("UINT64", EFI_IFR_TYPE_NUM_SIZE_64,
+ sizeof(ctypes.c_ulonglong), sizeof(ctypes.c_ulonglong)),
+ InternalTypes("UINT32", EFI_IFR_TYPE_NUM_SIZE_32, sizeof(ctypes.c_ulong),
+ sizeof(ctypes.c_ulong)),
+ InternalTypes("UINT16", EFI_IFR_TYPE_NUM_SIZE_16, sizeof(ctypes.c_ushort),
+ sizeof(ctypes.c_ushort)),
+ InternalTypes("UINT8", EFI_IFR_TYPE_NUM_SIZE_8, sizeof(ctypes.c_ubyte),
+ sizeof(ctypes.c_ubyte)),
+ InternalTypes("BOOLEAN", EFI_IFR_TYPE_BOOLEAN, sizeof(ctypes.c_ubyte),
+ sizeof(ctypes.c_ubyte)),
+ InternalTypes("EFI_GUID", EFI_IFR_TYPE_OTHER, sizeof(EFI_GUID),
+ sizeof(c_ubyte * 8)),
+ InternalTypes("EFI_HII_DATE", EFI_IFR_TYPE_DATE, sizeof(EFI_HII_DATE),
+ sizeof(ctypes.c_ushort)),
+ InternalTypes("EFI_STRING_ID", EFI_IFR_TYPE_STRING,
+ sizeof(ctypes.c_ushort), sizeof(ctypes.c_ushort)),
+ InternalTypes("EFI_HII_TIME", EFI_IFR_TYPE_TIME, sizeof(EFI_HII_TIME),
+ sizeof(ctypes.c_ubyte)),
+ InternalTypes("EFI_HII_REF", EFI_IFR_TYPE_REF, sizeof(EFI_HII_REF),
+ sizeof(EFI_GUID)),
+]
+
+class CVfrVarDataTypeDB(object):
+
+ def __init__(self):
+ self.__PackAlign = DEFAULT_PACK_ALIGN
+ self.__PackStack = None
+ self.__DataTypeList = None
+ self.__NewDataType = None
+ self.__CurrDataType = None
+ self.__CurrDataField = None
+ self.__FirstNewDataTypeName = None
+ self.InternalTypesListInit()
+
+
+ def InternalTypesListInit(self):
+ for i in range(0, len(gInternalTypesTable)):
+ pNewType = SVfrDataType()
+ pNewType.TypeName = gInternalTypesTable[i].TypeName
+ pNewType.Type = gInternalTypesTable[i].Type
+ pNewType.Align = gInternalTypesTable[i].Align
+ pNewType.TotalSize = gInternalTypesTable[i].Size
+
+ if gInternalTypesTable[i].TypeName == 'EFI_HII_DATE':
+ pYearField = SVfrDataField()
+ pMonthField = SVfrDataField()
+ pDayField = SVfrDataField()
+
+ pYearField.FieldName = 'Year'
+ pYearField.FieldType, _ = self.GetDataType('UINT16')
+ pYearField.Offset = 0
+ pYearField.Next = pMonthField
+ pYearField.ArrayNum = 0
+ pYearField.IsBitField = False
+
+ pMonthField.FieldName = 'Month'
+ pMonthField.FieldType, _ = self.GetDataType('UINT8')
+ pMonthField.Offset = 2
+ pMonthField.Next = pDayField
+ pMonthField.ArrayNum = 0
+ pMonthField.IsBitField = False
+
+ pDayField.FieldName = 'Day'
+ pDayField.FieldType, _ = self.GetDataType('UINT8')
+ pDayField.Offset = 3
+ pDayField.Next = None
+ pDayField.ArrayNum = 0
+ pDayField.IsBitField = False
+
+ pNewType.Members = pYearField
+
+ elif gInternalTypesTable[i].TypeName == 'EFI_HII_TIME':
+ pHoursField = SVfrDataField()
+ pMinutesField = SVfrDataField()
+ pSecondsField = SVfrDataField()
+
+ pHoursField.FieldName = 'Hours'
+ pHoursField.FieldType, _ = self.GetDataType('UINT8')
+ pHoursField.Offset = 0
+ pHoursField.Next = pMinutesField
+ pHoursField.ArrayNum = 0
+ pHoursField.IsBitField = False
+
+ pMinutesField.FieldName = 'Minutes'
+ pMinutesField.FieldType, _ = self.GetDataType('UINT8')
+ pMinutesField.Offset = 1
+ pMinutesField.Next = pSecondsField
+ pMinutesField.ArrayNum = 0
+ pMinutesField.IsBitField = False
+
+ pSecondsField.FieldName = 'Seconds'
+ pSecondsField.FieldType, _ = self.GetDataType('UINT8')
+ pSecondsField.Offset = 2
+ pSecondsField.Next = None
+ pSecondsField.ArrayNum = 0
+ pSecondsField.IsBitField = False
+
+ pNewType.Members = pHoursField
+
+ elif gInternalTypesTable[i].TypeName == 'EFI_HII_REF':
+ pQuestionIdField = SVfrDataField()
+ pFormIdField = SVfrDataField()
+ pFormSetGuidField = SVfrDataField()
+ pDevicePathField = SVfrDataField()
+
+ pQuestionIdField.FieldName = 'QuestionId'
+ pQuestionIdField.FieldType, _ = self.GetDataType('UINT16')
+ pQuestionIdField.Offset = 0
+ pQuestionIdField.Next = pFormIdField
+ pQuestionIdField.ArrayNum = 0
+ pQuestionIdField.IsBitField = False
+
+ pFormIdField.FieldName = 'FormId'
+ pFormIdField.FieldType, _ = self.GetDataType('UINT16')
+ pFormIdField.Offset = 2
+ pFormIdField.Next = pFormSetGuidField
+ pFormIdField.ArrayNum = 0
+ pFormIdField.IsBitField = False
+
+ pFormSetGuidField.FieldName = 'FormSetGuid'
+ pFormSetGuidField.FieldType, _ = self.GetDataType('EFI_GUID')
+ pFormSetGuidField.Offset = 4
+ pFormSetGuidField.Next = pDevicePathField
+ pFormSetGuidField.ArrayNum = 0
+ pFormSetGuidField.IsBitField = False
+
+ pDevicePathField.FieldName = 'DevicePath'
+ pDevicePathField.FieldType, _ = self.GetDataType('EFI_STRING_ID')
+ pDevicePathField.Offset = 20
+ pDevicePathField.Next = None
+ pDevicePathField.ArrayNum = 0
+ pDevicePathField.IsBitField = False
+
+ pNewType.Members = pQuestionIdField
+
+ pNewType.Next = None
+ self.__RegisterNewType(pNewType)
+ pNewType = None
+
+ def GetDataTypeList(self):
+ return self.__DataTypeList
+
+ def Pack(self,
+ LineNum,
+ Action,
+ Identifier=None,
+ Number=DEFAULT_PACK_ALIGN):
+
+ if Action & VFR_PACK_SHOW:
+ Msg = str.format('value of pragma pack(show) == %d' %
+ (self.__PackAlign))
+ gCVfrErrorHandle.PrintMsg(LineNum, 'Warning', Msg)
+
+ if Action & VFR_PACK_PUSH:
+ pNew = SVfrPackStackNode(Identifier, self.__PackAlign)
+ if pNew == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+ pNew.Next = self.__PackStack
+ self.__PackStack = pNew
+
+ if Action & VFR_PACK_POP:
+ pNode = None
+ if self.__PackStack == None:
+ gCVfrErrorHandle.PrintMsg(LineNum, 'Error', '#pragma pack(pop...) : more pops than pushes')
+
+ pNode = self.__PackStack
+ while pNode != None:
+ if pNode.Match(Identifier) == True:
+ self.__PackAlign = pNode.Number
+ self.__PackStack = pNode.Next
+ pNode = pNode.Next
+
+ if Action & VFR_PACK_ASSIGN:
+ PackAlign = (Number + Number % 2) if (Number > 1) else Number
+ if PackAlign == 0 or PackAlign > 16:
+ gCVfrErrorHandle.PrintMsg(LineNum, 'Error', "expected pragma parameter to be '1', '2', '4', '8', or '16'")
+ else:
+ self.__PackAlign = PackAlign
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def DeclareDataTypeBegin(self):
+ pNewType = SVfrDataType()
+
+ pNewType.TypeName = ''
+ pNewType.Type = EFI_IFR_TYPE_OTHER
+ pNewType.Align = DEFAULT_ALIGN
+ pNewType.TotalSize = 0
+ pNewType.HasBitField = False
+ pNewType.Members = None
+ pNewType.Next = None
+ self.__NewDataType = pNewType
+
+ def SetNewTypeType(self, Type):
+ if self.__NewDataType == None:
+ return VfrReturnCode.VFR_RETURN_ERROR_SKIPED
+
+ if Type == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ self.__NewDataType.Type = Type # need to limit the value of the type
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def SetNewTypeTotalSize(self, Size):
+ self.__NewDataType.TotalSize = Size
+
+ def SetNewTypeAlign(self, Align):
+ self.__NewDataType.Align = Align
+
+ def SetNewTypeName(self, TypeName):
+ if self.__NewDataType == None:
+ return VfrReturnCode.VFR_RETURN_ERROR_SKIPED
+
+ if TypeName == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ if len(TypeName) >= MAX_NAME_LEN:
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+
+ pType = self.__DataTypeList
+ while pType != None:
+ if pType.TypeName == TypeName:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+ pType = pType.Next
+
+ self.__NewDataType.TypeName = TypeName
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def __AlignStuff(self, Size, Align):
+ return Align - (Size) % (Align)
+
+ def DeclareDataTypeEnd(self):
+ if self.__NewDataType.TypeName == '':
+ return
+
+ if self.__NewDataType.TotalSize % self.__NewDataType.Align != 0:
+ self.__NewDataType.TotalSize += self.__AlignStuff(
+ self.__NewDataType.TotalSize, self.__NewDataType.Align)
+
+ self.__RegisterNewType(self.__NewDataType)
+ if self.__FirstNewDataTypeName == None:
+ self.__FirstNewDataTypeName = self.__NewDataType.TypeName
+
+ self.__NewDataType = None
+
+ # two definitions
+ def GetDataTypeSizeByTypeName(self, TypeName):
+ Size = 0
+ pDataType = self.__DataTypeList
+ while pDataType != None:
+ if pDataType.TypeName == TypeName:
+ Size = pDataType.TotalSize
+ return Size, VfrReturnCode.VFR_RETURN_SUCCESS
+ pDataType = pDataType.Next
+
+ return Size, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def GetDataTypeSizeByDataType(self, DataType):
+ Size = 0
+ DataType = DataType & 0x0F
+ # For user defined data type, the size can't be got by this function.
+ if DataType == EFI_IFR_TYPE_OTHER:
+ return Size, VfrReturnCode.VFR_RETURN_SUCCESS
+ pDataType = self.__DataTypeList
+ while pDataType != None:
+ if DataType == pDataType.Type:
+ Size = pDataType.TotalSize
+ return Size, VfrReturnCode.VFR_RETURN_SUCCESS
+ pDataType = pDataType.Next
+
+ return Size, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def __ExtractStructTypeName(self, VarStr):
+ try:
+ index = VarStr.index('.')
+ except ValueError:
+ return VarStr, len(VarStr)
+ else:
+ return VarStr[0:index], index + 1
+
+ def __ExtractFieldNameAndArrary(self, VarStr, s):
+
+ ArrayIdx = INVALID_ARRAY_INDEX
+ s_copy = s
+ while (s < len(VarStr) and VarStr[s] != '.' and VarStr[s] != '['
+ and VarStr[s] != ']'):
+ s += 1
+
+ FName = VarStr[s_copy:s]
+
+ if s == len(VarStr):
+ return ArrayIdx, s, FName, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ elif VarStr[s] == '.':
+ s += 1
+ return ArrayIdx, s, FName, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ elif VarStr[s] == '[':
+ s += 1
+ try:
+ e = s + VarStr[s:].index(']')
+
+ except ValueError:
+ return None, None, None, VfrReturnCode.VFR_RETURN_DATA_STRING_ERROR
+ else:
+ ArrayStr = VarStr[s:e]
+ ArrayIdx = int(ArrayStr)
+ if VarStr[e] == ']':
+ e += 1
+ if e < len(VarStr) and (VarStr[e] == '.'):
+ e += 1
+ return ArrayIdx, e, FName, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ elif VarStr[s] == ']':
+ return None, None, None, VfrReturnCode.VFR_RETURN_DATA_STRING_ERROR
+
+ return ArrayIdx, s, FName, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetTypeField(self, FName, Type):
+ if FName == None or Type == None:
+ return None, VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ pField = Type.Members
+ while (pField != None):
+
+ if Type.Type == EFI_IFR_TYPE_TIME:
+ if FName == 'Hour':
+ FName = 'Hours'
+ elif FName == 'Minute':
+ FName == 'Minutes'
+ elif FName == 'Second':
+ FName = 'Seconds'
+ if pField.FieldName == FName:
+ Field = pField
+ return Field, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ pField = pField.Next
+
+ return None, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def IsThisBitField(self, VarStrName):
+
+ TName, i = self.__ExtractStructTypeName(VarStrName)
+ pType, ReturnCode = self.GetDataType(TName)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return None, ReturnCode
+ pField = None
+ while (i < len(VarStrName)):
+ # i start from field
+ _, i, FName, ReturnCode = self.__ExtractFieldNameAndArrary(
+ VarStrName, i)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return None, ReturnCode
+ pField, ReturnCode = self.GetTypeField(FName, pType)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return None, ReturnCode
+ pType = pField.FieldType
+
+ if pField != None and pField.IsBitField:
+ return True, ReturnCode
+ else:
+ return False, ReturnCode
+
+ def GetFieldOffset(self, Field, ArrayIdx, IsBitField):
+
+ if Field == None:
+ return None, VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ if (ArrayIdx != INVALID_ARRAY_INDEX) and (Field.ArrayNum == 0 or
+ Field.ArrayNum <= ArrayIdx):
+ return None, VfrReturnCode.VFR_RETURN_ERROR_ARRARY_NUM
+
+ Idx = 0 if ArrayIdx == INVALID_ARRAY_INDEX else ArrayIdx
+ if IsBitField:
+ Offset = Field.BitOffset + Field.FieldType.TotalSize * Idx * 8
+ else:
+ Offset = Field.Offset + Field.FieldType.TotalSize * Idx
+
+ return Offset, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def __GetFieldWidth(self, Field):
+ if Field == None:
+ return 0
+ return Field.FieldType.Type
+
+ def __GetFieldSize(self, Field, ArrayIdx, BitField):
+ if Field == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ if (ArrayIdx == INVALID_ARRAY_INDEX) and (Field.ArrayNum != 0):
+ return Field.FieldType.TotalSize * Field.ArrayNum
+ else:
+
+ if BitField:
+ return Field.BitWidth
+ else:
+ return Field.FieldType.TotalSize
+
+ def GetDataFieldInfo(self, VarStr):
+
+ # VarStr -> Type.Field
+ Offset = 0
+ Type = EFI_IFR_TYPE_OTHER
+ Size = 0
+ BitField = False
+
+ TName, i = self.__ExtractStructTypeName(VarStr)
+
+ pType, ReturnCode = self.GetDataType(TName)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return Offset, Type, Size, BitField, ReturnCode
+
+ BitField, ReturnCode = self.IsThisBitField(VarStr)
+
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return Offset, Type, Size, BitField, ReturnCode
+
+ # if it is not struct data type
+ Type = pType.Type
+ Size = pType.TotalSize
+
+ while (i < len(VarStr)):
+ ArrayIdx, i, FName, ReturnCode = self.__ExtractFieldNameAndArrary(
+ VarStr, i)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return Offset, Type, Size, BitField, ReturnCode
+ pField, ReturnCode = self.GetTypeField(FName, pType)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return Offset, Type, Size, BitField, ReturnCode
+ pType = pField.FieldType
+ Tmp, ReturnCode = self.GetFieldOffset(pField, ArrayIdx,
+ pField.IsBitField)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return Offset, Type, Size, BitField, ReturnCode
+
+ if BitField and pField.IsBitField == False:
+ Offset = int(Offset + Tmp * 8)
+ else:
+ Offset = int(Offset + Tmp)
+
+ Type = self.__GetFieldWidth(pField)
+ Size = self.__GetFieldSize(pField, ArrayIdx, BitField)
+
+ return Offset, Type, Size, BitField, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def __RegisterNewType(self, New):
+ New.Next = self.__DataTypeList
+ self.__DataTypeList = New
+ return
+
+ def DataTypeAddField(self, FieldName, TypeName, ArrayNum, FieldInUnion):
+
+ pFieldType, ReturnCode = self.GetDataType(TypeName)
+
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ MaxDataTypeSize = self.__NewDataType.TotalSize
+
+
+ if len(FieldName) >= MAX_NAME_LEN:
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+
+ pTmp = self.__NewDataType.Members
+ while pTmp != None:
+ if pTmp.FieldName == FieldName:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+ pTmp = pTmp.Next
+
+ Align = min(self.__PackAlign, pFieldType.Align)
+ pNewField = SVfrDataField()
+ if pNewField == None:
+ return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+ pNewField.FieldName = FieldName
+ pNewField.FieldType = pFieldType
+ pNewField.ArrayNum = ArrayNum
+ pNewField.IsBitField = False
+
+ if self.__NewDataType.TotalSize % Align == 0:
+ pNewField.Offset = self.__NewDataType.TotalSize
+ else:
+ pNewField.Offset = self.__NewDataType.TotalSize + self.__AlignStuff(
+ self.__NewDataType.TotalSize, Align)
+
+ if self.__NewDataType.Members == None:
+ self.__NewDataType.Members = pNewField
+ pNewField.Next = None
+ else:
+ pTmp = self.__NewDataType.Members
+ while pTmp.Next != None:
+ pTmp = pTmp.Next
+ pTmp.Next = pNewField
+ pNewField.Next = None
+
+ self.__NewDataType.Align = min(
+ self.__PackAlign, max(pFieldType.Align, self.__NewDataType.Align))
+
+ if FieldInUnion:
+ if MaxDataTypeSize < pNewField.FieldType.TotalSize:
+ self.__NewDataType.TotalSize = pNewField.FieldType.TotalSize
+ pNewField.Offset = 0
+ else:
+ Num = ArrayNum if ArrayNum != 0 else 1
+ self.__NewDataType.TotalSize = pNewField.Offset + (
+ pNewField.FieldType.TotalSize) * Num
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def DataTypeAddBitField(self, FieldName, TypeName, Width, FieldInUnion):
+
+ pFieldType, ReturnCode = self.GetDataType(TypeName)
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ if Width > MAX_BIT_WIDTH:
+ return VfrReturnCode.VFR_RETURN_BIT_WIDTH_ERROR
+
+ if Width > (pFieldType.TotalSize) * 8:
+ return VfrReturnCode.VFR_RETURN_BIT_WIDTH_ERROR
+
+ if (FieldName != None) and (len(FieldName) >= MAX_NAME_LEN):
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+
+ if Width == 0 and FieldName != None:
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+
+ pTmp = self.__NewDataType.Members
+ while pTmp != None:
+ if FieldName != None and pTmp.FieldName == FieldName:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+ pTmp = pTmp.Next
+
+ Align = min(self.__PackAlign, pFieldType.Align)
+ UpdateTotalSize = False
+
+ pNewField = SVfrDataField()
+ if pNewField == None:
+ return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ MaxDataTypeSize = self.__NewDataType.TotalSize
+
+ pNewField.FieldName = FieldName
+ pNewField.FieldType = pFieldType
+ pNewField.IsBitField = True
+ pNewField.BitWidth = Width
+ pNewField.ArrayNum = 0
+ pNewField.BitOffset = 0
+ pNewField.Offset = 0
+
+ if self.__NewDataType.Members == None:
+ self.__NewDataType.Members = pNewField
+ pNewField.Next = None
+ else:
+ pTmp = self.__NewDataType.Members
+ while pTmp.Next != None:
+ pTmp = pTmp.Next
+ pTmp.Next = pNewField
+ pNewField.Next = None
+
+ if FieldInUnion:
+ pNewField.Offset = 0
+ if MaxDataTypeSize < pNewField.FieldType.TotalSize:
+ self.__NewDataType.TotalSize = pNewField.FieldType.TotalSize
+ else:
+ # Check whether the bit fields can be contained within one FieldType.
+ cond1 = (pTmp != None) and (pTmp.IsBitField) and (
+ pTmp.FieldType.TypeName == pNewField.FieldType.TypeName)
+ cond2 = (pTmp != None) and (pTmp.BitOffset - pTmp.Offset * 8 +
+ pTmp.BitWidth + pNewField.BitWidth <=
+ pNewField.FieldType.TotalSize * 8)
+ if cond1 and cond2:
+ pNewField.BitOffset = pTmp.BitOffset + pTmp.BitWidth
+ pNewField.Offset = pTmp.Offset
+
+ if pNewField.BitWidth == 0:
+ pNewField.BitWidth = pNewField.FieldType.TotalSize * 8 - (
+ pNewField.BitOffset - pTmp.Offset * 8)
+ else:
+ pNewField.BitOffset = self.__NewDataType.TotalSize * 8
+ UpdateTotalSize = True
+
+ if UpdateTotalSize:
+ if self.__NewDataType.TotalSize % Align == 0:
+ pNewField.Offset = self.__NewDataType.TotalSize
+ else:
+ pNewField.Offset = self.__NewDataType.TotalSize + self.__AlignStuff(
+ self.__NewDataType.TotalSize, Align)
+ self.__NewDataType.TotalSize = pNewField.Offset + pNewField.FieldType.TotalSize
+
+ self.__NewDataType.Align = min(
+ self.__PackAlign, max(pFieldType.Align, self.__NewDataType.Align))
+ self.__NewDataType.HasBitField = True
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetDataType(self, TypeName):
+ if TypeName == None:
+ return None, VfrReturnCode.VFR_RETURN_ERROR_SKIPED
+
+ DataType = self.__DataTypeList
+ while DataType != None:
+ if DataType.TypeName == TypeName:
+ return DataType, VfrReturnCode.VFR_RETURN_SUCCESS
+ DataType = DataType.Next
+ return None, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def DataTypeHasBitField(self, TypeName):
+ if TypeName == None:
+ return False
+
+ pType = self.__DataTypeList
+ while pType != None:
+ if pType.TypeName == TypeName:
+ break
+ pType = pType.Next
+
+ if pType == None:
+ return False
+
+ pTmp = pType.Members
+ while pTmp != None:
+ if pTmp.IsBitField:
+ return True
+ pTmp = pTmp.Next
+ return False
+
+ def Dump(self, FileName):
+ try:
+ with open(FileName, 'w') as f:
+ f.write("PackAlign = " + str(self.__PackAlign) + '\n')
+ pNode = self.__DataTypeList
+ while pNode != None:
+ f.write('struct {} : Align : {} TotalSize : '.format(str(pNode.TypeName), str(pNode.Align)))
+ f.write('%#x\n'%(pNode.TotalSize))
+ # f.write(" struct " + str(pNode.TypeName) + " : " + " Align " + str(pNode.Align)) + " TotalSize " + str('%#x'%pNode.TotalSize))
+ f.write('struct {} \n'.format(str(pNode.TypeName)))
+ FNode = pNode.Members
+ while(FNode != None):
+ if FNode.ArrayNum > 0:
+ f.write('FieldName : {} , Offset : {}, ArrayNum : {} , FieldTypeName : {} , IsBitField : {} \n '.format(str(FNode.FieldName), str(FNode.Offset), str(FNode.ArrayNum), str(FNode.FieldType.TypeName), str(FNode.IsBitField)))
+ else:
+ f.write('FieldName : {} , Offset : {}, FieldTypeName : {} , IsBitField : {} \n '.format(str(FNode.FieldName), str(FNode.Offset), str(FNode.FieldType.TypeName), str(FNode.IsBitField)))
+ FNode = FNode.Next
+ f.write('\n')
+ pNode = pNode.Next
+ f.close()
+ except IOError as e:
+ print("error")
+ pass
+
+class SVfrDefaultStoreNode(object):
+
+ def __init__(self,
+ ObjAddr=None,
+ RefName='',
+ DefaultStoreNameId=0,
+ DefaultId=0):
+ self.ObjAddr = ObjAddr
+ self.RefName = RefName
+ self.DefaultStoreNameId = DefaultStoreNameId
+ self.DefaultId = DefaultId
+ self.Next = None
+
+
+class CVfrDefaultStore(object):
+
+ def __init__(self):
+ self.__DefaultStoreList = None
+
+ def RegisterDefaultStore(self, ObjAddr: EFI_IFR_DEFAULTSTORE, RefName, DefaultStoreNameId, DefaultId):
+ if RefName == '' or RefName == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ pNode = self.__DefaultStoreList
+ while pNode != None:
+ if pNode.RefName == RefName:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+ pNode = pNode.Next
+
+ pNode = SVfrDefaultStoreNode(ObjAddr, RefName, DefaultStoreNameId, DefaultId)
+
+ if pNode == None:
+ return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode.Next = self.__DefaultStoreList
+ self.__DefaultStoreList = pNode
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def DefaultIdRegistered(self, DefaultId):
+ pNode = self.__DefaultStoreList
+ while pNode != None:
+ if pNode.DefaultId == DefaultId:
+ return True
+ pNode = pNode.Next
+
+ return False
+
+ def ReRegisterDefaultStoreById(self, DefaultId, RefName, DefaultStoreNameId):
+
+ pNode = self.__DefaultStoreList
+ while pNode != None:
+ if pNode.DefaultId == DefaultId:
+ break
+ pNode = pNode.Next
+
+ if pNode == None:
+ return None, VfrReturnCode.VFR_RETURN_UNDEFINED
+ else:
+ if pNode.DefaultStoreNameId == EFI_STRING_ID_INVALID:
+ pNode.DefaultStoreNameId == DefaultStoreNameId
+ pNode.RefName = RefName
+ if pNode.ObjAddr != None:
+ pNode.ObjAddr.DefaultName = DefaultStoreNameId
+ else:
+ return None, VfrReturnCode.VFR_RETURN_REDEFINED
+
+ return pNode, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetDefaultId(self, RefName):
+ pTmp = self.__DefaultStoreList
+ while(pTmp != None):
+ if pTmp.RefName == RefName:
+ DefaultId = pTmp.DefaultId
+ return DefaultId, VfrReturnCode.VFR_RETURN_SUCCESS
+ pTmp = pTmp.Next
+ return None, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def BufferVarStoreAltConfigAdd(self, DefaultId, BaseInfo, VarStoreName,
+ VarStoreGuid, Type, Value):
+ if VarStoreName == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+ pNode = self.__DefaultStoreList
+ while pNode != None:
+ if pNode.DefaultId == DefaultId:
+ break
+ pNode = pNode.Next
+ if pNode == None:
+ return VfrReturnCode.VFR_RETURN_UNDEFINED
+ # pNode.DefaultId sprintf (NewAltCfg, "%04x", pNode->mDefaultId)
+ gCVfrBufferConfig.Open()
+ if gCVfrBufferConfig.Select(VarStoreName, VarStoreGuid) == 0:
+ Returnvalue = gCVfrBufferConfig.Write('a', VarStoreName,
+ VarStoreGuid,
+ pNode.DefaultId, Type,
+ BaseInfo.Info.VarOffset,
+ BaseInfo.VarTotalSize, Value)
+ if Returnvalue != 0:
+ gCVfrBufferConfig.Close()
+ return VfrReturnCode(Returnvalue)
+ gCVfrBufferConfig.Close()
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+
+
+class EFI_VFR_VARSTORE_TYPE(Enum):
+ EFI_VFR_VARSTORE_INVALID = 0
+ EFI_VFR_VARSTORE_BUFFER = 1
+ EFI_VFR_VARSTORE_EFI = 2
+ EFI_VFR_VARSTORE_NAME = 3
+ EFI_VFR_VARSTORE_BUFFER_BITS = 4
+
+
+class EfiVar():
+
+ def __init__(self, VarName=0, VarSize=0):
+ self.EfiVarName = VarName
+ self.EfiVarSize = VarSize
+
+
+DEFAULT_NAME_TABLE_ITEMS = 1024
+
+
+class SVfrVarStorageNode():
+
+ def __init__(self,
+ VarStoreName='',
+ VarStoreId=0,
+ Guid=None,
+ Attributes=0,
+ Flag=True,
+ EfiValue=None,
+ DataType=None,
+ BitsVarstore=False):
+
+ self.Guid = Guid
+ self.VarStoreName = VarStoreName
+ self.VarStoreId = VarStoreId
+ self.AssignedFlag = Flag
+ self.Attributes = Attributes
+ self.Next = None
+ self.EfiVar = EfiValue
+ self.DataType = DataType
+ self.NameSpace = []
+
+ if EfiValue != None:
+ self.VarstoreType = EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI
+ elif DataType != None:
+ if BitsVarstore:
+ self.VarstoreType = EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS
+ else:
+ self.VarstoreType = EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER
+ else:
+ self.VarstoreType = EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_NAME
+
+class SConfigItem():
+
+ def __init__(self,
+ Name=None,
+ Guid=None,
+ Id=None,
+ Type=None,
+ Offset=None,
+ Width=None,
+ Value=None):
+ self.Name = Name # varstore name
+ self.Guid = Guid # varstore guid, varstore name + guid deside one varstore
+ self.Id = Id # default ID
+ if Type != None:
+ # list of Offset/Value in the varstore
+ self.InfoStrList = SConfigInfo(Type, Offset, Width, Value)
+ else:
+ self.InfoStrList = None
+ self.Next = None
+
+
+class SConfigInfo():
+
+ def __init__(self, Type, Offset, Width, Value: EFI_IFR_TYPE_VALUE):
+ self.Type = Type
+ self.Offset = Offset
+ self.Width = Width
+ self.Next = None
+ self.Value = Value
+
+class CVfrBufferConfig(object):
+ __metaclass__ = ABCMeta
+
+ def __init__(self):
+ self.__ItemListHead = None # SConfigItem
+ self.__ItemListTail = None
+ self.__ItemListPos = None
+
+ def GetVarItemList(self):
+ return self.__ItemListHead
+
+ @abstractmethod
+ def Open(self):
+ self.__ItemListPos = self.__ItemListHead
+
+ @abstractmethod
+ def Close(self):
+ self.__ItemListPos = None
+
+ @abstractmethod
+ def Select(self, Name, Guid, Id=None):
+ if Name == None or Guid == None:
+ self.__ItemListPos = self.__ItemListHead
+ return 0
+ else:
+ p = self.__ItemListHead
+ while p != None:
+ if p.Name != Name or p.Guid.__cmp__(Guid) == False:
+ p = p.Next
+ continue
+ if Id != None:
+ if p.Id == None or p.Id != Id:
+ p = p.Next
+ continue
+ elif p.Id != None:
+ p = p.Next
+ continue
+ self.__ItemListPos = p
+ return 0
+ return 1
+
+ @abstractmethod
+ def Register(self, Name, Guid, Id=None):
+ if self.Select(Name, Guid) == 0:
+ return 1
+ pNew = SConfigItem(Name, Guid, Id)
+ if pNew == None:
+ return 2
+ if self.__ItemListHead == None:
+ self.__ItemListHead = pNew
+ self.__ItemListTail = pNew
+ else:
+ self.__ItemListTail.Next = pNew
+ self.__ItemListTail = pNew
+ self.__ItemListPos = pNew
+ return 0
+
+ @abstractmethod
+ def Write(self, Mode, Name, Guid, Id, Type, Offset, Width,
+ Value: EFI_IFR_TYPE_VALUE):
+ Ret = self.Select(Name, Guid)
+ if Ret != 0:
+ return Ret
+
+ if Mode == 'a': # add
+ if self.Select(Name, Guid, Id) != 0:
+ pItem = SConfigItem(Name, Guid, Id, Type, Offset, Width, Value)
+ if pItem == None:
+ return 2
+
+ if self.__ItemListHead == None:
+ self.__ItemListHead = pItem
+ self.__ItemListTail = pItem
+ else:
+ self.__ItemListTail.Next = pItem
+ self.__ItemListTail = pItem
+
+ self.__ItemListPos = pItem
+
+ else:
+ # tranverse the list to find out if there's already the value for the same offset
+ pInfo = self.__ItemListPos.InfoStrList
+ while pInfo != None:
+ if pInfo.Offset == Offset:
+ return 0
+ pInfo = pInfo.Next
+
+ pInfo = SConfigInfo(Type, Offset, Width, Value)
+ if pInfo == None:
+ return 2
+
+ pInfo.Next = self.__ItemListPos.InfoStrList
+ self.__ItemListPos.InfoStrList = pInfo
+
+ elif Mode == 'd': # delete
+ if self.__ItemListHead == self.__ItemListPos:
+ self.__ItemListHead = self.__ItemListPos.Next
+
+ pItem = self.__ItemListHead
+ while pItem.Next != self.__ItemListPos:
+ pItem = pItem.Next
+ pItem.Next = self.__ItemListPos.Next
+
+ if self.__ItemListTail == self.__ItemListPos:
+ self.__ItemListTail = pItem
+
+ self.__ItemListPos = pItem.Next
+
+ elif Mode == 'i': # set info
+ if Id != None:
+ self.__ItemListPos.Id = Id
+ else:
+ return 1
+ return 0
+
+gCVfrBufferConfig = CVfrBufferConfig()
+
+class EFI_VARSTORE_INFO(Structure):
+ _pack_ = 1
+ _fields_ = [
+ ('VarStoreId', c_uint16),
+ ('Info', VarStoreInfoNode),
+ ('VarType', c_uint8),
+ ('VarTotalSize', c_uint32),
+ ('IsBitVar', c_bool),
+ ]
+
+ def __init__(self,
+ VarStoreId=EFI_VARSTORE_ID_INVALID,
+ VarName=EFI_STRING_ID_INVALID,
+ VarOffset=EFI_VAROFFSET_INVALID,
+ VarType=EFI_IFR_TYPE_OTHER,
+ VarTotalSize=0,
+ IsBitVar=False):
+
+ self.VarStoreId = VarStoreId
+ self.Info.VarName = VarName
+ self.Info.VarOffset = VarOffset
+ self.VarTotalSize = VarTotalSize
+ self.IsBitVar = IsBitVar
+ self.VarType = VarType
+
+
+class BufferVarStoreFieldInfoNode():
+
+ def __init__(self, BaseInfo: EFI_VARSTORE_INFO):
+
+ self.VarStoreInfo = EFI_VARSTORE_INFO()
+ self.VarStoreInfo.VarType = BaseInfo.VarType
+ self.VarStoreInfo.VarTotalSize = BaseInfo.VarTotalSize
+ self.VarStoreInfo.Info.VarOffset = BaseInfo.Info.VarOffset
+ self.VarStoreInfo.VarStoreId = BaseInfo.VarStoreId
+ self.Next = None
+
+
+class CVfrDataStorage(object):
+
+ def __init__(self):
+ self.__BufferVarStoreList = None # SVfrVarStorageNode
+ self.__EfiVarStoreList = None
+ self.__NameVarStoreList = None
+ self.__CurrVarStorageNode = None
+ self.__NewVarStorageNode = None
+ self.__BufferFieldInfoListHead = None
+ self.__mBufferFieldInfoListTail = None
+ self.__FreeVarStoreIdBitMap = []
+ for i in range(0, EFI_FREE_VARSTORE_ID_BITMAP_SIZE):
+ self.__FreeVarStoreIdBitMap.append(0)
+ #Question ID0 is reserved
+ self.__FreeVarStoreIdBitMap[0] = 0x80000000
+
+ def GetBufferVarStoreList(self):
+ return self.__BufferVarStoreList
+
+ def __CheckGuidField(self, pNode, StoreGuid, HasFoundOne, ReturnCode):
+ if StoreGuid != None:
+ # If has guid info, compare the guid filed.
+ if pNode.Guid.__cmp__(StoreGuid):
+ self.__CurrVarStorageNode = pNode
+ ReturnCode = VfrReturnCode.VFR_RETURN_SUCCESS
+ return True, ReturnCode, HasFoundOne
+ else:
+ # not has Guid field, check whether this name is the only one.
+ if HasFoundOne:
+ # The name has conflict, return name redefined.
+ ReturnCode = VfrReturnCode.VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR
+ return True, ReturnCode, HasFoundOne
+
+ self.__CurrVarStorageNode = pNode
+ HasFoundOne = True
+ return False, ReturnCode, HasFoundOne
+
+ def __GetVarStoreByDataType(self, DataTypeName, VarGuid):
+ MatchNode = None
+ pNode = self.__BufferVarStoreList
+ while pNode != None:
+ if pNode.DataType.TypeName != DataTypeName:
+ pNode = pNode.Next
+ continue
+ if VarGuid != None:
+ if pNode.Guid.__cmp__(VarGuid):
+ return pNode, VfrReturnCode.VFR_RETURN_SUCCESS
+ else:
+ if MatchNode == None:
+ MatchNode = pNode
+ else:
+ # More than one varstores referred the same data structures
+ return None, VfrReturnCode.VFR_RETURN_VARSTORE_DATATYPE_REDEFINED_ERROR
+ pNode = pNode.Next
+
+ if MatchNode == None:
+ return MatchNode, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ return MatchNode, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ """
+ Base on the input store name and guid to find the varstore id.
+ If both name and guid are inputed, base on the name and guid to
+ found the varstore. If only name inputed, base on the name to
+ found the varstore and go on to check whether more than one varstore
+ has the same name. If only has found one varstore, return this
+ varstore; if more than one varstore has same name, return varstore
+ name redefined error. If no varstore found by varstore name, call
+ function GetVarStoreByDataType and use inputed varstore name as
+ data type name to search.
+ """
+
+ def GetVarStoreId(self, StoreName, StoreGuid=None):
+
+ ReturnCode = None
+ HasFoundOne = False
+ self.__CurrVarStorageNode = None
+
+ pNode = self.__BufferVarStoreList
+ while pNode != None:
+ if pNode.VarStoreName == StoreName:
+ Result, ReturnCode, HasFoundOne = self.__CheckGuidField(
+ pNode, StoreGuid, HasFoundOne, ReturnCode)
+ if Result:
+ VarStoreId = self.__CurrVarStorageNode.VarStoreId
+ return VarStoreId, ReturnCode
+ pNode = pNode.Next
+
+ pNode = self.__EfiVarStoreList
+ while pNode != None:
+ if pNode.VarStoreName == StoreName:
+ Result, ReturnCode, HasFoundOne = self.__CheckGuidField(
+ pNode, StoreGuid, HasFoundOne, ReturnCode)
+ if Result:
+ VarStoreId = self.__CurrVarStorageNode.VarStoreId
+ return VarStoreId, ReturnCode
+ pNode = pNode.Next
+
+ pNode = self.__NameVarStoreList
+ while pNode != None:
+ if pNode.VarStoreName == StoreName:
+ Result, ReturnCode, HasFoundOne = self.__CheckGuidField(
+ pNode, StoreGuid, HasFoundOne, ReturnCode)
+ if Result:
+ VarStoreId = self.__CurrVarStorageNode.VarStoreId
+ return VarStoreId, ReturnCode
+ pNode = pNode.Next
+
+ if HasFoundOne:
+ VarStoreId = self.__CurrVarStorageNode.VarStoreId
+ return VarStoreId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ VarStoreId = EFI_VARSTORE_ID_INVALID
+ pNode, ReturnCode = self.__GetVarStoreByDataType(StoreName,
+ StoreGuid) #
+ if pNode != None:
+ self.__CurrVarStorageNode = pNode
+ VarStoreId = pNode.VarStoreId
+
+ return VarStoreId, ReturnCode
+
+ def __GetFreeVarStoreId(self, VarType):
+
+ Index = 0
+ for i in range(0, EFI_FREE_VARSTORE_ID_BITMAP_SIZE):
+ if self.__FreeVarStoreIdBitMap[i] != 0xFFFFFFFF:
+ Index = i
+ break
+ if Index == EFI_FREE_VARSTORE_ID_BITMAP_SIZE:
+ return EFI_VARSTORE_ID_INVALID
+
+ Offset = 0
+ Mask = 0x80000000
+ while Mask != 0:
+ if (self.__FreeVarStoreIdBitMap[Index] & Mask) == 0:
+ self.__FreeVarStoreIdBitMap[Index] |= Mask
+ return (Index << EFI_BITS_SHIFT_PER_UINT32) + Offset
+ Mask >>= 1
+ Offset += 1
+ return EFI_VARSTORE_ID_INVALID
+
+ def __CheckVarStoreIdFree(self, VarStoreId):
+
+ Index = int(VarStoreId / EFI_BITS_PER_UINT32)
+ Offset = VarStoreId % EFI_BITS_PER_UINT32
+ return (self.__FreeVarStoreIdBitMap[Index] &
+ (0x80000000 >> Offset)) == 0
+
+ def __MarkVarStoreIdUsed(self, VarStoreId):
+
+ Index = int(VarStoreId / EFI_BITS_PER_UINT32)
+ Offset = VarStoreId % EFI_BITS_PER_UINT32
+ self.__FreeVarStoreIdBitMap[Index] |= (0x80000000 >> Offset)
+
+ def DeclareBufferVarStore(self,
+ StoreName,
+ Guid,
+ DataTypeDB,
+ TypeName,
+ VarStoreId,
+ IsBitVarStore,
+ Attr=0,
+ Flag=True):
+
+ if StoreName == None or Guid == None or DataTypeDB == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+ _, ReturnCode = self.GetVarStoreId(StoreName, Guid)
+
+ if ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+
+ DataType, ReturnCode = DataTypeDB.GetDataType(TypeName)
+
+ if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
+ return ReturnCode
+
+ if VarStoreId == EFI_VARSTORE_ID_INVALID:
+ VarStoreId = self.__GetFreeVarStoreId(
+ EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER)
+ else:
+ if self.__CheckVarStoreIdFree(VarStoreId) == False:
+ return VfrReturnCode.VFR_RETURN_VARSTOREID_REDEFINED
+ self.__MarkVarStoreIdUsed(VarStoreId)
+ pNew = SVfrVarStorageNode(StoreName, VarStoreId, Guid, Attr, Flag, None,
+ DataType, IsBitVarStore)
+
+ if pNew == None:
+ return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNew.Next = self.__BufferVarStoreList
+ self.__BufferVarStoreList = pNew
+
+ if gCVfrBufferConfig.Register(StoreName, Guid) != 0:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def DeclareNameVarStoreBegin(self, StoreName, VarStoreId):
+ if StoreName == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ _, ReturnCode = self.GetVarStoreId(StoreName)
+ if ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+
+ if VarStoreId == EFI_VARSTORE_ID_INVALID:
+ VarStoreId = self.__GetFreeVarStoreId(
+ EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_NAME)
+ else:
+ if self.__CheckVarStoreIdFree(VarStoreId) == False:
+ return VfrReturnCode.VFR_RETURN_VARSTOREID_REDEFINED
+ self.__MarkVarStoreIdUsed(VarStoreId)
+
+ pNode = SVfrVarStorageNode(StoreName, VarStoreId)
+
+ if pNode == None:
+ return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ self.__NewVarStorageNode = pNode
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def DeclareNameVarStoreEnd(self, Guid):
+ self.__NewVarStorageNode.Guid = Guid
+ self.__NewVarStorageNode.Next = self.__NameVarStoreList
+ self.__NameVarStoreList = self.__NewVarStorageNode
+ self.__NewVarStorageNode = None
+
+ def NameTableAddItem(self, Item):
+ self.__NewVarStorageNode.NameSpace.append(Item)
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetNameVarStoreInfo(self, BaseInfo, Index):
+ if BaseInfo == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ if self.__CurrVarStorageNode == None:
+ return VfrReturnCode.VFR_RETURN_GET_NVVARSTORE_ERROR
+
+ BaseInfo.Info.VarName = self.__CurrVarStorageNode.NameSpace[Index]
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetVarStoreType(self, VarStoreId):
+
+ VarStoreType = EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_INVALID
+
+ if VarStoreId == EFI_VARSTORE_ID_INVALID:
+ return VarStoreType
+
+ pNode = self.__BufferVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ VarStoreType = pNode.VarstoreType
+ return VarStoreType
+ pNode = pNode.Next
+
+ pNode = self.__EfiVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ VarStoreType = pNode.VarstoreType
+ return VarStoreType
+ pNode = pNode.Next
+
+ pNode = self.__NameVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ VarStoreType = pNode.VarstoreType
+ return VarStoreType
+ pNode = pNode.Next
+
+ return VarStoreType
+
+ def GetVarStoreName(self, VarStoreId):
+
+ pNode = self.__BufferVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ return pNode.VarStoreName, VfrReturnCode.VFR_RETURN_SUCCESS
+ pNode = pNode.Next
+
+ pNode = self.__EfiVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ return pNode.VarStoreName, VfrReturnCode.VFR_RETURN_SUCCESS
+ pNode = pNode.Next
+
+ pNode = self.__NameVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ return pNode.VarStoreName, VfrReturnCode.VFR_RETURN_SUCCESS
+ pNode = pNode.Next
+
+ return None, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+
+ def GetBufferVarStoreDataTypeName(self, VarStoreId):
+
+ DataTypeName = None
+ if VarStoreId == EFI_VARSTORE_ID_INVALID:
+ return DataTypeName, VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ pNode = self.__BufferVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ DataTypeName = pNode.DataType.TypeName
+ return DataTypeName, VfrReturnCode.VFR_RETURN_SUCCESS
+ pNode = pNode.Next
+
+ return DataTypeName, VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def GetEfiVarStoreInfo(self, BaseInfo: EFI_VARSTORE_INFO):
+
+ if BaseInfo == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ if self.__CurrVarStorageNode == None:
+ return VfrReturnCode.VFR_RETURN_GET_EFIVARSTORE_ERROR
+
+ BaseInfo.Info.VarName = self.__CurrVarStorageNode.EfiVar.EfiVarName
+ BaseInfo.VarTotalSize = self.__CurrVarStorageNode.EfiVar.EfiVarSize
+
+ if BaseInfo.VarTotalSize == 1:
+ BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_8
+ elif BaseInfo.VarTotalSize == 2:
+ BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_16
+ elif BaseInfo.VarTotalSize == 4:
+ BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_32
+ elif BaseInfo.VarTotalSize == 8:
+ BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_64
+ else:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetVarStoreGuid(self, VarStoreId):
+
+ VarGuid = None
+ if VarStoreId == EFI_VARSTORE_ID_INVALID:
+ return VarGuid
+
+ pNode = self.__BufferVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ VarGuid = pNode.Guid
+ return VarGuid
+ pNode = pNode.Next
+
+ pNode = self.__EfiVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ VarGuid = pNode.Guid
+ return VarGuid
+ pNode = pNode.Next
+
+ pNode = self.__NameVarStoreList
+ while pNode != None:
+ if pNode.VarStoreId == VarStoreId:
+ VarGuid = pNode.Guid
+ return VarGuid
+ pNode = pNode.Next
+
+ return VarGuid
+
+ def AddBufferVarStoreFieldInfo(self, BaseInfo: EFI_VARSTORE_INFO):
+
+ pNew = BufferVarStoreFieldInfoNode(BaseInfo)
+ if pNew == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ if self.__BufferFieldInfoListHead == None:
+ self.__BufferFieldInfoListHead = pNew
+ self.__mBufferFieldInfoListTail = pNew
+ else:
+ self.__mBufferFieldInfoListTail.Next = pNew
+ self.__mBufferFieldInfoListTail = pNew
+
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+
+class CVfrStringDB(object):
+
+ def __init__(self):
+ self.__StringFileName = ''
+
+ def GetVarStoreNameFromStringId(self, StringId):
+ if self.__StringFileName == '':
+ return None
+ try:
+ f = open(self.__StringFileName)
+ StringPtr = f.read()
+ f.close()
+ except IOError:
+ print('Error')
+
+gCVfrStringDB = CVfrStringDB()
+
+EFI_RULE_ID_START = 0x01
+EFI_RULE_ID_INVALID = 0x00
+
+
+class SVfrRuleNode():
+
+ def __init__(self, RuleName=None, RuleId=0):
+ self.RuleId = RuleId
+ self.RuleName = RuleName
+ self.Next = None
+
+
+class CVfrRulesDB(object):
+
+ def __init__(self):
+ self.__RuleList = None
+ self.__FreeRuleId = EFI_VARSTORE_ID_START
+
+ def RegisterRule(self, RuleName):
+ if RuleName == None:
+ return
+
+ pNew = SVfrRuleNode(RuleName, self.__FreeRuleId)
+ if pNew == None: return
+ self.__FreeRuleId += 1
+ pNew.Next = self.__RuleList
+ self.__RuleList = pNew
+
+ def GetRuleId(self, RuleName):
+ if RuleName == None:
+ return
+
+ pNode = self.__RuleList
+ while pNode != None:
+ if pNode.RuleName == RuleName:
+ return pNode.RuleId
+ pNode = pNode.Next
+
+ return EFI_RULE_ID_INVALID
+
+
+EFI_QUESTION_ID_MAX = 0xFFFF
+EFI_FREE_QUESTION_ID_BITMAP_SIZE = int(
+ (EFI_QUESTION_ID_MAX + 1) / EFI_BITS_PER_UINT32)
+EFI_QUESTION_ID_INVALID = 0x0
+
+
+class EFI_QUESION_TYPE(Enum):
+ QUESTION_NORMAL = 0
+ QUESTION_DATE = 1
+ QUESTION_TIME = 2
+ QUESTION_REF = 3
+
+
+class SVfrQuestionNode():
+
+ def __init__(self, Name=None, VarIdStr=None, BitMask=0): #
+ self.Name = Name
+ self.VarIdStr = VarIdStr
+ self.QuestionId = EFI_QUESTION_ID_INVALID
+ self.BitMask = BitMask
+ self.Next = None
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+
+
+DATE_YEAR_BITMASK = 0x0000FFFF
+DATE_MONTH_BITMASK = 0x00FF0000
+DATE_DAY_BITMASK = 0xFF000000
+TIME_HOUR_BITMASK = 0x000000FF
+TIME_MINUTE_BITMASK = 0x0000FF00
+TIME_SECOND_BITMASK = 0x00FF0000
+
+
+class CVfrQuestionDB(object):
+
+ def __init__(self):
+ self.__FreeQIdBitMap = []
+ for i in range(0, EFI_FREE_QUESTION_ID_BITMAP_SIZE):
+ self.__FreeQIdBitMap.append(0)
+
+ # Question ID 0 is reserved.
+ self.__FreeQIdBitMap[0] = 0x80000000
+
+ self.__QuestionList = None
+
+ def FindQuestionByName(self, Name):
+ if Name == None:
+ return VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ pNode = self.__QuestionList
+ while pNode != None:
+ if pNode.Name == Name:
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+ pNode = pNode.Next
+
+ return VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def FindQuestionById(self, QuestionId):
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
+
+ pNode = self.__QuestionList
+ while pNode != None:
+ if pNode.QuestionId == QuestionId:
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+ pNode = pNode.Next
+
+ return VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ def __GetFreeQuestionId(self):
+
+ Index = 0
+ for i in range(0, EFI_FREE_QUESTION_ID_BITMAP_SIZE):
+ if self.__FreeQIdBitMap[i] != 0xFFFFFFFF:
+ Index = i
+ break
+ if Index == EFI_FREE_QUESTION_ID_BITMAP_SIZE:
+ return EFI_QUESTION_ID_INVALID
+
+ Offset = 0
+ Mask = 0x80000000
+ while Mask != 0:
+ if (self.__FreeQIdBitMap[Index] & Mask) == 0:
+ self.__FreeQIdBitMap[Index] |= Mask
+ return (Index << EFI_BITS_SHIFT_PER_UINT32) + Offset
+ Mask >>= 1
+ Offset += 1
+
+ return EFI_QUESTION_ID_INVALID
+
+ def __CheckQuestionIdFree(self, QId):
+ Index = int(QId / EFI_BITS_PER_UINT32)
+ Offset = QId % EFI_BITS_PER_UINT32
+ return (self.__FreeQIdBitMap[Index] & (0x80000000 >> Offset)) == 0
+
+ def __MarkQuestionIdUsed(self, QId):
+
+ Index = int(QId / EFI_BITS_PER_UINT32)
+ Offset = QId % EFI_BITS_PER_UINT32
+ self.__FreeQIdBitMap[Index] |= (0x80000000 >> Offset)
+
+ def __MarkQuestionIdUnused(self, QId):
+ Index = int(QId / EFI_BITS_PER_UINT32)
+ Offset = QId % EFI_BITS_PER_UINT32
+ self.__FreeQIdBitMap[Index] &= ~(0x80000000 >> Offset)
+
+ def RegisterQuestion(self, Name, VarIdStr, QuestionId):
+
+ if (Name != None) and (self.FindQuestionByName(Name) == VfrReturnCode.VFR_RETURN_SUCCESS):
+ return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
+
+ pNode = SVfrQuestionNode(Name, VarIdStr)
+ if pNode == None:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return QuestionId, VfrReturnCode.VFR_RETURN_QUESTIONID_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+
+ pNode.QuestionId = QuestionId
+ pNode.Next = self.__QuestionList
+ self.__QuestionList = pNode
+
+ # gCFormPkg.DoPendingAssign
+
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def UpdateQuestionId(self, QId, NewQId):
+
+ if QId == NewQId:
+ # don't update
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ if self.__CheckQuestionIdFree(NewQId) == False:
+ return VfrReturnCode.VFR_RETURN_REDEFINED
+
+ pNode = self.__QuestionList
+ TempList = []
+ while pNode != None:
+ if pNode.QuestionId == QId:
+ TempList.append(pNode)
+ pNode = pNode.Next
+
+ if len(TempList) == 0:
+ return VfrReturnCode.VFR_RETURN_UNDEFINED
+
+ self.__MarkQuestionIdUnused(QId)
+
+ for pNode in TempList:
+ pNode.QuestionId = NewQId
+
+ self.__MarkQuestionIdUsed(NewQId)
+
+ # gCFormPkg.DoPendingAssign
+ return VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def GetQuestionId(self, Name, VarIdStr=None, QType=None):
+
+ QuestionId = EFI_QUESTION_ID_INVALID
+ BitMask = 0x00000000
+ if QType != None:
+ QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+
+ if Name == None and VarIdStr == None:
+ return QuestionId, BitMask, QType
+
+ pNode = self.__QuestionList
+ while pNode != None:
+
+ if Name != None:
+ if pNode.Name != Name:
+ pNode = pNode.Next
+ continue
+
+ if VarIdStr != None:
+ if pNode.VarIdStr != VarIdStr:
+ pNode = pNode.Next
+ continue
+
+ QuestionId = pNode.QuestionId
+ BitMask = pNode.BitMask
+ if QType != None:
+ QType = pNode.QType
+ break
+
+ return QuestionId, BitMask, QType
+
+ def RegisterNewDateQuestion(self, Name, BaseVarId, QuestionId):
+
+ if BaseVarId == '' and Name == None:
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ VarIdStrList = []
+ if BaseVarId != '':
+ VarIdStrList.append(BaseVarId + '.Year')
+ VarIdStrList.append(BaseVarId + '.Month')
+ VarIdStrList.append(BaseVarId + '.Day')
+
+ else:
+ VarIdStrList.append(Name + '.Year')
+ VarIdStrList.append(Name + '.Month')
+ VarIdStrList.append(Name + '.Day')
+
+ pNodeList = []
+ pNode = SVfrQuestionNode(Name, VarIdStrList[0], DATE_YEAR_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[1], DATE_MONTH_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[2], DATE_DAY_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+
+ pNodeList[0].QuestionId = QuestionId
+ pNodeList[1].QuestionId = QuestionId
+ pNodeList[2].QuestionId = QuestionId
+ pNodeList[0].QType = EFI_QUESION_TYPE.QUESTION_DATE
+ pNodeList[1].QType = EFI_QUESION_TYPE.QUESTION_DATE
+ pNodeList[2].QType = EFI_QUESION_TYPE.QUESTION_DATE
+ pNodeList[0].Next = pNodeList[1]
+ pNodeList[1].Next = pNodeList[2]
+ pNodeList[2].Next = self.__QuestionList
+ self.__QuestionList = pNodeList[0]
+
+ # DoPendingAssign
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def RegisterNewTimeQuestion(self, Name, BaseVarId, QuestionId):
+ if BaseVarId == '' and Name == None:
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ VarIdStrList = []
+ if BaseVarId != '':
+ VarIdStrList.append(BaseVarId + '.Hour')
+ VarIdStrList.append(BaseVarId + '.Minute')
+ VarIdStrList.append(BaseVarId + '.Second')
+
+ else:
+ VarIdStrList.append(Name + '.Hour')
+ VarIdStrList.append(Name + '.Minute')
+ VarIdStrList.append(Name + '.Second')
+
+ pNodeList = []
+ pNode = SVfrQuestionNode(Name, VarIdStrList[0], TIME_HOUR_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[1], TIME_MINUTE_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[2], TIME_SECOND_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+
+ pNodeList[0].QuestionId = QuestionId
+ pNodeList[1].QuestionId = QuestionId
+ pNodeList[2].QuestionId = QuestionId
+ pNodeList[0].QType = EFI_QUESION_TYPE.QUESTION_TIME
+ pNodeList[1].QType = EFI_QUESION_TYPE.QUESTION_TIME
+ pNodeList[2].QType = EFI_QUESION_TYPE.QUESTION_TIME
+ pNodeList[0].Next = pNodeList[1]
+ pNodeList[1].Next = pNodeList[2]
+ pNodeList[2].Next = self.__QuestionList
+ self.__QuestionList = pNodeList[0]
+
+ # DoPendingAssign
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def RegisterRefQuestion(self, Name, BaseVarId, QuestionId):
+
+ if BaseVarId == '' and Name == None:
+ return QuestionId, VfrReturnCode.VFR_RETURN_FATAL_ERROR
+
+ VarIdStrList = []
+ if BaseVarId != '':
+ VarIdStrList.append(BaseVarId + '.QuestionId')
+ VarIdStrList.append(BaseVarId + '.FormId')
+ VarIdStrList.append(BaseVarId + '.FormSetGuid')
+ VarIdStrList.append(BaseVarId + '.DevicePath')
+
+ else:
+ VarIdStrList.append(BaseVarId + '.QuestionId')
+ VarIdStrList.append(BaseVarId + '.FormId')
+ VarIdStrList.append(BaseVarId + '.FormSetGuid')
+ VarIdStrList.append(BaseVarId + '.DevicePath')
+
+ pNodeList = []
+ pNode = SVfrQuestionNode(Name, VarIdStrList[0])
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[1])
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[2])
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(Name, VarIdStrList[3])
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return QuestionId, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+
+ pNodeList[0].QuestionId = QuestionId
+ pNodeList[1].QuestionId = QuestionId
+ pNodeList[2].QuestionId = QuestionId
+ pNodeList[3].QuestionId = QuestionId
+
+ pNodeList[0].QType = EFI_QUESION_TYPE.QUESTION_REF
+ pNodeList[1].QType = EFI_QUESION_TYPE.QUESTION_REF
+ pNodeList[2].QType = EFI_QUESION_TYPE.QUESTION_REF
+ pNodeList[3].QType = EFI_QUESION_TYPE.QUESTION_REF
+
+ pNodeList[0].Next = pNodeList[1]
+ pNodeList[1].Next = pNodeList[2]
+ pNodeList[2].Next = pNodeList[3]
+ pNodeList[3].Next = self.__QuestionList
+ self.__QuestionList = pNodeList[0]
+ x = self.__QuestionList
+
+ # DoPendingAssign
+
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def RegisterOldDateQuestion(self, YearVarId, MonthVarId, DayVarId, QuestionId):
+ pNodeList = []
+ if YearVarId == '' or MonthVarId == '' or DayVarId == '' or YearVarId == None or MonthVarId == None or DayVarId == None:
+ return QuestionId, VfrReturnCode.VFR_RETURN_ERROR_SKIPED
+
+ pNode = SVfrQuestionNode(None, YearVarId, DATE_YEAR_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(None, MonthVarId, DATE_MONTH_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(None, DayVarId, DATE_DAY_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+
+ pNodeList[0].QuestionId = QuestionId
+ pNodeList[1].QuestionId = QuestionId
+ pNodeList[2].QuestionId = QuestionId
+ pNodeList[0].QType = EFI_QUESION_TYPE.QUESTION_DATE
+ pNodeList[1].QType = EFI_QUESION_TYPE.QUESTION_DATE
+ pNodeList[2].QType = EFI_QUESION_TYPE.QUESTION_DATE
+ pNodeList[0].Next = pNodeList[1]
+ pNodeList[1].Next = pNodeList[2]
+ pNodeList[2].Next = self.__QuestionList
+ self.__QuestionList = pNodeList[0]
+
+ # DoPendingAssign
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def RegisterOldTimeQuestion(self, HourVarId, MinuteVarId, SecondVarId, QuestionId):
+ pNodeList = []
+ if HourVarId == '' or MinuteVarId == '' or SecondVarId == '' or HourVarId == None or MinuteVarId == None or SecondVarId == None:
+ return QuestionId, VfrReturnCode.VFR_RETURN_ERROR_SKIPED
+
+ pNode = SVfrQuestionNode(None, HourVarId, TIME_HOUR_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(None, MinuteVarId, TIME_MINUTE_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ pNode = SVfrQuestionNode(None, SecondVarId, TIME_SECOND_BITMASK)
+ if pNode != None:
+ pNodeList.append(pNode)
+ else:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
+
+ if QuestionId == EFI_QUESTION_ID_INVALID:
+ QuestionId = self.__GetFreeQuestionId()
+ else:
+ if self.__CheckQuestionIdFree(QuestionId) == False:
+ return EFI_QUESTION_ID_INVALID, VfrReturnCode.VFR_RETURN_REDEFINED
+ self.__MarkQuestionIdUsed(QuestionId)
+
+ pNodeList[0].QuestionId = QuestionId
+ pNodeList[1].QuestionId = QuestionId
+ pNodeList[2].QuestionId = QuestionId
+ pNodeList[0].QType = EFI_QUESION_TYPE.QUESTION_TIME
+ pNodeList[1].QType = EFI_QUESION_TYPE.QUESTION_TIME
+ pNodeList[2].QType = EFI_QUESION_TYPE.QUESTION_TIME
+ pNodeList[0].Next = pNodeList[1]
+ pNodeList[1].Next = pNodeList[2]
+ pNodeList[2].Next = self.__QuestionList
+ self.__QuestionList = pNodeList[0]
+
+ # DoPendingAssign
+ return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
+
+ def PrintAllQuestion(self, FileName):
+
+ with open(FileName, 'w') as f:
+ pNode = self.__QuestionList
+ while(pNode != None):
+
+ f.write('Question VarId is {} and QuestionId is '.format(pNode.VarIdStr))
+ f.write('%d\n'%(pNode.QuestionId))
+ # f.write('%#x\n'%(pNode.QuestionId))
+ pNode = pNode.Next
+
+ f.close()
\ No newline at end of file
diff --git a/edk2basetools/VfrCompiler/main.py b/edk2basetools/VfrCompiler/main.py
new file mode 100644
index 0000000..ba0cfbe
--- /dev/null
+++ b/edk2basetools/VfrCompiler/main.py
@@ -0,0 +1,27 @@
+from distutils.filelist import FileList
+from pickletools import uint8
+import sys
+from tkinter.ttk import Treeview
+from antlr4 import*
+from VfrCompiler.VfrSyntaxLexer import VfrSyntaxLexer
+from VfrCompiler.VfrSyntaxParser import VfrSyntaxParser
+from VfrCompiler.VfrSyntaxVisitor import VfrSyntaxVisitor
+from VfrCompiler.VfrError import *
+
+def VfrParse(Infile, YamlOutFile, JsonOutFile):
+ gCVfrErrorHandle.SetInputFile (Infile)
+ InputStream = FileStream(Infile)
+ Lexer = VfrSyntaxLexer(InputStream)
+ Stream = CommonTokenStream(Lexer)
+ Parser = VfrSyntaxParser(Stream)
+ Tree = Parser.vfrProgram()
+ Visitor = VfrSyntaxVisitor()
+ Visitor.visit(Tree)
+ Visitor.DumpYaml(Visitor.GetRoot(), YamlOutFile)
+ Visitor.DumpJson(JsonOutFile)
+
+if __name__ == '__main__':
+ Infile = 'VfrCompiler/test.i'
+ YamlOutFile = 'VfrCompiler/test.yaml'
+ JsonOutFile = 'VfrCompiler/test.json'
+ VfrParse(Infile, YamlOutFile, JsonOutFile)
--
2.27.0.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#99278): https://edk2.groups.io/g/devel/message/99278
Mute This Topic: https://groups.io/mt/96622973/1813853
Group Owner: devel+owner at edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [edk2-devel-archive at redhat.com]
-=-=-=-=-=-=-=-=-=-=-=-
More information about the edk2-devel-archive
mailing list