From: "Yuwei Chen" <yuwei.chen@intel.com>
To: "devel@edk2.groups.io" <devel@edk2.groups.io>,
"Yang, Yuting2" <yuting2.yang@intel.com>
Subject: Re: [edk2-devel] [Patch V2] [edk2-staging]BaseTools: Python VfrCompiler Tool
Date: Mon, 18 Mar 2024 00:36:24 +0000 [thread overview]
Message-ID: <PH7PR11MB5915BA5E7FD92A6F7F009943962D2@PH7PR11MB5915.namprd11.prod.outlook.com> (raw)
In-Reply-To: <20240315092045.1626-1-yuting2.yang@intel.com>
Reviewed-by: Yuwei Chen <yuwei.chen@intel.com>
> -----Original Message-----
> From: devel@edk2.groups.io <devel@edk2.groups.io> On Behalf Of Yuting
> Yang
> Sent: Friday, March 15, 2024 5:21 PM
> To: devel@edk2.groups.io
> Subject: [edk2-devel] [Patch V2] [edk2-staging]BaseTools: Python VfrCompiler
> Tool
>
> This python VfrCompiler tool is the python implementation
> of the edk2 VfrCompiler tool which C implementation locates at
> https://github.com/tianocore/edk2/tree/master/BaseTools/Source/C/VfrCom
> pile.
>
> This python implementation not only covers the same usage as
> the C version VfrCompiler, but also extends several new features.
>
> Cc: Rebecca Cran rebecca@bsdio.com
> Cc: Liming Gao gaoliming@byosoft.com.cn
> Cc: Bob Feng bob.c.feng@intel.com
> Signed-off-by: Yuting Yang yuting2.yang@intel.com
> ---
> BaseTools/BinWrappers/PosixLike/PyVfrCompile | 13 ++
> BaseTools/BinWrappers/WindowsLike/PyVfrCompile.bat | 4 +
> BaseTools/Conf/build_rule.template | 4 +-
> BaseTools/Conf/tools_def.template | 1 +
> BaseTools/Source/Python/VfrCompiler/CommonCtypes.py | 1394 -----------
> ----------------------------------------------------------------------------------------------------
> ------------
> BaseTools/Source/Python/VfrCompiler/IfrCommon.py | 100 +++++++++
> BaseTools/Source/Python/VfrCompiler/IfrCompiler.py | 587
> ++++++++++++++++++++++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrCtypes.py | 1811
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrError.py | 153
> ++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py | 2937
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++
> BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py | 262
> ++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrTree.py | 1734
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrUtility.py | 2226
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++
> BaseTools/Source/Python/VfrCompiler/README.md | 88 ++++++--
> BaseTools/Source/Python/VfrCompiler/VfrError.py | 162 ---------------
> BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py | 2738 ---------------
> ----------------------------------------------------------------------------------------------------
> ----------------------------------------------------------------------------------------------------
> --------------------------
> BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4 | 3808
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++++------------------------------------
> ----------------------------------------------------------------------------------------------------
> ------------------------------
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py | 17 +-
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py | 8145
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++++++++++++---------------------------------------
> ----------------------------------------------------------------------------------------------------
> ----------------------------------------------------------------------------------------------------
> ----------------------------------------------------------------------------------------------------
> -------------------
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py | 10610
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++--------------------------------------------
> ----------------------------------------------------------------------------------------------------
> ----------------------------------------------------------------------------------------------------
> ----------------------------------------------------------------------------------------------------
> ----------------------------------------------------------------------------------------------------
> ------
> BaseTools/Source/Python/VfrCompiler/VfrTree.py | 88 --------
> BaseTools/Source/Python/VfrCompiler/VfrUtility.py | 1991 -------------------
> ----------------------------------------------------------------------------------------------------
> ---------------------------------------------------------
> BaseTools/Source/Python/VfrCompiler/__init__.py | 1 +
> BaseTools/Source/Python/VfrCompiler/main.py | 27 ---
> 24 files changed, 21413 insertions(+), 17488 deletions(-)
>
> diff --git a/BaseTools/BinWrappers/PosixLike/PyVfrCompile
> b/BaseTools/BinWrappers/PosixLike/PyVfrCompile
> new file mode 100644
> index 0000000000..e87e2ae88f
> --- /dev/null
> +++ b/BaseTools/BinWrappers/PosixLike/PyVfrCompile
> @@ -0,0 +1,13 @@
> + #!/usr/bin/env bash
> + #python `dirname $0`/RunToolFromSource.py `basename $0` $*
> +
> + # If a ${PYTHON_COMMAND} command is available, use it in preference
> to python
> + if command -v ${PYTHON_COMMAND} >/dev/null 2>&1; then
> + python_exe=${PYTHON_COMMAND}
> + fi
> + full_cmd=${BASH_SOURCE:-$0} # see
> http://mywiki.wooledge.org/BashFAQ/028 for a discussion of why $0 is not a
> good choice here
> + dir=$(dirname "$full_cmd")
> + cmd=${full_cmd##*/}
> +
> + export
> PYTHONPATH="$dir/../../Source/Python:$dir/../../Source/Python/VfrCompiler
> :$dir/../../Source/Python${PYTHONPATH:+:"$PYTHONPATH"}"
> + exec "${python_exe:-python}" -m IfrCompiler "$@"
> \ No newline at end of file
> diff --git a/BaseTools/BinWrappers/WindowsLike/PyVfrCompile.bat
> b/BaseTools/BinWrappers/WindowsLike/PyVfrCompile.bat
> new file mode 100644
> index 0000000000..6f5758a481
> --- /dev/null
> +++ b/BaseTools/BinWrappers/WindowsLike/PyVfrCompile.bat
> @@ -0,0 +1,4 @@
> +@setlocal
> +@set ToolName=IfrCompiler
> +@set
> PYTHONPATH=%PYTHONPATH%;%BASE_TOOLS_PATH%\Source\Python;%BAS
> E_TOOLS_PATH%\Source\Python\VfrCompiler
> +@%PYTHON_COMMAND% -m %ToolName% %*
> \ No newline at end of file
> diff --git a/BaseTools/Conf/build_rule.template
> b/BaseTools/Conf/build_rule.template
> index d42e7937cc..0e19133589 100755
> --- a/BaseTools/Conf/build_rule.template
> +++ b/BaseTools/Conf/build_rule.template
> @@ -257,6 +257,7 @@
> <Command>
>
> "$(VFRPP)" $(DEPS_FLAGS) $(VFRPP_FLAGS) $(INC) ${src} >
> $(OUTPUT_DIR)(+)${s_base}.i
>
> "$(VFR)" $(VFR_FLAGS) --string-db
> $(OUTPUT_DIR)(+)$(MODULE_NAME)StrDefs.hpk --output-directory
> ${d_path} $(OUTPUT_DIR)(+)${s_base}.i
>
> + "$(PYVFR)" ${src} --string-db
> $(OUTPUT_DIR)(+)$(MODULE_NAME)StrDefs.hpk -w $(WORKSPACE) -m
> $(MODULE_NAME) -o $(OUTPUT_DIR) --vfr
>
>
>
> [Object-File]
>
> <InputFile>
>
> @@ -628,7 +629,8 @@
> <Command>
>
> "$(VFRPP)" $(DEPS_FLAGS) $(VFRPP_FLAGS) $(INC) ${src} >
> $(OUTPUT_DIR)(+)${s_dir}(+)${s_base}.i
>
> "$(VFR)" $(VFR_FLAGS) --create-ifr-package --string-db
> $(OUTPUT_DIR)(+)$(MODULE_NAME)StrDefs.hpk --output-directory
> $(OUTPUT_DIR)(+)${s_dir} $(OUTPUT_DIR)(+)${s_dir}(+)${s_base}.i
>
> -
>
> + "$(PYVFR)" ${src} --string-db
> $(OUTPUT_DIR)(+)$(MODULE_NAME)StrDefs.hpk -w $(WORKSPACE) -m
> $(MODULE_NAME) -o $(OUTPUT_DIR) --vfr
>
> +
>
> [Hii-Binary-Package.UEFI_HII]
>
> <InputFile>
>
> *.hpk
>
> diff --git a/BaseTools/Conf/tools_def.template
> b/BaseTools/Conf/tools_def.template
> index 380d458733..6e01fc7ccb 100755
> --- a/BaseTools/Conf/tools_def.template
> +++ b/BaseTools/Conf/tools_def.template
> @@ -3036,6 +3036,7 @@ RELEASE_XCODE5_X64_CC_FLAGS = -target
> x86_64-pc-win32-macho -c -Os -W
> ##################
>
> *_*_*_VFR_PATH = VfrCompile
>
> *_*_*_VFR_FLAGS = -l -n
>
> +*_*_*_PYVFR_PATH = PyVfrCompile
>
>
>
> ##################
>
> # OptionRom tool definitions
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/CommonCtypes.py
> b/BaseTools/Source/Python/VfrCompiler/CommonCtypes.py
> deleted file mode 100644
> index b62145d980..0000000000
> --- a/BaseTools/Source/Python/VfrCompiler/CommonCtypes.py
> +++ /dev/null
> @@ -1,1394 +0,0 @@
> -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/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> new file mode 100644
> index 0000000000..69e5663f32
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> @@ -0,0 +1,100 @@
> +## @file
> +# This file is used to define common funtions.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +import Common.EdkLogger as EdkLogger
> +from VfrCompiler.IfrCtypes import EFI_GUID
> +from Common.BuildToolError import PARAMETER_INVALID
> +
> +# Enumeration of EFI_STATUS.
> +RETURN_SUCCESS = EFI_SUCCESS = 0
> +EFI_BUFFER_TOO_SMALL = 0x8000000000000000 | (5)
> +EFI_ABORTED = 0x8000000000000000 | (21)
> +EFI_OUT_OF_RESOURCES = 0x8000000000000000 | (9)
> +EFI_INVALID_PARAMETER = 0x8000000000000000 | (2)
> +EFI_NOT_FOUND = 0x8000000000000000 | (14)
> +RETURN_INVALID_PARAMETER = 0x8000000000000000 | (2)
> +RETURN_UNSUPPORTED = 0x8000000000000000 | (3)
> +
> +ASCII_GUID_BUFFER_INDEX_1 = 8
> +ASCII_GUID_BUFFER_INDEX_2 = 13
> +ASCII_GUID_BUFFER_INDEX_3 = 18
> +ASCII_GUID_BUFFER_INDEX_4 = 23
> +ASCII_GUID_BUFFER_MAX_INDEX = 36
> +GUID_BUFFER_VALUE_LEN = 11
> +
> +
> +def EFI_ERROR(A):
> + return A < 0
> +
> +
> +# Converts a string to an EFI_GUID.
> +def StringToGuid(AsciiGuidBuffer: str, GuidBuffer: EFI_GUID):
> + Data4 = [0] * 8
> + if AsciiGuidBuffer is None or GuidBuffer is None:
> + return EFI_INVALID_PARAMETER
> + Index = 0
> + while Index < ASCII_GUID_BUFFER_MAX_INDEX:
> + if (
> + Index == ASCII_GUID_BUFFER_INDEX_1
> + or Index == ASCII_GUID_BUFFER_INDEX_2
> + or Index == ASCII_GUID_BUFFER_INDEX_3
> + or Index == ASCII_GUID_BUFFER_INDEX_4
> + ):
> + if AsciiGuidBuffer[Index] != "-":
> + break
> + elif (
> + (AsciiGuidBuffer[Index] >= "0" and AsciiGuidBuffer[Index] <= "9")
> + or (AsciiGuidBuffer[Index] >= "a" and AsciiGuidBuffer[Index] <= "f")
> + or (AsciiGuidBuffer[Index] >= "A" and AsciiGuidBuffer[Index] <= "F")
> + ):
> + Index += 1
> + continue
> + else:
> + break
> + Index += 1
> + continue
> +
> + if Index < ASCII_GUID_BUFFER_MAX_INDEX:
> + EdkLogger.error("VfrCompiler", PARAMETER_INVALID, "Invalid option
> value")
> + return EFI_ABORTED
> + Index = GUID_BUFFER_VALUE_LEN
> + try:
> + Data1 = int(AsciiGuidBuffer[0:8], 16)
> + Data2 = int(AsciiGuidBuffer[9:13], 16)
> + Data3 = int(AsciiGuidBuffer[14:18], 16)
> + Data4[0] = int(AsciiGuidBuffer[19:21], 16)
> + Data4[1] = int(AsciiGuidBuffer[21:23], 16)
> + Data4[2] = int(AsciiGuidBuffer[24:26], 16)
> + Data4[3] = int(AsciiGuidBuffer[26:28], 16)
> + Data4[4] = int(AsciiGuidBuffer[28:30], 16)
> + Data4[5] = int(AsciiGuidBuffer[30:32], 16)
> + Data4[6] = int(AsciiGuidBuffer[32:34], 16)
> + Data4[7] = int(AsciiGuidBuffer[34:36], 16)
> + except Exception:
> + EdkLogger.error("VfrCompiler", PARAMETER_INVALID, "Invalid Data
> value!")
> + Index = 0
> +
> + # Verify the correct number of items were scanned.
> + if Index != GUID_BUFFER_VALUE_LEN:
> + EdkLogger.error("VfrCompiler", PARAMETER_INVALID, "Invalid option
> value")
> + return EFI_ABORTED
> +
> + # Copy the data into our GUID.
> + GuidBuffer.Data1 = Data1
> + GuidBuffer.Data2 = Data2
> + GuidBuffer.Data3 = Data3
> + GuidBuffer.Data4[0] = Data4[0]
> + GuidBuffer.Data4[1] = Data4[1]
> + GuidBuffer.Data4[2] = Data4[2]
> + GuidBuffer.Data4[3] = Data4[3]
> + GuidBuffer.Data4[4] = Data4[4]
> + GuidBuffer.Data4[5] = Data4[5]
> + GuidBuffer.Data4[6] = Data4[6]
> + GuidBuffer.Data4[7] = Data4[7]
> + Status = EFI_SUCCESS
> +
> + return Status, GuidBuffer
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> b/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> new file mode 100644
> index 0000000000..e0ebc76921
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> @@ -0,0 +1,587 @@
> +## @file
> +# Extented Python VfrCompiler Tool.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +import os
> +import sys
> +import argparse
> +import Common.EdkLogger as EdkLogger
> +from pathlib import Path
> +from antlr4 import *
> +from enum import Enum
> +from Common.BuildToolError import *
> +from VfrCompiler.VfrSyntaxParser import VfrSyntaxParser
> +from VfrCompiler.VfrSyntaxVisitor import VfrSyntaxVisitor
> +from VfrCompiler.VfrSyntaxLexer import VfrSyntaxLexer
> +from VfrCompiler.IfrCommon import EFI_SUCCESS, EFI_ERROR, StringToGuid
> +from VfrCompiler.IfrTree import IfrTreeNode, IfrTree,
> VFR_COMPILER_VERSION, BUILD_VERSION
> +from VfrCompiler.IfrPreProcess import Options, PreProcessDB
> +from VfrCompiler.IfrUtility import gVfrStringDB
> +from VfrCompiler.IfrFormPkg import (
> + gFormPkg,
> + gVfrVarDataTypeDB,
> + gVfrDefaultStore,
> + gVfrDataStorage,
> + gIfrFormId,
> +)
> +from VfrCompiler.IfrError import gVfrErrorHandle
> +
> +
> +class COMPILER_RUN_STATUS(Enum):
> + STATUS_STARTED = 0
> + STATUS_INITIALIZED = 1
> + STATUS_VFR_PREPROCESSED = 2
> + STATUS_VFR_COMPILEED = 3
> + STATUS_VFR_GENBINARY = 4
> + STATUS_YAML_GENERATED = 5
> + STATUS_YAML_PREPROCESSED = 6
> + STATUS_YAML_COMPILED = 7
> + STATUS_YAML_DLT_CONSUMED = 8
> + STATUS_YAML_GENBINARY = 9
> + STATUS_FINISHED = 10
> + STATUS_FAILED = 11
> + STATUS_DEAD = 12
> +
> +
> +"""
> + This is how we invoke the C preprocessor on the VFR source file
> + to resolve #defines, #includes, etc. To make C source files
> + shareable between VFR and drivers, define VFRCOMPILE so that
> + #ifdefs can be used in shared .h files.
> +"""
> +PREPROCESSOR_COMMAND = "cl "
> +PREPROCESSOR_OPTIONS = "/nologo /E /TC /DVFRCOMPILE "
> +
> +# Specify the filename extensions for the files we generate.
> +VFR__FILENAME_EXTENSION = ".vfr"
> +VFR_PREPROCESS_FILENAME_EXTENSION = ".i"
> +VFR_PACKAGE_FILENAME_EXTENSION = ".hpk"
> +VFR_RECORDLIST_FILENAME_EXTENSION = ".lst"
> +VFR_YAML_FILENAME_EXTENSION = ".yml"
> +VFR_JSON_FILENAME_EXTENSION = ".json"
> +
> +WARNING_LOG_LEVEL = 15
> +UTILITY_NAME = "VfrCompiler"
> +
> +parser = argparse.ArgumentParser(
> + description="VfrCompiler",
> + epilog=f"VfrCompile version {VFR_COMPILER_VERSION} \
> + Build {BUILD_VERSION} Copyright (c) 2004-2016 Intel
> Corporation.\
> + All rights reserved.",
> +)
> +parser.add_argument("InputFileName", help="Input source file name")
> +parser.add_argument(
> + "--vfr", dest="LanuchVfrCompiler", action="store_true", help="lanuch
> VfrCompiler"
> +)
> +parser.add_argument(
> + "--version",
> + action="version",
> + version=f"VfrCompile version {VFR_COMPILER_VERSION} Build
> {BUILD_VERSION}",
> + help="prints version info",
> +)
> +parser.add_argument("-l", dest="CreateRecordListFile", help="create an
> output IFR listing file")
> +parser.add_argument("-c", dest="CreateYamlFile", help="create Yaml file")
> +parser.add_argument("-j", dest="CreateJsonFile", help="create Json file")
> +parser.add_argument("-w", dest="Workspace", help="workspace")
> +parser.add_argument(
> + "-o",
> + "--output-directory",
> + "-od",
> + dest="OutputDirectory",
> + help="deposit all output files to directory OutputDir, \
> + default is current directory",
> +)
> +parser.add_argument(
> + "-oo",
> + "--old-output-directory",
> + "-ood",
> + dest="OldOutputDirectory",
> + help="Former directory OutputDir of output files, \
> + default is current directory",
> +)
> +parser.add_argument(
> + "-b",
> + "--create-ifr-package",
> + "-ibin",
> + dest="CreateIfrPkgFile",
> + help="create an IFR HII pack file",
> +)
> +parser.add_argument(
> + "-n",
> + "--no-pre-processing",
> + "-nopp",
> + dest="SkipCPreprocessor",
> + help="do not preprocessing input file",
> +)
> +parser.add_argument(
> + "-f",
> + "--pre-processing-flag",
> + "-ppflag",
> + dest="CPreprocessorOptions",
> + help="C-preprocessor argument",
> +) #
> +parser.add_argument(
> + "-s", "--string-db", dest="StringFileName", help="input uni string package
> file"
> +)
> +parser.add_argument(
> + "-g",
> + "--guid",
> + dest="OverrideClassGuid",
> + help="override class guid input,\
> + format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
> +)
> +parser.add_argument(
> + "-wae", "--warning-as-error", dest="WarningAsError", help="treat warning
> as an error"
> +)
> +parser.add_argument(
> + "-a",
> + "--autodefault",
> + dest="AutoDefault",
> + help="generate default value for question opcode if some default is
> missing",
> +)
> +parser.add_argument(
> + "-d",
> + "--checkdefault",
> + dest="CheckDefault",
> + help="check the default information in a question opcode",
> +)
> +parser.add_argument("-m", "--modulename", dest="ModuleName",
> help="Module name")
> +
> +
> +class CmdParser:
> + def __init__(self, Args, Argc):
> + self.Options = Options()
> + self.RunStatus = COMPILER_RUN_STATUS.STATUS_STARTED
> + self.PreProcessCmd = PREPROCESSOR_COMMAND
> + self.PreProcessOpt = PREPROCESSOR_OPTIONS
> + self.OptionIntialization(Args, Argc)
> +
> + def OptionIntialization(self, Args, Argc):
> + Status = EFI_SUCCESS
> +
> + if Argc == 1:
> + parser.print_help()
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if Args.LanuchVfrCompiler:
> + self.Options.LanuchVfrCompiler = True
> +
> + if Args.CreateRecordListFile:
> + self.Options.CreateRecordListFile = True
> +
> + if Args.ModuleName:
> + self.Options.ModuleName = Args.ModuleName
> +
> + if Args.OutputDirectory:
> + self.Options.OutputDirectory = Args.OutputDirectory
> + if self.Options.OutputDirectory is None:
> + EdkLogger.error("VfrCompiler", OPTION_MISSING, "-o missing
> output directory name")
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> + self.Options.DebugDirectory =
> str(Path(self.Options.OutputDirectory).parent / "DEBUG")
> + EdkLogger.debug(EdkLogger.DEBUG_8, f"Output Directory
> {self.Options.OutputDirectory}")
> +
> + if Args.Workspace:
> + self.Options.Workspace = Args.Workspace
> + IsInCludePathLine = False
> + HasVFRPPLine = False
> + self.Options.IncludePaths = []
> + MakeFile = Path(self.Options.OutputDirectory).parent / "Makefile"
> + if MakeFile.exists():
> + with MakeFile.open(mode="r") as File:
> + for Line in File:
> + if Line.find("INC = \\") != -1:
> + IsInCludePathLine = True
> + continue
> + if Line.find("VFRPP = ") != -1:
> + HasVFRPPLine = True
> + self.Options.VFRPP = Line.split("=")[1].strip()
> + continue
> + if IsInCludePathLine:
> + Line = Line.lstrip().rstrip(" \\\n\r")
> + if Line.startswith("/IC"):
> + InCludePath = Line.replace("/IC", "C", 1)
> + self.Options.IncludePaths.append(InCludePath)
> + elif Line.startswith("/Ic"):
> + InCludePath = Line.replace("/Ic", "C", 1)
> + self.Options.IncludePaths.append(InCludePath)
> + elif Line.startswith("/I$(WORKSPACE)"):
> + InCludePath = Line.replace(
> + "/I$(WORKSPACE)", self.Options.Workspace, 1
> + )
> + self.Options.IncludePaths.append(InCludePath)
> + elif Line.startswith("/I$(DEBUG_DIR)"):
> + InCludePath = self.Options.DebugDirectory
> + self.Options.IncludePaths.append(InCludePath)
> + elif HasVFRPPLine is False:
> + IsInCludePathLine = False
> + else:
> + break
> +
> + if Args.OldOutputDirectory:
> + self.Options.OldOutputDirectory = Args.OldOutputDirectory
> + if self.Options.OldOutputDirectory is None:
> + EdkLogger.error("VfrCompiler", OPTION_MISSING, "-oo missing
> output directory name")
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> + EdkLogger.debug(
> + EdkLogger.DEBUG_8, f"Old Output Directory
> {self.Options.OldOutputDirectory}"
> + )
> +
> + if Args.CreateIfrPkgFile:
> + self.Options.CreateIfrPkgFile = True
> +
> + if Args.CreateYamlFile:
> + self.Options.CreateYamlFile = True
> +
> + if Args.CreateJsonFile:
> + self.Options.CreateJsonFile = True
> +
> + if Args.SkipCPreprocessor:
> + self.Options.SkipCPreprocessor = True
> +
> + if Args.CPreprocessorOptions:
> + Options = Args.CPreprocessorOptions
> + if Options is None:
> + EdkLogger.error(
> + "VfrCompiler",
> + OPTION_MISSING,
> + "-od - missing C-preprocessor argument",
> + )
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> + self.Options.CPreprocessorOptions += " " + Options
> +
> + if Args.StringFileName:
> + StringFileName = Args.StringFileName
> + if StringFileName is None:
> + EdkLogger.error("VfrCompiler", OPTION_MISSING, "-s missing input
> string file name")
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> + gVfrStringDB.SetStringFileName(StringFileName)
> + EdkLogger.debug(EdkLogger.DEBUG_8, f"Input string file path
> {StringFileName}")
> +
> + if Args.OverrideClassGuid:
> + res = StringToGuid(Args.OverrideClassGuid,
> self.Options.OverrideClassGuid)
> + if type(res) == "int":
> + Status = res
> + else:
> + Status = res[0]
> + self.Options.OverrideClassGuid = res[1]
> +
> + if EFI_ERROR(Status):
> + EdkLogger.error(
> + "VfrCompiler",
> + FORMAT_INVALID,
> + f"Invalid format: {Args.OverrideClassGuid}",
> + )
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + self.Options.HasOverrideClassGuid = True
> +
> + if Args.WarningAsError:
> + self.Options.WarningAsError = True
> +
> + if Args.AutoDefault:
> + self.Options.AutoDefault = True
> +
> + if Args.CheckDefault:
> + self.Options.CheckDefault = True
> +
> + if Args.InputFileName:
> + self.Options.InputFileName = Args.InputFileName
> + if self.Options.InputFileName is None:
> + EdkLogger.error("VfrCompiler", OPTION_MISSING, "Input file name
> is not specified.")
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.Options.OutputDirectory is None:
> + self.Options.OutputDirectory = ""
> +
> + if self.SetBaseFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.SetPkgOutputFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.SetCOutputFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.SetPreprocessorOutputFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.SetRecordListFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.SetSourceYamlFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + if self.SetJsonFileName() != 0:
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> +
> + def SetBaseFileName(self):
> + if self.Options.InputFileName is None:
> + return -1
> + pFileName = self.Options.InputFileName
> + while (pFileName.find("\\") != -1) or (pFileName.find("/") != -1):
> + if pFileName.find("\\") != -1:
> + i = pFileName.find("\\")
> + else:
> + i = pFileName.find("/")
> +
> + if i == len(pFileName) - 1:
> + return -1
> +
> + pFileName = pFileName[i + 1 :]
> +
> + if pFileName == "" or pFileName.find(".") == -1:
> + return -1
> +
> + self.Options.BaseFileName = pFileName[: pFileName.find(".")]
> + return 0
> +
> + def SetPkgOutputFileName(self):
> + if self.Options.BaseFileName is None:
> + return -1
> + if self.Options.LanuchVfrCompiler:
> + self.Options.PkgOutputFileName = str(
> + Path(self.Options.OutputDirectory) /
> f"PyVfr_{self.Options.BaseFileName}.hpk"
> + )
> + return 0
> +
> + def SetCOutputFileName(self):
> + if self.Options.BaseFileName is None:
> + return -1
> + if self.Options.LanuchVfrCompiler:
> + self.Options.COutputFileName = str(
> + Path(self.Options.DebugDirectory) /
> f"PyVfr_{self.Options.BaseFileName}.c"
> + )
> + return 0
> +
> + def SetPreprocessorOutputFileName(self):
> + if self.Options.BaseFileName is None:
> + return -1
> + self.Options.CProcessedVfrFileName = str(
> + Path(self.Options.OutputDirectory) / f"{self.Options.BaseFileName}.i"
> + )
> + return 0
> +
> + def SetRecordListFileName(self):
> + if self.Options.BaseFileName is None:
> + return -1
> + if self.Options.LanuchVfrCompiler:
> + self.Options.RecordListFileName = str(
> + Path(self.Options.DebugDirectory) /
> f"PyVfr_{self.Options.BaseFileName}.lst"
> + )
> + return 0
> +
> + def SetSourceYamlFileName(self):
> + if self.Options.BaseFileName is None:
> + return -1
> + self.Options.YamlFileName = str(
> + Path(self.Options.DebugDirectory) /
> f"{self.Options.BaseFileName}.yml"
> + )
> + self.Options.YamlOutputFileName = str(
> + Path(self.Options.DebugDirectory) /
> f"{self.Options.BaseFileName}Compiled.yml"
> + )
> + return 0
> +
> + def SetJsonFileName(self):
> + if self.Options.BaseFileName is None:
> + return -1
> + self.Options.JsonFileName = str(
> + Path(self.Options.DebugDirectory) /
> f"{self.Options.BaseFileName}.json"
> + )
> + return 0
> +
> + def FindIncludeHeaderFile(self, Start, Name):
> + FileList = []
> + for Relpath, _, Files in os.walk(Start):
> + if Name in Files:
> + FullPath = os.path.join(Start, Relpath, Name)
> + FileList.append(os.path.normpath(os.path.abspath(FullPath)))
> + return FileList
> +
> + def SET_RUN_STATUS(self, Status):
> + self.RunStatus = Status
> +
> + def IS_RUN_STATUS(self, Status):
> + return self.RunStatus == Status
> +
> +
> +class VfrCompiler:
> + def __init__(self, Cmd: CmdParser):
> + self.Clear()
> + self.Options = Cmd.Options
> + self.RunStatus = Cmd.RunStatus
> + self.VfrRoot = IfrTreeNode()
> + self.PreProcessDB = PreProcessDB(self.Options)
> + self.VfrTree = IfrTree(self.VfrRoot, self.PreProcessDB, self.Options)
> + if (not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED))
> and (
> + not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + ):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_INITIALIZED)
> +
> + def Clear(self):
> + gVfrVarDataTypeDB.Clear()
> + gVfrDefaultStore.Clear()
> + gVfrDataStorage.Clear()
> + gFormPkg.Clear()
> + gIfrFormId.Clear()
> +
> + def PreProcess(self):
> + if not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_INITIALIZED):
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + elif self.Options.SkipCPreprocessor is False:
> + # call C preprocessor first in the tool itself, but currently not support
> here
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + # makefile will call cl commands to generate .i file
> + # do not need to run C preprocessor in this tool itself
> + self.PreProcessDB.Preprocess()
> +
> self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_PREPROCESSED)
> +
> + def Compile(self):
> + InFileName = self.Options.CProcessedVfrFileName
> + if not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_PREPROCESSED):
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_PARSE_FAILURE,
> + "compile error in file %s" % InFileName,
> + InFileName,
> + )
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + gVfrErrorHandle.SetInputFile(self.Options.InputFileName)
> + gVfrErrorHandle.SetWarningAsError(self.Options.WarningAsError)
> +
> + try:
> + InputStream = FileStream(InFileName)
> + VfrLexer = VfrSyntaxLexer(InputStream)
> + VfrStream = CommonTokenStream(VfrLexer)
> + VfrParser = VfrSyntaxParser(VfrStream)
> + except:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_OPEN_FAILURE,
> + "File open failed for %s" % InFileName,
> + InFileName,
> + )
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + return
> + self.Visitor = VfrSyntaxVisitor(
> + self.PreProcessDB, self.VfrRoot, self.Options.OverrideClassGuid
> + )
> + self.Visitor.visit(VfrParser.vfrProgram())
> +
> + if self.Visitor.ParserStatus != 0:
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_PARSE_FAILURE,
> + "compile error in file %s" % InFileName,
> + InFileName,
> + )
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + return
> +
> + if gFormPkg.HavePendingUnassigned() is True:
> + gFormPkg.PendingAssignPrintAll()
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_PARSE_FAILURE,
> + "compile error in file %s" % InFileName,
> + InFileName,
> + )
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + return
> +
> +
> self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_COMPILEED)
> + if self.Options.CreateJsonFile:
> + self.VfrTree.DumpJson()
> +
> + def GenBinary(self):
> + if not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_COMPILEED):
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + if self.Options.CreateIfrPkgFile:
> + self.VfrTree.GenBinary()
> +
> + def GenCFile(self):
> + if not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_COMPILEED):
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + if self.Options.CreateIfrPkgFile:
> + self.VfrTree.GenCFile()
> +
> + def GenRecordListFile(self):
> + if not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_COMPILEED):
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + if self.Options.CreateRecordListFile:
> + self.VfrTree.GenRecordListFile()
> +
> + def GenBinaryFiles(self):
> + if not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_VFR_COMPILEED):
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + self.VfrTree.GenBinaryFiles()
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FINISHED)
> +
> + def DumpSourceYaml(self):
> + if not self.IS_RUN_STATUS(
> + COMPILER_RUN_STATUS.STATUS_VFR_COMPILEED
> + ) and not
> self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FINISHED):
> + if not self.IS_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD):
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FAILED)
> + else:
> + if self.Options.CreateYamlFile:
> + self.VfrTree.DumpYamlForXMLCLI()
> + self.VfrTree.DumpYamlForConfigEditor()
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_FINISHED)
> +
> + def SET_RUN_STATUS(self, Status):
> + self.RunStatus = Status
> +
> + def IS_RUN_STATUS(self, Status):
> + return self.RunStatus == Status
> +
> +
> +def main():
> + Args = parser.parse_args()
> + Argc = len(sys.argv)
> + EdkLogger.SetLevel(WARNING_LOG_LEVEL)
> + Cmd = CmdParser(Args, Argc)
> + Compiler = VfrCompiler(Cmd)
> + Compiler.PreProcess()
> + Compiler.Compile()
> + Compiler.GenBinaryFiles()
> + #Compiler.DumpSourceYaml()
> + Status = Compiler.RunStatus
> + if Status == COMPILER_RUN_STATUS.STATUS_DEAD or Status ==
> COMPILER_RUN_STATUS.STATUS_FAILED:
> + return 2
> +
> + return EFI_SUCCESS
> +
> +
> +if __name__ == "__main__":
> + sys.exit(main())
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> b/BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> new file mode 100644
> index 0000000000..c3a3dd6584
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> @@ -0,0 +1,1811 @@
> +## @file
> +# This file is used to define the common C struct and functions.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +from ctypes import *
> +from struct import *
> +from enum import Enum
> +
> +
> +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_8_BIT_SIZE = 0x01
> +EFI_IFR_TYPE_NUM_SIZE_16 = 0x01
> +EFI_IFR_TYPE_NUM_16_BIT_SIZE = 0x02
> +EFI_IFR_TYPE_NUM_SIZE_32 = 0x02
> +EFI_IFR_TYPE_NUM_32_BIT_SIZE = 0x04
> +EFI_IFR_TYPE_NUM_SIZE_64 = 0x03
> +EFI_IFR_TYPE_NUM_64_BIT_SIZE = 0x08
> +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
> +
> +EFI_HII_SIBT_END = 0x00
> +EFI_HII_SIBT_STRING_SCSU = 0x10
> +EFI_HII_SIBT_STRING_SCSU_FONT = 0x11
> +EFI_HII_SIBT_STRINGS_SCSU = 0x12
> +EFI_HII_SIBT_STRINGS_SCSU_FONT = 0x13
> +EFI_HII_SIBT_STRING_UCS2 = 0x14
> +EFI_HII_SIBT_STRING_UCS2_FONT = 0x15
> +EFI_HII_SIBT_STRINGS_UCS2 = 0x16
> +EFI_HII_SIBT_STRINGS_UCS2_FONT = 0x17
> +EFI_HII_SIBT_DUPLICATE = 0x20
> +EFI_HII_SIBT_SKIP2 = 0x21
> +EFI_HII_SIBT_SKIP1 = 0x22
> +EFI_HII_SIBT_EXT1 = 0x30
> +EFI_HII_SIBT_EXT2 = 0x31
> +EFI_HII_SIBT_EXT4 = 0x32
> +EFI_HII_SIBT_FONT = 0x40
> +
> +BasicTypes = [
> + EFI_IFR_TYPE_NUM_SIZE_8,
> + EFI_IFR_TYPE_NUM_SIZE_16,
> + EFI_IFR_TYPE_NUM_SIZE_32,
> + EFI_IFR_TYPE_NUM_SIZE_64,
> +]
> +BasicCInts = [c_uint64, c_uint32, c_uint16, c_uint8, c_ubyte, c_ushort]
> +
> +
> +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 to_string(self) -> str:
> + GuidStr = f"{{{self.Data1:#x}, {self.Data2:#x}, {self.Data3:#x}, {{ {',
> '.join(f'{x:#x}' for x in self.Data4)}}}}}"
> +
> + return GuidStr
> +
> + 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", ARRAY(c_ubyte, 2)),
> + ]
> +
> +
> +def Refine_EFI_IFR_VARSTORE(Nums):
> + class EFI_IFR_VARSTORE(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("Guid", EFI_GUID),
> + ("VarStoreId", c_uint16),
> + ("Size", c_uint16),
> + ("Name", ARRAY(c_ubyte, Nums)),
> + ]
> +
> + def __init__(self) -> None:
> + self.Header = EFI_IFR_OP_HEADER()
> +
> + return EFI_IFR_VARSTORE()
> +
> +
> +class EFI_IFR_VARSTORE_EFI(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("VarStoreId", c_uint16),
> + ("Guid", EFI_GUID),
> + ("Attributes", c_uint32),
> + ("Size", c_uint16),
> + ("Name", ARRAY(c_ubyte, 2)),
> + ]
> +
> +
> +def Refine_EFI_IFR_VARSTORE_EFI(Nums):
> + class EFI_IFR_VARSTORE_EFI(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("VarStoreId", c_uint16),
> + ("Guid", EFI_GUID),
> + ("Attributes", c_uint32),
> + ("Size", c_uint16),
> + ("Name", ARRAY(c_ubyte, Nums)),
> + ]
> +
> + def __init__(self) -> None:
> + self.Header = EFI_IFR_OP_HEADER()
> +
> + return EFI_IFR_VARSTORE_EFI()
> +
> +
> +class EFI_IFR_GUID(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("Guid", EFI_GUID),
> + ]
> +
> +
> +def Refine_EFI_IFR_BUFFER(Nums):
> + class EFI_IFR_BUFFER(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Data", ARRAY(c_ubyte, Nums)),
> + ]
> +
> + def SetBuffer(self, Buffer):
> + self.Buffer = Buffer
> +
> + return EFI_IFR_BUFFER()
> +
> +
> +def Refine_EFI_IFR_BIT_BUFFER(Nums):
> + class EFI_IFR_BIT_BUFFER(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Data", ARRAY(c_ubyte, Nums)),
> + ]
> +
> + def SetBuffer(self, Buffer):
> + self.Buffer = Buffer
> +
> + return EFI_IFR_BIT_BUFFER
> +
> +
> +def Refine_EFI_IFR_BIT(Type, PreBits, Size, Data):
> + if PreBits == 0:
> +
> + class Refine_EFI_IFR_BIT(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Data", Type, Size), # the really needed data
> + ("Postfix", Type, sizeof(Type) * 8 - Size),
> + ]
> +
> + def __init__(self, Data):
> + self.Data = Data
> +
> + elif sizeof(Type) * 8 - Size - PreBits == 0:
> +
> + class Refine_EFI_IFR_BIT(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Prefix", Type, PreBits),
> + ("Data", Type, Size), # the really needed data
> + ]
> +
> + def __init__(self, Data):
> + self.Data = Data
> +
> + else:
> +
> + class Refine_EFI_IFR_BIT(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Prefix", Type, PreBits),
> + ("Data", Type, Size), # the really needed data
> + ("Postfix", Type, sizeof(Type) * 8 - Size - PreBits),
> + ]
> +
> + def __init__(self, Data):
> + self.Data = Data
> +
> + return Refine_EFI_IFR_BIT(Data)
> +
> +
> +class EFI_IFR_GUID_VAREQNAME(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("Guid", EFI_GUID),
> + ("ExtendOpCode", c_uint8),
> + ("QuestionId", c_uint16),
> + ("NameId", c_uint16),
> + ]
> +
> +
> +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),
> + ]
> +
> +
> +def Refine_EFI_IFR_ONE_OF(Type):
> + if Type == EFI_IFR_TYPE_NUM_SIZE_8:
> + DataType = u8Node
> + elif Type == EFI_IFR_TYPE_NUM_SIZE_16:
> + DataType = u16Node
> + elif Type == EFI_IFR_TYPE_NUM_SIZE_32:
> + DataType = u32Node
> + elif Type == EFI_IFR_TYPE_NUM_SIZE_64:
> + DataType = u64Node
> + else:
> + DataType = u32Node
> +
> + class EFI_IFR_ONE_OF(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("Question", EFI_IFR_QUESTION_HEADER),
> + ("Flags", c_ubyte),
> + ("Data", DataType),
> + ]
> +
> + return EFI_IFR_ONE_OF()
> +
> +
> +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),
> + ]
> +
> +
> +def Refine_EFI_IFR_NUMERIC(Type):
> + if Type == EFI_IFR_TYPE_NUM_SIZE_8:
> + DataType = u8Node
> + elif Type == EFI_IFR_TYPE_NUM_SIZE_16:
> + DataType = u16Node
> + elif Type == EFI_IFR_TYPE_NUM_SIZE_32:
> + DataType = u32Node
> + elif Type == EFI_IFR_TYPE_NUM_SIZE_64:
> + DataType = u64Node
> + else:
> + DataType = u32Node
> +
> + class EFI_IFR_NUMERIC(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("Question", EFI_IFR_QUESTION_HEADER),
> + ("Flags", c_ubyte),
> + ("Data", DataType),
> + ]
> +
> + return EFI_IFR_NUMERIC()
> +
> +
> +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_ubyte), #
> + ("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),
> + ]
> +
> +
> +TypeDict = {
> + EFI_IFR_TYPE_NUM_SIZE_8: c_ubyte,
> + EFI_IFR_TYPE_NUM_SIZE_16: c_ushort,
> + EFI_IFR_TYPE_NUM_SIZE_32: c_ulong,
> + EFI_IFR_TYPE_NUM_SIZE_64: c_ulonglong,
> + EFI_IFR_TYPE_BOOLEAN: c_ubyte,
> + EFI_IFR_TYPE_TIME: EFI_HII_TIME,
> + EFI_IFR_TYPE_DATE: EFI_HII_DATE,
> + EFI_IFR_TYPE_STRING: c_uint16,
> + EFI_IFR_TYPE_REF: EFI_HII_REF,
> +}
> +
> +TypeSizeDict = {
> + EFI_IFR_TYPE_NUM_SIZE_8: 1,
> + EFI_IFR_TYPE_NUM_SIZE_16: 2,
> + EFI_IFR_TYPE_NUM_SIZE_32: 4,
> + EFI_IFR_TYPE_NUM_SIZE_64: 8,
> + EFI_IFR_TYPE_BOOLEAN: 1,
> + EFI_IFR_TYPE_STRING: 2,
> +}
> +
> +SizeTypeDict = {
> + 1: c_uint8,
> + 2: c_uint16,
> + 4: c_uint32,
> + 8: c_uint64,
> +}
> +
> +
> +def Refine_EFI_IFR_ONE_OF_OPTION(Type, Nums):
> + ValueType = TypeDict[Type]
> +
> + 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", ValueType * Nums),
> + ]
> +
> + def __init__(self) -> None:
> + self.Header = EFI_IFR_OP_HEADER()
> +
> + 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),
> + ]
> +
> + def __init__(self):
> + self.Header = EFI_IFR_OP_HEADER()
> +
> + 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(Type, Nums):
> + ValueType = TypeDict[Type]
> +
> + class EFI_IFR_DEFAULT(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("DefaultId", c_uint16),
> + ("Type", c_ubyte),
> + ("Value", ARRAY(ValueType, Nums)),
> + ]
> +
> + def __init__(self):
> + self.Header = EFI_IFR_OP_HEADER()
> +
> + 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),
> + ]
> +
> +
> +def Refine_EFI_IFR_FORM_MAP(Nums):
> + class EFI_IFR_FORM_MAP(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("FormId", c_uint16),
> + ("FormMapMethod", ARRAY(EFI_IFR_FORM_MAP_METHOD, Nums)),
> + ]
> +
> + return EFI_IFR_FORM_MAP()
> +
> +
> +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),
> + ]
> +
> +
> +class EFI_HII_STRING_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("BlockType", c_uint8),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("FontIdentifier", c_uint8),
> + ("StringText", ARRAY(c_uint8, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRINGS_SCSU_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("StringCount", c_uint16),
> + ("StringText", ARRAY(c_uint8, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("FontIdentifier", c_uint8),
> + ("StringCount", c_uint16),
> + ("StringText", ARRAY(c_uint8, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRING_UCS2_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("StringText", ARRAY(c_ushort, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("FontIdentifier", c_uint8),
> + ("StringText", ARRAY(c_ushort, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRINGS_UCS2_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("StringCount", c_uint16),
> + ("StringText", ARRAY(c_ushort, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("FontIdentifier", c_uint8),
> + ("StringCount", c_uint16),
> + ("StringText", ARRAY(c_ushort, 2)),
> + ]
> +
> +
> +class EFI_HII_SIBT_DUPLICATE_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("StringId", c_uint16),
> + ]
> +
> +
> +class EFI_HII_SIBT_EXT1_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("BlockType2", c_uint8),
> + ("Length", c_uint8),
> + ]
> +
> +
> +class EFI_HII_SIBT_EXT2_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("BlockType2", c_uint8),
> + ("Length", c_uint16),
> + ]
> +
> +
> +class EFI_HII_SIBT_EXT4_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("BlockType2", c_uint8),
> + ("Length", c_uint32),
> + ]
> +
> +
> +class EFI_HII_SIBT_SKIP1_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("SkipCount", c_uint8),
> + ]
> +
> +
> +class EFI_HII_SIBT_SKIP2_BLOCK(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_HII_STRING_BLOCK),
> + ("SkipCount", c_uint16),
> + ]
> +
> +
> +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
> +EFI_IFR_SHOWN_DEFAULTSTORE_OP = 0x65
> +
> +ConditionOps = [
> + 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",
> +]
> +
> +
> +def Refine_EFI_IFR_GUID_OPTIONKEY(Type):
> + ValueType = TypeDict[Type]
> +
> + class EFI_IFR_GUID_OPTIONKEY(Structure):
> + _pack_ = 1
> + _fields_ = [
> + ("Header", EFI_IFR_OP_HEADER),
> + ("Guid", EFI_GUID),
> + ("ExtendOpCode", c_uint8),
> + ("QuestionId", c_uint16),
> + ("OptionValue", ValueType),
> + ("KeyValue", c_uint16),
> + ]
> +
> + return EFI_IFR_GUID_OPTIONKEY()
> +
> +
> +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
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrError.py
> b/BaseTools/Source/Python/VfrCompiler/IfrError.py
> new file mode 100644
> index 0000000000..8d2eec1aae
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrError.py
> @@ -0,0 +1,153 @@
> +## @file
> +# VfrCompiler error handler.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +from enum import Enum
> +from Common import EdkLogger
> +from Common.BuildToolError import *
> +
> +
> +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_OPCO
> DE: ": Not recommend to use obsoleted framework opcode",
> + EFI_VFR_WARNING_CODE.VFR_WARNING_CODEUNDEFINED: ":
> undefined Warning Code",
> +}
> +
> +
> +class VfrErrorHandle:
> + 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=None,
> TokenValue=None):
> + if self.vfrWarningMessage is 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.value,
> + WarningMsg,
> + self.InputFileName,
> + LineNum,
> + "warning treated as error",
> + )
> + EdkLogger.warn(
> + "VfrCompiler", WarningCode.value, self.InputFileName, LineNum,
> TokenValue
> + )
> +
> + def PrintMsg(self, LineNum, MsgType="Error", ErrorMsg=None,
> TokenValue=None):
> + if MsgType == "Warning":
> + EdkLogger.verbose(ErrorMsg)
> + else:
> + EdkLogger.error(
> + "VfrCompiler", FORMAT_INVALID, ErrorMsg, self.InputFileName,
> LineNum, TokenValue
> + )
> +
> + def HandleError(self, ErrorCode, LineNum=None, TokenValue=None):
> + if self.vfrErrorMessage is None:
> + return 1
> + ErrorMsg = ""
> + for Key in self.vfrErrorMessage.keys():
> + if ErrorCode == Key:
> + ErrorMsg = self.vfrErrorMessage[Key]
> + break
> + if ErrorMsg != "":
> + EdkLogger.error(
> + "VfrCompiler", ErrorCode.value, ErrorMsg, self.InputFileName,
> LineNum, TokenValue
> + )
> + return 1
> + return 0
> +
> +
> +gVfrErrorHandle = VfrErrorHandle()
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
> b/BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
> new file mode 100644
> index 0000000000..d4de2898f5
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
> @@ -0,0 +1,2937 @@
> +## @file
> +# The definition of FormPkg's member function
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrUtility import *
> +from VfrCompiler.IfrError import VfrReturnCode
> +
> +gVfrVarDataTypeDB = VfrVarDataTypeDB()
> +gVfrDefaultStore = VfrDefaultStore()
> +gVfrDataStorage = VfrDataStorage()
> +
> +
> +class OpNode:
> + def __init__(self, Size, Scope):
> + self.Size = Size
> + self.Scope = Scope
> +
> +
> +gOpcodeSizesScopeTable = [
> + OpNode(0, 0), # EFI_IFR_INVALID - 0x00
> + OpNode(sizeof(EFI_IFR_FORM), 1), # EFI_IFR_FORM_OP
> + OpNode(sizeof(EFI_IFR_SUBTITLE), 1), # EFI_IFR_SUBTITLE_OP
> + OpNode(sizeof(EFI_IFR_TEXT), 0), # EFI_IFR_TEXT_OP
> + OpNode(sizeof(EFI_IFR_IMAGE), 0), # EFI_IFR_IMAGE_OP
> + OpNode(sizeof(EFI_IFR_ONE_OF), 1), # EFI_IFR_ONE_OF_OP - 0x05
> + OpNode(sizeof(EFI_IFR_CHECKBOX), 1), # EFI_IFR_CHECKBOX_OP
> + OpNode(sizeof(EFI_IFR_NUMERIC), 1), # EFI_IFR_NUMERIC_OP
> + OpNode(sizeof(EFI_IFR_PASSWORD), 1), # EFI_IFR_PASSWORD_OP
> + OpNode(sizeof(EFI_IFR_ONE_OF_OPTION), 0), #
> EFI_IFR_ONE_OF_OPTION_OP
> + OpNode(sizeof(EFI_IFR_SUPPRESS_IF), 1), # EFI_IFR_SUPPRESS_IF - 0x0A
> + OpNode(sizeof(EFI_IFR_LOCKED), 0), # EFI_IFR_LOCKED_OP
> + OpNode(sizeof(EFI_IFR_ACTION), 1), # EFI_IFR_ACTION_OP
> + OpNode(sizeof(EFI_IFR_RESET_BUTTON), 1), #
> EFI_IFR_RESET_BUTTON_OP
> + OpNode(sizeof(EFI_IFR_FORM_SET), 1), # EFI_IFR_FORM_SET_OP -0xE
> + OpNode(sizeof(EFI_IFR_REF), 0), # EFI_IFR_REF_OP
> + OpNode(sizeof(EFI_IFR_NO_SUBMIT_IF), 1), #
> EFI_IFR_NO_SUBMIT_IF_OP -0x10
> + OpNode(sizeof(EFI_IFR_INCONSISTENT_IF), 1), #
> EFI_IFR_INCONSISTENT_IF_OP
> + OpNode(sizeof(EFI_IFR_EQ_ID_VAL), 0), # EFI_IFR_EQ_ID_VAL_OP
> + OpNode(sizeof(EFI_IFR_EQ_ID_ID), 0), # EFI_IFR_EQ_ID_ID_OP
> + OpNode(sizeof(EFI_IFR_EQ_ID_VAL_LIST), 0), # EFI_IFR_EQ_ID_LIST_OP -
> 0x14
> + OpNode(sizeof(EFI_IFR_AND), 0), # EFI_IFR_AND_OP
> + OpNode(sizeof(EFI_IFR_OR), 0), # EFI_IFR_OR_OP
> + OpNode(sizeof(EFI_IFR_NOT), 0), # EFI_IFR_NOT_OP
> + OpNode(sizeof(EFI_IFR_RULE), 1), # EFI_IFR_RULE_OP
> + OpNode(sizeof(EFI_IFR_GRAY_OUT_IF), 1), # EFI_IFR_GRAYOUT_IF_OP -
> 0x19
> + OpNode(sizeof(EFI_IFR_DATE), 1), # EFI_IFR_DATE_OP
> + OpNode(sizeof(EFI_IFR_TIME), 1), # EFI_IFR_TIME_OP
> + OpNode(sizeof(EFI_IFR_STRING), 1), # EFI_IFR_STRING_OP
> + OpNode(sizeof(EFI_IFR_REFRESH), 0), # EFI_IFR_REFRESH_OP
> + OpNode(sizeof(EFI_IFR_DISABLE_IF), 1), # EFI_IFR_DISABLE_IF_OP - 0x1E
> + OpNode(0, 0), # 0x1F
> + OpNode(sizeof(EFI_IFR_TO_LOWER), 0), # EFI_IFR_TO_LOWER_OP - 0x20
> + OpNode(sizeof(EFI_IFR_TO_UPPER), 0), # EFI_IFR_TO_UPPER_OP - 0x21
> + OpNode(sizeof(EFI_IFR_MAP), 1), # EFI_IFR_MAP - 0x22
> + OpNode(sizeof(EFI_IFR_ORDERED_LIST), 1), # EFI_IFR_ORDERED_LIST_OP
> - 0x23
> + OpNode(sizeof(EFI_IFR_VARSTORE), 0), # EFI_IFR_VARSTORE_OP
> + OpNode(sizeof(EFI_IFR_VARSTORE_NAME_VALUE), 0), #
> EFI_IFR_VARSTORE_NAME_VALUE_OP
> + OpNode(sizeof(EFI_IFR_VARSTORE_EFI), 0), # EFI_IFR_VARSTORE_EFI_OP
> + OpNode(sizeof(EFI_IFR_VARSTORE_DEVICE), 1), #
> EFI_IFR_VARSTORE_DEVICE_OP
> + OpNode(sizeof(EFI_IFR_VERSION), 0), # EFI_IFR_VERSION_OP - 0x28
> + OpNode(sizeof(EFI_IFR_END), 0), # EFI_IFR_END_OP
> + OpNode(sizeof(EFI_IFR_MATCH), 0), # EFI_IFR_MATCH_OP - 0x2A
> + OpNode(sizeof(EFI_IFR_GET), 0), # EFI_IFR_GET - 0x2B
> + OpNode(sizeof(EFI_IFR_SET), 0), # EFI_IFR_SET - 0x2C
> + OpNode(sizeof(EFI_IFR_READ), 0), # EFI_IFR_READ - 0x2D
> + OpNode(sizeof(EFI_IFR_WRITE), 0), # EFI_IFR_WRITE - 0x2E
> + OpNode(sizeof(EFI_IFR_EQUAL), 0), # EFI_IFR_EQUAL_OP - 0x2F
> + OpNode(sizeof(EFI_IFR_NOT_EQUAL), 0), # EFI_IFR_NOT_EQUAL_OP
> + OpNode(sizeof(EFI_IFR_GREATER_THAN), 0), #
> EFI_IFR_GREATER_THAN_OP
> + OpNode(sizeof(EFI_IFR_GREATER_EQUAL), 0), #
> EFI_IFR_GREATER_EQUAL_OP
> + OpNode(sizeof(EFI_IFR_LESS_THAN), 0), # EFI_IFR_LESS_THAN_OP
> + OpNode(sizeof(EFI_IFR_LESS_EQUAL), 0), # EFI_IFR_LESS_EQUAL_OP -
> 0x34
> + OpNode(sizeof(EFI_IFR_BITWISE_AND), 0), # EFI_IFR_BITWISE_AND_OP
> + OpNode(sizeof(EFI_IFR_BITWISE_OR), 0), # EFI_IFR_BITWISE_OR_OP
> + OpNode(sizeof(EFI_IFR_BITWISE_NOT), 0), # EFI_IFR_BITWISE_NOT_OP
> + OpNode(sizeof(EFI_IFR_SHIFT_LEFT), 0), # EFI_IFR_SHIFT_LEFT_OP
> + OpNode(sizeof(EFI_IFR_SHIFT_RIGHT), 0), # EFI_IFR_SHIFT_RIGHT_OP
> + OpNode(sizeof(EFI_IFR_ADD), 0), # EFI_IFR_ADD_OP - 0x3A
> + OpNode(sizeof(EFI_IFR_SUBTRACT), 0), # EFI_IFR_SUBTRACT_OP
> + OpNode(sizeof(EFI_IFR_MULTIPLY), 0), # EFI_IFR_MULTIPLY_OP
> + OpNode(sizeof(EFI_IFR_DIVIDE), 0), # EFI_IFR_DIVIDE_OP
> + OpNode(sizeof(EFI_IFR_MODULO), 0), # EFI_IFR_MODULO_OP - 0x3E
> + OpNode(sizeof(EFI_IFR_RULE_REF), 0), # EFI_IFR_RULE_REF_OP
> + OpNode(sizeof(EFI_IFR_QUESTION_REF1), 0), #
> EFI_IFR_QUESTION_REF1_OP
> + OpNode(sizeof(EFI_IFR_QUESTION_REF2), 0), #
> EFI_IFR_QUESTION_REF2_OP - 0x41
> + OpNode(sizeof(EFI_IFR_UINT8), 0), # EFI_IFR_UINT8
> + OpNode(sizeof(EFI_IFR_UINT16), 0), # EFI_IFR_UINT16
> + OpNode(sizeof(EFI_IFR_UINT32), 0), # EFI_IFR_UINT32
> + OpNode(sizeof(EFI_IFR_UINT64), 0), # EFI_IFR_UTNT64
> + OpNode(sizeof(EFI_IFR_TRUE), 0), # EFI_IFR_TRUE_OP - 0x46
> + OpNode(sizeof(EFI_IFR_FALSE), 0), # EFI_IFR_FALSE_OP
> + OpNode(sizeof(EFI_IFR_TO_UINT), 0), # EFI_IFR_TO_UINT_OP
> + OpNode(sizeof(EFI_IFR_TO_STRING), 0), # EFI_IFR_TO_STRING_OP
> + OpNode(sizeof(EFI_IFR_TO_BOOLEAN), 0), # EFI_IFR_TO_BOOLEAN_OP
> + OpNode(sizeof(EFI_IFR_MID), 0), # EFI_IFR_MID_OP
> + OpNode(sizeof(EFI_IFR_FIND), 0), # EFI_IFR_FIND_OP
> + OpNode(sizeof(EFI_IFR_TOKEN), 0), # EFI_IFR_TOKEN_OP
> + OpNode(sizeof(EFI_IFR_STRING_REF1), 0), # EFI_IFR_STRING_REF1_OP -
> 0x4E
> + OpNode(sizeof(EFI_IFR_STRING_REF2), 0), # EFI_IFR_STRING_REF2_OP
> + OpNode(sizeof(EFI_IFR_CONDITIONAL), 0), # EFI_IFR_CONDITIONAL_OP
> + OpNode(sizeof(EFI_IFR_QUESTION_REF3), 0), #
> EFI_IFR_QUESTION_REF3_OP
> + OpNode(sizeof(EFI_IFR_ZERO), 0), # EFI_IFR_ZERO_OP
> + OpNode(sizeof(EFI_IFR_ONE), 0), # EFI_IFR_ONE_OP
> + OpNode(sizeof(EFI_IFR_ONES), 0), # EFI_IFR_ONES_OP
> + OpNode(sizeof(EFI_IFR_UNDEFINED), 0), # EFI_IFR_UNDEFINED_OP
> + OpNode(sizeof(EFI_IFR_LENGTH), 0), # EFI_IFR_LENGTH_OP
> + OpNode(sizeof(EFI_IFR_DUP), 0), # EFI_IFR_DUP_OP - 0x57
> + OpNode(sizeof(EFI_IFR_THIS), 0), # EFI_IFR_THIS_OP
> + OpNode(sizeof(EFI_IFR_SPAN), 0), # EFI_IFR_SPAN_OP
> + OpNode(sizeof(EFI_IFR_VALUE), 1), # EFI_IFR_VALUE_OP
> + OpNode(sizeof(EFI_IFR_DEFAULT), 0), # EFI_IFR_DEFAULT_OP
> + OpNode(sizeof(EFI_IFR_DEFAULTSTORE), 0), # EFI_IFR_DEFAULTSTORE_OP
> - 0x5C
> + OpNode(sizeof(EFI_IFR_FORM_MAP), 1), # EFI_IFR_FORM_MAP_OP -
> 0x5D
> + OpNode(sizeof(EFI_IFR_CATENATE), 0), # EFI_IFR_CATENATE_OP
> + OpNode(sizeof(EFI_IFR_GUID), 0), # EFI_IFR_GUID_OP
> + OpNode(sizeof(EFI_IFR_SECURITY), 0), # EFI_IFR_SECURITY_OP - 0x60
> + OpNode(sizeof(EFI_IFR_MODAL_TAG), 0), # EFI_IFR_MODAL_TAG_OP -
> 0x61
> + OpNode(sizeof(EFI_IFR_REFRESH_ID), 0), # EFI_IFR_REFRESH_ID_OP -
> 0x62
> + OpNode(sizeof(EFI_IFR_WARNING_IF), 1), # EFI_IFR_WARNING_IF_OP -
> 0x63
> + OpNode(sizeof(EFI_IFR_MATCH2), 0),
> +]
> +
> +
> +class OpBufferNode:
> + def __init__(self, Buffer=None, Next=None):
> + self.Buffer = Buffer
> + self.Next = Next
> +
> +
> +class ASSIGN_FLAG(Enum):
> + PENDING = 1
> + ASSIGNED = 2
> +
> +
> +VALUE_TYPE_ONE = 1
> +VALUE_TYPE_TWO = 2
> +
> +
> +class SPendingAssign:
> + def __init__(self, Key, ValAddr, LineNo, Msg, Type=0):
> + self.Key = Key
> + self.Addr = ValAddr
> + self.Flag = ASSIGN_FLAG.PENDING
> + self.LineNo = LineNo
> + self.Msg = Msg
> + self.Type = Type
> + self.Next = None
> +
> + def AssignValue(self, Val):
> + if self.Type == VALUE_TYPE_ONE:
> + self.Addr.QuestionId1 = Val
> + elif self.Type == VALUE_TYPE_TWO:
> + self.Addr.QuestionId2 = Val
> + else:
> + self.Addr.QuestionId = Val
> +
> + self.Flag = ASSIGN_FLAG.ASSIGNED
> +
> +
> +class InsertOpNode:
> + def __init__(self, Data, OpCode):
> + self.Data = Data
> + self.OpCode = OpCode
> +
> +
> +class FormPkg:
> + def __init__(self):
> + self.PkgLength = 0
> + self.Offset = 0
> + self.PendingAssignList = None
> +
> + def Clear(self):
> + self.PkgLength = 0
> + self.Offset = 0
> + self.PendingAssignList = None
> +
> + def BuildPkgHdr(self):
> + PkgHdr = EFI_HII_PACKAGE_HEADER()
> + PkgHdr.Type = EFI_HII_PACKAGE_FORM
> + PkgHdr.Length = self.PkgLength + sizeof(EFI_HII_PACKAGE_HEADER)
> + return PkgHdr
> +
> + def BuildPkg(self, Root):
> + if Root is None:
> + return
> + if Root.OpCode is not None and Root.OpCode !=
> EFI_IFR_SHOWN_DEFAULTSTORE_OP:
> + self.PkgLength += Root.Data.GetInfo().Header.Length
> + Root.Offset = gFormPkg.Offset
> + self.Offset += Root.Data.GetInfo().Header.Length
> + if Root.Child != []:
> + for ChildNode in Root.Child:
> + self.BuildPkg(ChildNode)
> +
> + # Get data from ctypes to bytes.
> + def StructToStream(self, Struct) -> bytes:
> + Length = sizeof(Struct)
> + P = cast(pointer(Struct), POINTER(c_char * Length))
> + return P.contents.raw
> +
> + def AssignPending(self, Key, VarAddr, LineNo, Msg, Type=0):
> + pNew = SPendingAssign(Key, VarAddr, LineNo, Msg, Type)
> + if pNew is None:
> + return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> + pNew.Next = self.PendingAssignList
> + self.PendingAssignList = pNew
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def DoPendingAssign(self, Key, Val):
> + if Key is None or Val is None:
> + return
> + pNode = self.PendingAssignList
> + while pNode is not None:
> + if pNode.Key == Key:
> + pNode.AssignValue(Val)
> + pNode = pNode.Next
> +
> + def HavePendingUnassigned(self):
> + pNode = self.PendingAssignList
> + while pNode is not None:
> + if pNode.Flag == ASSIGN_FLAG.PENDING:
> + return True
> + pNode = pNode.Next
> +
> + return False
> +
> + def PendingAssignPrintAll(self):
> + pNode = self.PendingAssignList
> + while pNode is not None:
> + if pNode.Flag == ASSIGN_FLAG.PENDING:
> + gVfrErrorHandle.PrintMsg(pNode.LineNo, "Error", pNode.Msg,
> pNode.Key)
> + pNode = pNode.Next
> +
> + def DeclarePendingQuestion(
> + self,
> + lVfrVarDataTypeDB: VfrVarDataTypeDB,
> + lVfrDataStorage: VfrDataStorage,
> + lVfrQuestionDB: VfrQuestionDB,
> + LineNo=None,
> + ):
> + # Declare all questions as Numeric in DisableIf True
> + ReturnList = []
> + GuidObj = None
> + DIObj = IfrDisableIf()
> + DIObj.SetLineNo(LineNo)
> + ReturnList.append(InsertOpNode(DIObj, EFI_IFR_DISABLE_IF_OP))
> + # TrueOpcode
> + TObj = IfrTrue(LineNo)
> + ReturnList.append(InsertOpNode(TObj, EFI_IFR_TRUE_OP))
> + pNode = self.PendingAssignList
> + while pNode is not None:
> + if pNode.Flag == ASSIGN_FLAG.PENDING:
> + Info = EFI_VARSTORE_INFO()
> + VarStr = pNode.Key
> + QId, ReturnCode = lVfrQuestionDB.RegisterQuestion(
> + None, VarStr, EFI_QUESTION_ID_INVALID, gFormPkg
> + )
> + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
> + gVfrErrorHandle.HandleError(ReturnCode, pNode.LineNo,
> pNode.Key)
> + return ReturnList, ReturnCode
> + # ifdef VFREXP_DEBUG
> + # printf("Undefined Question name is %s and Id is 0x%x\n", VarStr,
> QId);
> + # endif
> + # Get Question Info, framework vfr VarName == StructName
> + ArrayIdx, s, FName, ReturnCode =
> lVfrVarDataTypeDB.ExtractFieldNameAndArrary(
> + VarStr, 0
> + )
> + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
> + gVfrErrorHandle.PrintMsg(
> + pNode.LineNo, "Error", "Var string is not the valid C variable",
> pNode.Key
> + )
> + return ReturnList, ReturnCode
> +
> + # Get VarStoreType
> + Info.VarStoreId, ReturnCode =
> lVfrDataStorage.GetVarStoreId(FName)
> +
> + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
> + gVfrErrorHandle.PrintMsg(
> + pNode.LineNo, "Error", "Var Store Type is not defined", FName
> + )
> + return ReturnList, ReturnCode
> +
> + VarStoreType = lVfrDataStorage.GetVarStoreType(Info.VarStoreId)
> + if s == len(VarStr) and ArrayIdx != INVALID_ARRAY_INDEX:
> + ReturnCode = lVfrDataStorage.GetNameVarStoreInfo(Info,
> ArrayIdx)
> + else:
> + if VarStoreType ==
> EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
> + ReturnCode = lVfrDataStorage.GetEfiVarStoreInfo(Info)
> + elif (
> + VarStoreType ==
> EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER
> + or VarStoreType ==
> EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS
> + ):
> + VarStr = pNode.Key
> + SName, ReturnCode =
> lVfrDataStorage.GetBufferVarStoreDataTypeName(
> + Info.VarStoreId
> + )
> + if ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
> + NewStr = SName + "." + VarStr[s:]
> + (
> + Info.Info.VarOffset,
> + Info.VarType,
> + Info.VarTotalSize,
> + Info.IsBitVar,
> + ReturnCode,
> + ) = lVfrVarDataTypeDB.GetDataFieldInfo(NewStr)
> + else:
> + ReturnCode = VfrReturnCode.VFR_RETURN_UNSUPPORTED
> +
> + if ReturnCode != VfrReturnCode.VFR_RETURN_SUCCESS:
> + gVfrErrorHandle.HandleError(ReturnCode, pNode.LineNo,
> pNode.Key)
> + # If the storage is bit fields, create Guid opcode to wrap the numeric
> opcode.
> + if Info.IsBitVar:
> + GuidObj = IfrGuid(0)
> + GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
> + GuidObj.SetLineNo(LineNo)
> + ReturnList.append(InsertOpNode(GuidObj, EFI_IFR_GUID_OP))
> +
> + if Info.IsBitVar:
> + Info.VarType = EFI_IFR_TYPE_NUM_SIZE_32
> +
> + # Numeric doesn't support BOOLEAN data type.
> + # BOOLEAN type has the same data size to UINT8.
> + elif Info.VarType == EFI_IFR_TYPE_BOOLEAN:
> + Info.VarType = EFI_IFR_TYPE_NUM_SIZE_8
> +
> + CNObj = IfrNumeric(Info.VarType)
> + CNObj.SetLineNo(LineNo)
> + CNObj.SetPrompt(0x0)
> + CNObj.SetHelp(0x0)
> + CNObj.SetQuestionId(QId)
> + CNObj.SetVarStoreInfo(Info)
> + ReturnList.append(InsertOpNode(CNObj, EFI_IFR_GUID_OP))
> +
> + if Info.IsBitVar:
> + MaxValue = (1 << Info.VarTotalSize) - 1
> + CNObj.SetMinMaxStepData(0, MaxValue, 0)
> + LFlags = EDKII_IFR_NUMERIC_SIZE_BIT & Info.VarTotalSize
> + CNObj.SetFlagsForBitField(0, LFlags)
> + else:
> + CNObj.SetFlags(0, Info.VarType)
> + CNObj.SetMinMaxStepData(0, -1, 0)
> +
> + if VarStoreType ==
> EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
> + VNObj = IfrVarEqName(QId, Info.Info.VarName)
> + VNObj.SetLineNo(LineNo)
> + ReturnList.append(InsertOpNode(VNObj, EFI_IFR_GUID_OP))
> +
> + CEObj = IfrEnd()
> + CEObj.SetLineNo(LineNo)
> + ReturnList.append(InsertOpNode(CEObj, EFI_IFR_END_OP))
> +
> + if GuidObj is not None:
> + CEObjGuid = IfrEnd()
> + CEObjGuid.SetLineNo(LineNo)
> + ReturnList.append(InsertOpNode(CEObjGuid, EFI_IFR_END_OP))
> + GuidObj.SetScope(1)
> + GuidObj = None
> + pNode = pNode.Next
> +
> + SEObj = IfrEnd()
> + SEObj.SetLineNo(LineNo)
> + ReturnList.append(InsertOpNode(SEObj, EFI_IFR_END_OP))
> + return ReturnList, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> +
> +gFormPkg = FormPkg()
> +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",
> +]
> +
> +gScopeCount = 0
> +gIsOrderedList = False
> +gIsStringOp = False
> +gCurrentMinMaxData = None
> +
> +
> +class IfrLine:
> + def __init__(self, LineNo=0):
> + self.LineNo = LineNo
> +
> + def SetLineNo(self, LineNo):
> + self.LineNo = LineNo
> +
> + def GetLineNo(self):
> + return self.LineNo
> +
> +
> +class IfrBaseInfo:
> + def __init__(self, Obj=None, QName=None, VarIdStr=""):
> + self.Obj = Obj
> + self.QName = QName
> + self.VarIdStr = VarIdStr
> +
> + self.FlagsStream = ""
> + self.HasKey = False
> + self.HasQuestionId = False
> +
> + def SetQName(self, QName):
> + self.QName = QName
> +
> + def SetVarIdStr(self, VarIdStr):
> + self.VarIdStr = VarIdStr
> +
> + def SetFlagsStream(self, FlagsStream):
> + self.FlagsStream = FlagsStream
> +
> + def SetHasKey(self, HasKey):
> + self.HasKey = HasKey
> +
> + def SetHasQuestionId(self, HasQuestionId):
> + self.HasQuestionId = HasQuestionId
> +
> + def GetInfo(self):
> + return self.Obj
> +
> +
> +class IfrOpHeader:
> + def __init__(self, OpHeader: EFI_IFR_OP_HEADER, OpCode=None,
> Length=0):
> + self.OpHeader = OpHeader
> + if OpCode is not 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 UpdateHeader(self, Header):
> + self.OpHeader = Header
> +
> + def IncLength(self, Size):
> + self.OpHeader.Length += Size
> +
> + def DecLength(self, Size):
> + self.OpHeader.Length -= Size
> +
> + def AdjustLength(self, BeforeSize, AfterSize):
> + self.OpHeader.Length -= BeforeSize
> + self.OpHeader.Length += AfterSize
> + self.OpHeader.Length += 1
> +
> + def GetOpCode(self):
> + return self.OpHeader.OpCode
> +
> +
> +class IfrStatementHeader:
> + 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 IfrMinMaxStepData:
> + def __init__(self, MinMaxStepData, NumericOpcode=False):
> + self.MinMaxStepData = MinMaxStepData
> + self.MinMaxStepData.MinValue = 0
> + self.MinMaxStepData.MaxValue = 0
> + self.MinMaxStepData.Step = 0
> + self.ValueIsSet = False
> + self.IsNumeric = NumericOpcode
> +
> + def SetMinMaxStepData(self, MinValue, MaxValue, Step):
> + if self.ValueIsSet == False:
> + self.MinMaxStepData.MinValue = MinValue
> + self.MinMaxStepData.MaxValue = MaxValue
> + self.MinMaxStepData.Step = Step
> +
> + self.ValueIsSet = True
> + else:
> + if MinValue < self.MinMaxStepData.MinValue:
> + self.MinMaxStepData.MinValue = MinValue
> + if MaxValue > self.MinMaxStepData.MaxValue:
> + self.MinMaxStepData.MaxValue = MaxValue
> + self.MinMaxStepData.Step = Step
> +
> + def IsNumericOpcode(self):
> + return self.IsNumeric
> +
> + def UpdateIfrMinMaxStepData(self, MinMaxStepData):
> + self.MinMaxStepData = MinMaxStepData
> +
> + def GetMinData(self):
> + return self.MinMaxStepData.MinValue
> +
> + def GetMaxData(self):
> + return self.MinMaxStepData.MaxValue
> +
> + def GetStepData(self):
> + return self.MinMaxStepData.Step
> +
> +
> +class IfrFormSet(IfrLine, IfrOpHeader):
> + def __init__(self, Size):
> + self.FormSet = EFI_IFR_FORM_SET()
> + self.ClassGuid = []
> + IfrOpHeader.__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.ClassGuidNum = 0
> +
> + 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 SetClassGuidNum(self, Num):
> + self.ClassGuidNum = Num
> +
> + def GetInfo(self):
> + return self.FormSet
> +
> +
> +class IfrOneOfOption(IfrLine, IfrOpHeader):
> + def __init__(self, ValueType, ValueList):
> + Nums = len(ValueList)
> + self.OneOfOption = Refine_EFI_IFR_ONE_OF_OPTION(ValueType, Nums)
> + IfrOpHeader.__init__(
> + self, self.OneOfOption.Header, EFI_IFR_ONE_OF_OPTION_OP,
> sizeof(self.OneOfOption)
> + )
> + self.OneOfOption.Flags = 0
> + self.OneOfOption.Option = EFI_STRING_ID_INVALID
> + self.OneOfOption.Type = EFI_IFR_TYPE_OTHER
> + self.ValueType = ValueType
> + if ValueList != []:
> + ArrayType = TypeDict[ValueType] * Nums
> + ValueArray = ArrayType()
> + for i in range(0, len(ValueList)):
> + ValueArray[i] = ValueList[i]
> + self.OneOfOption.Value = ValueArray
> +
> + self.IfrOptionKey = None
> + self.FlagsStream = ""
> + self.ValueStream = ""
> +
> + def SetOption(self, Option):
> + self.OneOfOption.Option = Option
> +
> + def SetType(self, Type):
> + self.OneOfOption.Type = Type
> +
> + def SetIfrOptionKey(self, IfrOptionKey):
> + self.IfrOptionKey = IfrOptionKey
> +
> + def SetFlagsStream(self, FlagsStream):
> + self.FlagsStream = FlagsStream
> +
> + def SetValueStream(self, ValueStream):
> + self.ValueStream = ValueStream
> +
> + def GetValueType(self):
> + return self.ValueType
> +
> + def SetValue(self, ValueList):
> + ArrayType = TypeDict[self.ValueType] * (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 IfrOptionKey(IfrLine, IfrOpHeader):
> + def __init__(self, QuestionId, Type, OptionValue, KeyValue):
> + self.OptionKey = Refine_EFI_IFR_GUID_OPTIONKEY(Type)
> + IfrOpHeader.__init__(self, self.OptionKey.Header, EFI_IFR_GUID_OP,
> sizeof(self.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 IfrClass(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Class = EFI_IFR_GUID_CLASS() # static guid
> + IfrOpHeader.__init__(self, self.Class.Header, EFI_IFR_GUID_OP,
> 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
> +
> + self.HasSubClass = False
> + self.ClassStr = None
> +
> + def SetClass(self, Class):
> + self.Class.Class = Class
> +
> + def SetClassStr(self, ClassStr):
> + self.ClassStr = ClassStr
> +
> + def GetInfo(self):
> + return self.Class
> +
> +
> +class IfrSubClass(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.SubClass = EFI_IFR_GUID_SUBCLASS()
> + IfrOpHeader.__init__(
> + self, self.SubClass.Header, EFI_IFR_GUID_OP,
> 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
> +
> + self.SubClassStr = None
> +
> + def SetSubClass(self, SubClass):
> + self.SubClass.SubClass = SubClass
> +
> + def SetSubClassStr(self, SubClassStr):
> + self.SubClassStr = SubClassStr
> +
> + def GetInfo(self):
> + return self.SubClass
> +
> +
> +class IfrDefaultStore(IfrLine, IfrOpHeader):
> + def __init__(self, TypeName=None):
> + self.DefaultStore = EFI_IFR_DEFAULTSTORE()
> + IfrOpHeader.__init__(self, self.DefaultStore.Header,
> EFI_IFR_DEFAULTSTORE_OP)
> + self.DefaultStore.DefaultName = EFI_STRING_ID_INVALID
> + self.DefaultStore.DefaultId = EFI_VARSTORE_ID_INVALID
> + self.Type = TypeName
> + self.HasAttr = False
> +
> + def SetDefaultName(self, DefaultName):
> + self.DefaultStore.DefaultName = DefaultName
> +
> + def SetType(self, Type):
> + self.Type = Type
> +
> + def SetDefaultId(self, DefaultId):
> + self.DefaultStore.DefaultId = DefaultId
> +
> + def SetDefaultStore(self, DefaultStore: EFI_IFR_DEFAULTSTORE):
> + self.DefaultStore = DefaultStore
> + IfrOpHeader.__init__(self, self.DefaultStore.Header,
> EFI_IFR_DEFAULTSTORE_OP)
> +
> + def GetDefaultId(self):
> + return self.DefaultStore.DefaultId
> +
> + def GetInfo(self):
> + return self.DefaultStore
> +
> +
> +class IfrVarStore(IfrLine, IfrOpHeader):
> + def __init__(self, TypeName, StoreName):
> + Nums = len(StoreName)
> + self.Varstore = Refine_EFI_IFR_VARSTORE(Nums)
> + IfrOpHeader.__init__(
> + self, self.Varstore.Header, EFI_IFR_VARSTORE_OP, sizeof(self.Varstore)
> + 1
> + )
> + self.Varstore.VarStoreId = EFI_VARSTORE_ID_INVALID
> + self.Varstore.Size = 0
> + ArrayType = c_ubyte * (Nums)
> + ValueArray = ArrayType()
> + for i in range(0, Nums):
> + ValueArray[i] = ord(StoreName[i])
> + self.Varstore.Name = ValueArray
> +
> + # info saved for yaml generation
> + self.Type = TypeName
> + self.HasVarStoreId = False
> +
> + 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 SetHasVarStoreId(self, HasVarStoreId):
> + self.HasVarStoreId = HasVarStoreId
> +
> + def GetInfo(self):
> + return self.Varstore
> +
> +
> +class IfrVarStoreEfi(IfrLine, IfrOpHeader):
> + def __init__(self, TypeName, StoreName):
> + Nums = len(StoreName)
> + self.VarStoreEfi = Refine_EFI_IFR_VARSTORE_EFI(Nums)
> + IfrOpHeader.__init__(
> + self, self.VarStoreEfi.Header, EFI_IFR_VARSTORE_EFI_OP,
> sizeof(self.VarStoreEfi) + 1
> + )
> + self.VarStoreEfi.VarStoreId = EFI_VAROFFSET_INVALID
> + self.VarStoreEfi.Size = 0
> + ArrayType = c_ubyte * (Nums)
> + ValueArray = ArrayType()
> + for i in range(0, Nums):
> + ValueArray[i] = ord(StoreName[i])
> + self.VarStoreEfi.Name = ValueArray
> +
> + # info saved for yaml generation
> + self.Type = TypeName
> + self.HasVarStoreId = False
> + self.AttributesText = None
> + self.NameStringId = None
> + self.VarSize = None
> +
> + def SetGuid(self, Guid):
> + self.VarStoreEfi.Guid = Guid
> +
> + def SetSize(self, Size):
> + self.VarStoreEfi.Size = Size
> +
> + def SetNameStringId(self, NameStringId):
> + self.NameStringId = NameStringId
> +
> + def SetVarSize(self, VarSize):
> + self.VarSize = VarSize
> +
> + def SetVarStoreId(self, VarStoreId):
> + self.VarStoreEfi.VarStoreId = VarStoreId
> +
> + def SetAttributes(self, Attributes):
> + self.VarStoreEfi.Attributes = Attributes
> +
> + def SetHasVarStoreId(self, HasVarStoreId):
> + self.HasVarStoreId = HasVarStoreId
> +
> + def SetAttributesText(self, AttributesText):
> + self.AttributesText = AttributesText
> +
> + def GetInfo(self):
> + return self.VarStoreEfi
> +
> +
> +class IfrVarStoreNameValue(IfrLine, IfrOpHeader):
> + def __init__(self, TypeName):
> + self.VarStoreNameValue = EFI_IFR_VARSTORE_NAME_VALUE()
> + IfrOpHeader.__init__(self, self.VarStoreNameValue.Header,
> EFI_IFR_VARSTORE_NAME_VALUE_OP)
> + self.VarStoreNameValue.VarStoreId = EFI_VAROFFSET_INVALID
> +
> + self.Type = TypeName
> + self.NameItemList = []
> + self.HasVarStoreId = False
> +
> + def SetGuid(self, Guid):
> + self.VarStoreNameValue.Guid = Guid
> +
> + def SetVarStoreId(self, VarStoreId):
> + self.VarStoreNameValue.VarStoreId = VarStoreId
> +
> + def SetNameItemList(self, NameItem):
> + self.NameItemList.append(NameItem)
> +
> + def SetHasVarStoreId(self, HasVarStoreId):
> + self.HasVarStoreId = HasVarStoreId
> +
> + 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 IfrFormId:
> + def __init__(self):
> + self.FormIdBitMap = []
> + for _ in range(0, EFI_FREE_FORM_ID_BITMAP_SIZE):
> + self.FormIdBitMap.append(0)
> +
> + def Clear(self):
> + self.FormIdBitMap = []
> + for _ in range(0, EFI_FREE_FORM_ID_BITMAP_SIZE):
> + self.FormIdBitMap.append(0)
> +
> + def CheckFormIdFree(self, FormId):
> + Index = int(FormId / EFI_BITS_PER_UINT32)
> + Offset = FormId % EFI_BITS_PER_UINT32
> +
> + return (self.FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0
> +
> + def MarkFormIdUsed(self, FormId):
> + Index = int(FormId / EFI_BITS_PER_UINT32)
> + Offset = FormId % EFI_BITS_PER_UINT32
> + self.FormIdBitMap[Index] |= 0x80000000 >> Offset
> +
> +
> +gIfrFormId = IfrFormId()
> +
> +
> +class IfrForm(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.Form = EFI_IFR_FORM()
> + IfrOpHeader.__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 gIfrFormId.CheckFormIdFree(FormId) == False:
> + return VfrReturnCode.VFR_RETURN_FORMID_REDEFINED
> + self.Form.FormId = FormId
> + gIfrFormId.MarkFormIdUsed(FormId)
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def SetFormTitle(self, FormTitle):
> + self.Form.FormTitle = FormTitle
> +
> + def GetInfo(self):
> + return self.Form
> +
> +
> +class IfrFormMap(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.FormMap = EFI_IFR_FORM_MAP()
> + self.MethodMapList = []
> + IfrOpHeader.__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 gIfrFormId.CheckFormIdFree(FormId) == False:
> + return VfrReturnCode.VFR_RETURN_FORMID_REDEFINED
> + self.FormMap.FormId = FormId
> + gIfrFormId.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
> +
> + def GetMethodMapList(self):
> + return self.MethodMapList
> +
> +
> +class IfrEnd(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.End = EFI_IFR_END()
> + IfrOpHeader.__init__(self, self.End.Header, EFI_IFR_END_OP)
> +
> + def GetInfo(self):
> + return self.End
> +
> +
> +class IfrBanner(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Banner = EFI_IFR_GUID_BANNER()
> + IfrOpHeader.__init__(self, self.Banner.Header, EFI_IFR_GUID_OP,
> sizeof(EFI_IFR_GUID_BANNER))
> + self.Banner.ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER
> + self.Banner.Guid = EFI_IFR_TIANO_GUID
> +
> + self.HasTimeOut = False
> + self.TimeOut = None
> +
> + 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 SetHasTimeOut(self, HasTimeOut):
> + self.HasTimeOut = HasTimeOut
> +
> + def SetTimeOut(self, TimeOut):
> + self.TimeOut = TimeOut
> +
> + def GetInfo(self):
> + return self.Banner
> +
> +
> +class IfrVarEqName(IfrLine, IfrOpHeader):
> + def __init__(self, QuestionId, NameId):
> + self.VarEqName = EFI_IFR_GUID_VAREQNAME()
> + IfrOpHeader.__init__(
> + self, self.VarEqName.Header, EFI_IFR_GUID_OP,
> sizeof(EFI_IFR_GUID_VAREQNAME)
> + )
> + self.VarEqName.ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME
> + self.VarEqName.Guid = EFI_IFR_FRAMEWORK_GUID
> + self.VarEqName.QuestionId = QuestionId
> + self.VarEqName.NameId = NameId
> +
> + def GetInfo(self):
> + return self.VarEqName
> +
> +
> +class IfrTimeout(IfrLine, IfrOpHeader):
> + def __init__(self, Timeout=0):
> + self.Timeout = EFI_IFR_GUID_TIMEOUT()
> + IfrOpHeader.__init__(
> + self, self.Timeout.Header, EFI_IFR_GUID_OP,
> 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 IfrLabel(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Label = EFI_IFR_GUID_LABEL()
> + IfrOpHeader.__init__(self, self.Label.Header, EFI_IFR_GUID_OP,
> 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 IfrRule(IfrLine, IfrOpHeader):
> + def __init__(self, RuleName=None):
> + self.Rule = EFI_IFR_RULE()
> + self.RuleName = RuleName
> + IfrOpHeader.__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 GetRuleName(self):
> + return self.RuleName
> +
> + def SetRuleName(self, RuleName):
> + self.RuleName = RuleName
> +
> + 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 IfrSubtitle(IfrLine, IfrOpHeader, IfrStatementHeader):
> + def __init__(
> + self,
> + ):
> + self.Subtitle = EFI_IFR_SUBTITLE()
> +
> + IfrOpHeader.__init__(self, self.Subtitle.Header, EFI_IFR_SUBTITLE_OP)
> + IfrStatementHeader.__init__(self, self.Subtitle.Statement)
> + self.Subtitle.Flags = 0
> +
> + self.FlagsStream = ""
> +
> + 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 SetFlagsStream(self, FlagsStream):
> + self.FlagsStream = FlagsStream
> +
> + def GetInfo(self):
> + return self.Subtitle
> +
> +
> +class IfrImage(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Image = EFI_IFR_IMAGE()
> + IfrOpHeader.__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 IfrLocked(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Lock = EFI_IFR_LOCKED()
> + IfrOpHeader.__init__(self, self.Lock.Header, EFI_IFR_LOCKED_OP)
> +
> + def GetInfo(self):
> + return self.Lock
> +
> +
> +class IfrModal(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Modal = EFI_IFR_MODAL_TAG()
> + IfrOpHeader.__init__(self, self.Modal.Header, EFI_IFR_MODAL_TAG_OP)
> +
> + def GetInfo(self):
> + return self.Modal
> +
> +
> +EFI_IFR_QUESTION_FLAG_DEFAULT = 0
> +
> +
> +class IfrQuestionHeader(IfrStatementHeader):
> + def __init__(self, QHeader, Flags=EFI_IFR_QUESTION_FLAG_DEFAULT):
> + self.QHeader = QHeader
> + IfrStatementHeader.__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):
> + Info.VarStoreId = self.QHeader.VarStoreId
> + Info.VarStoreInfo = self.QHeader.VarStoreInfo
> + return Info
> +
> + def GetQFlags(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 UpdateIfrQuestionHeader(self, qHeader):
> + self.QHeader = qHeader
> +
> +
> +class IfrRef(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Ref = EFI_IFR_REF()
> + IfrBaseInfo.__init__(self, self.Ref, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Ref.Header, EFI_IFR_REF_OP)
> + IfrQuestionHeader.__init__(self, self.Ref.Question)
> + self.Ref.FormId = 0
> +
> + def SetFormId(self, FormId):
> + self.Ref.FormId = FormId
> +
> +
> +class IfrRef2(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Ref2 = EFI_IFR_REF2()
> + IfrBaseInfo.__init__(self, self.Ref2, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Ref2.Header, EFI_IFR_REF_OP,
> sizeof(EFI_IFR_REF2))
> + IfrQuestionHeader.__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 SetQId(self, QuestionId):
> + self.Ref2.QuestionId = QuestionId
> +
> +
> +class IfrRef3(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Ref3 = EFI_IFR_REF3()
> + IfrBaseInfo.__init__(self, self.Ref3, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Ref3.Header, EFI_IFR_REF_OP,
> sizeof(EFI_IFR_REF3))
> + IfrQuestionHeader.__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 SetQId(self, QuestionId):
> + self.Ref3.QuestionId = QuestionId
> +
> + def SetFormSetId(self, FormSetId):
> + self.Ref3.FormSetId = FormSetId
> +
> +
> +class IfrRef4(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Ref4 = EFI_IFR_REF4()
> + IfrBaseInfo.__init__(self, self.Ref4, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Ref4.Header, EFI_IFR_REF_OP,
> sizeof(EFI_IFR_REF4))
> + IfrQuestionHeader.__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 SetQId(self, QuestionId):
> + self.Ref4.QuestionId = QuestionId
> +
> + def SetFormSetId(self, FormSetId):
> + self.Ref4.FormSetId = FormSetId
> +
> + def SetDevicePath(self, DevicePath):
> + self.Ref4.DevicePath = DevicePath
> +
> +
> +class IfrRef5(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Ref5 = EFI_IFR_REF5()
> + IfrBaseInfo.__init__(self, self.Ref5, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Ref5.Header, EFI_IFR_REF_OP,
> sizeof(EFI_IFR_REF5))
> + IfrQuestionHeader.__init__(self, self.Ref5.Question)
> +
> +
> +class IfrAction(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Action = EFI_IFR_ACTION()
> + IfrBaseInfo.__init__(self, self.Action, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Action.Header, EFI_IFR_ACTION_OP)
> + IfrQuestionHeader.__init__(self, self.Action.Question)
> + self.Action.QuestionConfig = EFI_STRING_ID_INVALID
> +
> + def SetQuestionConfig(self, QuestionConfig):
> + self.Action.QuestionConfig = QuestionConfig
> +
> +
> +class IfrText(IfrLine, IfrOpHeader, IfrStatementHeader):
> + def __init__(
> + self,
> + ):
> + self.Text = EFI_IFR_TEXT()
> + IfrOpHeader.__init__(self, self.Text.Header, EFI_IFR_TEXT_OP)
> + IfrStatementHeader.__init__(self, self.Text.Statement)
> + self.Text.TextTwo = EFI_STRING_ID_INVALID
> + self.HasTextTwo = False
> +
> + def SetTextTwo(self, StringId):
> + self.Text.TextTwo = StringId
> +
> + def SetHasTextTwo(self, Flag):
> + self.HasTextTwo = Flag
> +
> + def GetInfo(self):
> + return self.Text
> +
> +
> +class IfrGuid(IfrLine, IfrOpHeader):
> + def __init__(self, Size, Data=None):
> + self.Guid = EFI_IFR_GUID()
> + self.Data = Data # databuffer is saved here
> + IfrOpHeader.__init__(self, self.Guid.Header, EFI_IFR_GUID_OP,
> 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, Data):
> + self.Data = Data
> +
> + def GetData(self):
> + return self.Data
> +
> + def GetInfo(self): #
> + return self.Guid
> +
> +
> +class IfrExtensionGuid(IfrLine, IfrOpHeader):
> + def __init__(self, Size=0, TypeName="", ArraySize=0, Data=None):
> + self.Guid = EFI_IFR_GUID()
> + if ArraySize != 0:
> + self.DataType = TypeName + "[" + str(ArraySize) + "]"
> + else:
> + self.DataType = TypeName
> + self.FieldList = []
> + self.Data = Data
> + IfrOpHeader.__init__(self, self.Guid.Header, EFI_IFR_GUID_OP,
> 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, Data):
> + self.Data = Data
> +
> + def GetDataType(self):
> + return self.DataType
> +
> + def GetFieldList(self):
> + return self.FieldList
> +
> + def SetFieldList(self, TFName, TFValue):
> + self.FieldList.append([TFName, TFValue])
> +
> + def GetData(self):
> + return self.Data
> +
> + def GetInfo(self): #
> + return self.Guid
> +
> +
> +class IfrOrderedList(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.OrderedList = EFI_IFR_ORDERED_LIST()
> + IfrBaseInfo.__init__(self, self.OrderedList, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.OrderedList.Header,
> EFI_IFR_ORDERED_LIST_OP)
> + IfrQuestionHeader.__init__(self, self.OrderedList.Question)
> + self.OrderedList.MaxContainers = 0
> + self.OrderedList.Flags = 0
> +
> + self.HasMaxContainers = False
> +
> + def GetQuestion(self):
> + return self
> +
> + def SetQHeaderFlags(self, Flags):
> + IfrQuestionHeader.SetFlags(self, Flags)
> +
> + def SetMaxContainers(self, MaxContainers):
> + self.OrderedList.MaxContainers = MaxContainers
> +
> + def SetHasMaxContainers(self, HasMaxContainers):
> + self.HasMaxContainers = HasMaxContainers
> +
> + def SetFlags(self, HFlags, LFlags):
> + ReturnCode = IfrQuestionHeader.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
> + )
> +
> +
> +class IfrString(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Str = EFI_IFR_STRING()
> + IfrBaseInfo.__init__(self, self.Str, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Str.Header, EFI_IFR_STRING_OP)
> + IfrQuestionHeader.__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):
> + IfrQuestionHeader.SetFlags(self, Flags)
> +
> + def SetFlags(self, HFlags, LFlags):
> + ReturnCode = IfrQuestionHeader.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
> +
> +
> +class IfrPassword(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Password = EFI_IFR_PASSWORD()
> + IfrBaseInfo.__init__(self, self.Password, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Password.Header,
> EFI_IFR_PASSWORD_OP)
> + IfrQuestionHeader.__init__(self, self.Password.Question)
> + self.Password.MinSize = 0
> + self.Password.MaxSize = 0
> +
> + def GetQuestion(self):
> + return self
> +
> + def SetQHeaderFlags(self, Flags):
> + IfrQuestionHeader.SetFlags(self, Flags)
> +
> + def SetMinSize(self, MinSize):
> + self.Password.MinSize = MinSize
> +
> + def SetMaxSize(self, MaxSize):
> + self.Password.MaxSize = MaxSize
> +
> +
> +class IfrDefault(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ValueType,
> + ValueList,
> + DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD,
> + Type=EFI_IFR_TYPE_OTHER,
> + ):
> + Nums = len(ValueList)
> + self.Default = Refine_EFI_IFR_DEFAULT(ValueType, Nums)
> + IfrOpHeader.__init__(self, self.Default.Header, EFI_IFR_DEFAULT_OP,
> sizeof(self.Default))
> + self.Default.Type = Type
> + self.Default.DefaultId = DefaultId
> +
> + self.ValueType = ValueType
> + self.DefaultStore = ""
> + self.ValueStream = ""
> +
> + if ValueList != []:
> + ArrayType = TypeDict[ValueType] * 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 = TypeDict[self.ValueType] * (len(ValueList))
> + ValueArray = ArrayType()
> + for i in range(0, len(ValueList)):
> + ValueArray[i] = ValueList[i]
> + self.Default.Value = ValueArray
> +
> + def SetDefaultStore(self, DefaultStore):
> + self.DefaultStore = DefaultStore
> +
> + def SetValueStream(self, ValueStream):
> + self.ValueStream = ValueStream
> +
> + def GetInfo(self):
> + return self.Default
> +
> +
> +class IfrDefault2(IfrLine, IfrOpHeader):
> + def __init__(self, DefaultId=EFI_HII_DEFAULT_CLASS_STANDARD,
> Type=EFI_IFR_TYPE_OTHER):
> + self.Default = EFI_IFR_DEFAULT_2()
> + IfrOpHeader.__init__(
> + self, self.Default.Header, EFI_IFR_DEFAULT_OP,
> sizeof(EFI_IFR_DEFAULT_2)
> + )
> + self.Default.Type = Type
> + self.Default.DefaultId = DefaultId
> +
> + self.DefaultStore = ""
> +
> + def SetDefaultId(self, DefaultId):
> + self.Default.DefaultId = DefaultId
> +
> + def SetType(self, Type):
> + self.Default.Type = Type
> +
> + def SetDefaultStore(self, DefaultStore):
> + self.DefaultStore = DefaultStore
> +
> + def GetInfo(self):
> + return self.Default
> +
> +
> +class IfrInconsistentIf(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.InconsistentIf = EFI_IFR_INCONSISTENT_IF()
> + IfrOpHeader.__init__(self, self.InconsistentIf.Header,
> EFI_IFR_INCONSISTENT_IF_OP)
> + self.InconsistentIf.Error = EFI_STRING_ID_INVALID
> + self.FlagsStream = ""
> +
> + def SetError(self, Error):
> + self.InconsistentIf.Error = Error
> +
> + def SetFlagsStream(self, Flag):
> + self.FlagsStream = Flag
> +
> + def GetInfo(self):
> + return self.InconsistentIf
> +
> +
> +class IfrInconsistentIf2(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.InconsistentIf = EFI_IFR_INCONSISTENT_IF()
> + IfrOpHeader.__init__(self, self.InconsistentIf.Header,
> EFI_IFR_INCONSISTENT_IF_OP)
> + self.InconsistentIf.Error = EFI_STRING_ID_INVALID
> + self.FlagsStream = ""
> +
> + def SetError(self, Error):
> + self.InconsistentIf.Error = Error
> +
> + def SetFlagsStream(self, Flag):
> + self.FlagsStream = Flag
> +
> + def GetInfo(self):
> + return self.InconsistentIf
> +
> +
> +class IfrNoSubmitIf(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.NoSubmitIf = EFI_IFR_NO_SUBMIT_IF()
> + IfrOpHeader.__init__(self, self.NoSubmitIf.Header,
> EFI_IFR_NO_SUBMIT_IF_OP)
> + self.NoSubmitIf.Error = EFI_STRING_ID_INVALID
> +
> + self.FlagsStream = ""
> +
> + def SetError(self, Error):
> + self.NoSubmitIf.Error = Error
> +
> + def SetFlagsStream(self, Flag):
> + self.FlagsStream = Flag
> +
> + def GetInfo(self):
> + return self.NoSubmitIf
> +
> +
> +class IfrDisableIf(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.DisableIf = EFI_IFR_DISABLE_IF()
> + IfrOpHeader.__init__(self, self.DisableIf.Header,
> EFI_IFR_DISABLE_IF_OP)
> +
> + def GetInfo(self):
> + return self.DisableIf
> +
> +
> +class IfrSuppressIf(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.SuppressIf = EFI_IFR_SUPPRESS_IF()
> + IfrOpHeader.__init__(self, self.SuppressIf.Header,
> EFI_IFR_SUPPRESS_IF_OP)
> +
> + def GetInfo(self):
> + return self.SuppressIf
> +
> +
> +class IfrGrayOutIf(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.GrayOutIf = EFI_IFR_GRAY_OUT_IF()
> + IfrOpHeader.__init__(self, self.GrayOutIf.Header,
> EFI_IFR_GRAY_OUT_IF_OP)
> +
> + def GetInfo(self):
> + return self.GrayOutIf
> +
> +
> +class IfrValue(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.Value = EFI_IFR_VALUE()
> + IfrOpHeader.__init__(self, self.Value.Header, EFI_IFR_VALUE_OP)
> +
> + def GetInfo(self):
> + return self.Value
> +
> +
> +class IfrRead(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.Read = EFI_IFR_READ()
> + IfrOpHeader.__init__(self, self.Read.Header, EFI_IFR_READ_OP)
> +
> + def GetInfo(self):
> + return self.Read
> +
> +
> +class IfrWrite(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.Write = EFI_IFR_WRITE()
> + IfrOpHeader.__init__(self, self.Write.Header, EFI_IFR_WRITE_OP)
> +
> + def GetInfo(self):
> + return self.Write
> +
> +
> +class IfrWarningIf(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.WarningIf = EFI_IFR_WARNING_IF()
> + IfrOpHeader.__init__(self, self.WarningIf.Header,
> EFI_IFR_WARNING_IF_OP)
> + self.WarningIf.Warning = EFI_STRING_ID_INVALID
> + self.WarningIf.TimeOut = 0
> +
> + self.HasTimeOut = False
> +
> + def SetWarning(self, WarnMessage):
> + self.WarningIf.Warning = WarnMessage
> +
> + def SetHasHasTimeOut(self, HasTimeOut):
> + self.HasTimeOut = HasTimeOut
> +
> + def SetTimeOut(self, TimeOut):
> + self.WarningIf.TimeOut = TimeOut
> +
> + def GetInfo(self):
> + return self.WarningIf
> +
> +
> +class IfrRefresh(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.Refresh = EFI_IFR_REFRESH()
> + IfrOpHeader.__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 IfrRefreshId(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.RefreshId = EFI_IFR_REFRESH_ID()
> + IfrOpHeader.__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 IfrVarStoreDevice(IfrLine, IfrOpHeader):
> + def __init__(self):
> + self.VarStoreDevice = EFI_IFR_VARSTORE_DEVICE()
> + IfrOpHeader.__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 IfrDate(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Date = EFI_IFR_DATE()
> + IfrBaseInfo.__init__(self, self.Date, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Date.Header, EFI_IFR_DATE_OP)
> + IfrQuestionHeader.__init__(self, self.Date.Question)
> + self.Date.Flags = 0
> +
> + self.Year = None
> + self.Month = None
> + self.Day = None
> +
> + self.D_Year = None
> + self.D_Month = None
> + self.D_Day = None
> + self.Step = None
> + self.Min = None
> + self.Max = None
> +
> + def SetFlags(self, HFlags, LFlags):
> + ReturnCode = IfrQuestionHeader.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
> + )
> +
> +
> +class IfrTime(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.Time = EFI_IFR_TIME()
> + IfrBaseInfo.__init__(self, self.Time, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Time.Header, EFI_IFR_TIME_OP)
> + IfrQuestionHeader.__init__(self, self.Time.Question)
> + self.Time.Flags = 0
> +
> + self.Hour = None
> + self.Minute = None
> + self.Second = None
> +
> + self.D_Hour = None
> + self.D_Minute = None
> + self.D_Second = None
> +
> + self.Step = None
> + self.Min = None
> + self.Max = None
> +
> + def SetHour(self, Hour):
> + self.Hour = Hour
> +
> + def SetMinute(self, Minute):
> + self.Minute = Minute
> +
> + def SetSecond(self, Second):
> + self.Second = Second
> +
> + def SetFlags(self, HFlags, LFlags):
> + ReturnCode = IfrQuestionHeader.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
> + )
> +
> +
> +class IfrNumeric(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader,
> IfrMinMaxStepData):
> + def __init__(self, Type, QName=None, VarIdStr=""):
> + self.Numeric = Refine_EFI_IFR_NUMERIC(Type)
> + IfrBaseInfo.__init__(self, self.Numeric, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.Numeric.Header, EFI_IFR_NUMERIC_OP,
> sizeof(self.Numeric))
> + IfrQuestionHeader.__init__(self, self.Numeric.Question)
> + IfrMinMaxStepData.__init__(self, self.Numeric.Data, True)
> + self.Numeric.Flags = EFI_IFR_NUMERIC_SIZE_1 |
> EFI_IFR_DISPLAY_UINT_DEC
> +
> + self.HasStep = False
> +
> + def GetQuestion(self):
> + return self
> +
> + def GetMinMaxData(self):
> + return self
> +
> + def SetQHeaderFlags(self, Flags):
> + IfrQuestionHeader.SetFlags(self, Flags)
> +
> + def SetFlags(self, HFlags, LFlags, DisplaySettingsSpecified=False):
> + ReturnCode = IfrQuestionHeader.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 = IfrQuestionHeader.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 SetHasStep(self, HasStep):
> + self.HasStep = HasStep
> +
> +
> +class IfrOneOf(IfrQuestionHeader, IfrLine, IfrBaseInfo, IfrOpHeader,
> IfrMinMaxStepData):
> + def __init__(self, Type, QName=None, VarIdStr=""):
> + self.OneOf = Refine_EFI_IFR_ONE_OF(Type)
> + IfrBaseInfo.__init__(self, self.OneOf, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.OneOf.Header, EFI_IFR_ONE_OF_OP,
> sizeof(self.OneOf))
> + IfrQuestionHeader.__init__(self, self.OneOf.Question)
> + IfrMinMaxStepData.__init__(self, self.OneOf.Data)
> + self.OneOf.Flags = 0
> +
> + self.HasMinMax = False
> +
> + self.HasStep = False
> +
> + def GetQuestion(self):
> + return self
> +
> + def GetMinMaxData(self):
> + return self
> +
> + def SetQHeaderFlags(self, Flags):
> + IfrQuestionHeader.SetFlags(self, Flags)
> +
> + def SetFlags(self, HFlags, LFlags):
> + ReturnCode = IfrQuestionHeader.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 = IfrQuestionHeader.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 SetHasMinMax(self, HasMinMax):
> + self.HasMinMax = HasMinMax
> +
> + def SetHasStep(self, HasStep):
> + self.HasStep = HasStep
> +
> +
> +class IfrCheckBox(IfrLine, IfrBaseInfo, IfrOpHeader, IfrQuestionHeader):
> + def __init__(self, QName=None, VarIdStr=""):
> + self.CheckBox = EFI_IFR_CHECKBOX()
> + IfrBaseInfo.__init__(self, self.CheckBox, QName, VarIdStr)
> + IfrOpHeader.__init__(self, self.CheckBox.Header,
> EFI_IFR_CHECKBOX_OP)
> + IfrQuestionHeader.__init__(self, self.CheckBox.Question)
> + self.CheckBox.Flags = 0
> +
> + def GetQuestion(self):
> + return self
> +
> + def SetQHeaderFlags(self, Flags):
> + IfrQuestionHeader.SetFlags(self, Flags)
> +
> + def GetFlags(self):
> + return self.CheckBox.Flags
> +
> + def SetFlags(self, HFlags, LFlags):
> + ReturnCode = IfrQuestionHeader.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
> + )
> +
> +
> +class IfrResetButton(IfrLine, IfrOpHeader, IfrStatementHeader):
> + def __init__(self, DefaultStore=None):
> + self.ResetButton = EFI_IFR_RESET_BUTTON()
> + IfrOpHeader.__init__(self, self.ResetButton.Header,
> EFI_IFR_RESET_BUTTON_OP)
> + IfrStatementHeader.__init__(self, self.ResetButton.Statement)
> + self.ResetButton.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD
> +
> + self.DefaultStore = DefaultStore
> +
> + def SetDefaultId(self, DefaultId):
> + self.ResetButton.DefaultId = DefaultId
> +
> + def SetDefaultStore(self, DefaultStore):
> + self.DefaultStore = DefaultStore
> +
> + def GetInfo(self):
> + return self.ResetButton
> +
> +
> +class IfrOr(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Or = EFI_IFR_OR()
> + IfrOpHeader.__init__(self, self.Or.Header, EFI_IFR_OR_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Or
> +
> +
> +class IfrAnd(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.And = EFI_IFR_AND()
> + IfrOpHeader.__init__(self, self.And.Header, EFI_IFR_AND_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.And
> +
> +
> +class IfrBitWiseOr(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.BitWiseOr = EFI_IFR_BITWISE_OR()
> + IfrOpHeader.__init__(self, self.BitWiseOr.Header,
> EFI_IFR_BITWISE_OR_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.BitWiseOr
> +
> +
> +class IfrCatenate(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Catenate = EFI_IFR_CATENATE()
> + IfrOpHeader.__init__(self, self.Catenate.Header, EFI_IFR_CATENATE_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Catenate
> +
> +
> +class IfrDivide(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Divide = EFI_IFR_DIVIDE()
> + IfrOpHeader.__init__(self, self.Divide.Header, EFI_IFR_DIVIDE_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Divide
> +
> +
> +class IfrEqual(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Equal = EFI_IFR_EQUAL()
> + IfrOpHeader.__init__(self, self.Equal.Header, EFI_IFR_EQUAL_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Equal
> +
> +
> +class IfrGreaterEqual(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.GreaterEqual = EFI_IFR_GREATER_EQUAL()
> + IfrOpHeader.__init__(self, self.GreaterEqual.Header,
> EFI_IFR_GREATER_EQUAL_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.GreaterEqual
> +
> +
> +class IfrGreaterThan(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.GreaterThan = EFI_IFR_GREATER_THAN()
> + IfrOpHeader.__init__(self, self.GreaterThan.Header,
> EFI_IFR_GREATER_THAN_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.GreaterThan
> +
> +
> +class IfrLessEqual(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.LessEqual = EFI_IFR_LESS_EQUAL()
> + IfrOpHeader.__init__(self, self.LessEqual.Header,
> EFI_IFR_LESS_EQUAL_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.LessEqual
> +
> +
> +class IfrLessThan(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.LessThan = EFI_IFR_LESS_THAN()
> + IfrOpHeader.__init__(self, self.LessThan.Header,
> EFI_IFR_LESS_THAN_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.LessThan
> +
> +
> +class IfrMap(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Map = EFI_IFR_MAP()
> + IfrOpHeader.__init__(self, self.Map.Header, EFI_IFR_MAP_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Map
> +
> +
> +class IfrMatch(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Match = EFI_IFR_MATCH()
> + IfrOpHeader.__init__(self, self.Match.Header, EFI_IFR_MATCH_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Match
> +
> +
> +class IfrMatch2(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo, Guid):
> + self.Match2 = EFI_IFR_MATCH2()
> + IfrOpHeader.__init__(self, self.Match2.Header, EFI_IFR_MATCH2_OP)
> + self.SetLineNo(LineNo)
> + self.Match2.SyntaxType = Guid
> +
> + def GetInfo(self):
> + return self.Match2
> +
> +
> +class IfrMultiply(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Multiply = EFI_IFR_MULTIPLY()
> + IfrOpHeader.__init__(self, self.Multiply.Header, EFI_IFR_MULTIPLY_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Multiply
> +
> +
> +class IfrModulo(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Modulo = EFI_IFR_MODULO()
> + IfrOpHeader.__init__(self, self.Modulo.Header, EFI_IFR_MODULO_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Modulo
> +
> +
> +class IfrNotEqual(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.NotEqual = EFI_IFR_NOT_EQUAL()
> + IfrOpHeader.__init__(self, self.NotEqual.Header,
> EFI_IFR_NOT_EQUAL_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.NotEqual
> +
> +
> +class IfrShiftLeft(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.ShiftLeft = EFI_IFR_SHIFT_LEFT()
> + IfrOpHeader.__init__(self, self.ShiftLeft.Header, EFI_IFR_SHIFT_LEFT_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.ShiftLeft
> +
> +
> +class IfrShiftRight(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.ShiftRight = EFI_IFR_SHIFT_RIGHT()
> + IfrOpHeader.__init__(self, self.ShiftRight.Header,
> EFI_IFR_SHIFT_RIGHT_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.ShiftRight
> +
> +
> +class IfrSubtract(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Subtract = EFI_IFR_SUBTRACT()
> + IfrOpHeader.__init__(self, self.Subtract.Header, EFI_IFR_SUBTRACT_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Subtract
> +
> +
> +class IfrConditional(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Conditional = EFI_IFR_CONDITIONAL()
> + IfrOpHeader.__init__(self, self.Conditional.Header,
> EFI_IFR_CONDITIONAL_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Conditional
> +
> +
> +class IfrFind(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Find = EFI_IFR_FIND()
> + IfrOpHeader.__init__(self, self.Find.Header, EFI_IFR_FIND_OP)
> + self.SetLineNo(LineNo)
> +
> + def SetFormat(self, Format):
> + self.Find.Format = Format
> +
> + def GetInfo(self):
> + return self.Find
> +
> +
> +class IfrMid(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Mid = EFI_IFR_MID()
> + IfrOpHeader.__init__(self, self.Mid.Header, EFI_IFR_MID_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Mid
> +
> +
> +class IfrToken(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Token = EFI_IFR_TOKEN()
> + IfrOpHeader.__init__(self, self.Token.Header, EFI_IFR_TOKEN_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Token
> +
> +
> +class IfrSpan(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Span = EFI_IFR_SPAN()
> + IfrOpHeader.__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
> + )
> +
> + def GetInfo(self):
> + return self.Span
> +
> +
> +class IfrBitWiseAnd(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.BitWiseAnd = EFI_IFR_BITWISE_AND()
> + IfrOpHeader.__init__(self, self.BitWiseAnd.Header,
> EFI_IFR_BITWISE_AND_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.BitWiseAnd
> +
> +
> +class IfrAdd(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Add = EFI_IFR_ADD()
> + IfrOpHeader.__init__(self, self.Add.Header, EFI_IFR_ADD_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Add
> +
> +
> +class IfrToString(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.ToString = EFI_IFR_TO_STRING()
> + IfrOpHeader.__init__(self, self.ToString.Header, EFI_IFR_TO_STRING_OP)
> + self.SetLineNo(LineNo)
> +
> + def SetFormat(self, Format):
> + self.ToString.Format = Format
> +
> + def GetInfo(self):
> + return self.ToString
> +
> +
> +class IfrToUpper(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.ToUppper = EFI_IFR_TO_UPPER()
> + IfrOpHeader.__init__(self, self.ToUppper.Header,
> EFI_IFR_TO_UPPER_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.ToUppper
> +
> +
> +class IfrToUint(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.ToUint = EFI_IFR_TO_UINT()
> + IfrOpHeader.__init__(self, self.ToUint.Header, EFI_IFR_TO_UINT_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.ToUint
> +
> +
> +class IfrToLower(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.ToLower = EFI_IFR_TO_LOWER()
> + IfrOpHeader.__init__(self, self.ToLower.Header, EFI_IFR_TO_LOWER_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.ToLower
> +
> +
> +class IfrToBoolean(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Boolean = EFI_IFR_TO_BOOLEAN()
> + IfrOpHeader.__init__(self, self.Boolean.Header,
> EFI_IFR_TO_BOOLEAN_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Boolean
> +
> +
> +class IfrNot(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Not = EFI_IFR_NOT()
> + IfrOpHeader.__init__(self, self.Not.Header, EFI_IFR_NOT_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Not
> +
> +
> +class IfrDup(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Dup = EFI_IFR_DUP()
> + IfrOpHeader.__init__(self, self.Dup.Header, EFI_IFR_DUP_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.Dup.Header
> +
> + def GetInfo(self):
> + return self.Dup
> +
> +
> +class IfrEqIdId(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.EqIdId = EFI_IFR_EQ_ID_ID()
> + IfrOpHeader.__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:
> + gFormPkg.AssignPending(VarIdStr, self.EqIdId, LineNo, "no question
> refered", 1)
> +
> + def SetQuestionId2(self, QuestionId, VarIdStr, LineNo):
> + if QuestionId != EFI_QUESTION_ID_INVALID:
> + self.EqIdId.QuestionId2 = QuestionId
> + else:
> + gFormPkg.AssignPending(VarIdStr, self.EqIdId, LineNo, "no question
> refered", 2)
> +
> + def GetInfo(self):
> + return self.EqIdId
> +
> +
> +class IfrEqIdVal(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.EqIdVal = EFI_IFR_EQ_ID_VAL()
> + IfrOpHeader.__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:
> + gFormPkg.AssignPending(VarIdStr, self.EqIdVal, LineNo, "no question
> refered")
> +
> + def SetValue(self, Value):
> + self.EqIdVal.Value = Value
> +
> + def GetHeader(self):
> + return self.EqIdVal.Header
> +
> + def GetInfo(self):
> + return self.EqIdVal
> +
> +
> +class IfrEqIdList(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo, Nums, ValueList=None):
> + self.EqIdVList = Refine_EFI_IFR_EQ_ID_VAL_LIST(Nums)
> + IfrOpHeader.__init__(
> + self, self.EqIdVList.Header, EFI_IFR_EQ_ID_VAL_LIST_OP,
> sizeof(self.EqIdVList)
> + )
> + self.SetLineNo(LineNo)
> + self.EqIdVList.QuestionId = EFI_QUESTION_ID_INVALID
> + self.EqIdVList.ListLength = 0
> + if ValueList is not None and 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:
> + gFormPkg.AssignPending(VarIdStr, self.EqIdVList, LineNo, "no question
> refered")
> +
> + 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
> +
> + def GetInfo(self):
> + return self.EqIdVList
> +
> +
> +class IfrUint8(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Uint8 = EFI_IFR_UINT8()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.Uint8
> +
> +
> +class IfrUint16(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Uint16 = EFI_IFR_UINT16()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.Uint16
> +
> +
> +class IfrUint32(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Uint32 = EFI_IFR_UINT32()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.Uint32
> +
> +
> +class IfrUint64(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Uint64 = EFI_IFR_UINT64()
> + IfrOpHeader.__init__(self, self.Uint64.Header, EFI_IFR_UINT64_OP,
> sizeof(EFI_IFR_UINT64))
> + self.SetLineNo(LineNo)
> +
> + def SetValue(self, Value):
> + self.Uint64.Value = Value
> +
> + def GetHeader(self):
> + return self.Uint64.Header
> +
> + def GetInfo(self):
> + return self.Uint64
> +
> +
> +class IfrQuestionRef1(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.QuestionRef1 = EFI_IFR_QUESTION_REF1()
> + IfrOpHeader.__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:
> + gFormPkg.AssignPending(VarIdStr, self.QuestionRef1, LineNo, "no
> question refered")
> +
> + def GetInfo(self):
> + return self.QuestionRef1
> +
> +
> +class IfrQuestionRef2(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.QuestionRef2 = EFI_IFR_QUESTION_REF2()
> + IfrOpHeader.__init__(self, self.QuestionRef2.Header,
> EFI_IFR_QUESTION_REF2_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.QuestionRef2.Header
> +
> + def GetInfo(self):
> + return self.QuestionRef2
> +
> +
> +class IfrQuestionRef3(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.QuestionRef3 = EFI_IFR_QUESTION_REF3()
> + IfrOpHeader.__init__(
> + self, self.QuestionRef3.Header, EFI_IFR_QUESTION_REF3_OP,
> sizeof(EFI_IFR_QUESTION_REF3)
> + )
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.QuestionRef3.Header
> +
> + def GetInfo(self):
> + return self.QuestionRef3
> +
> +
> +class IfrQuestionRef3_2(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.QuestionRef3_2 = EFI_IFR_QUESTION_REF3_2()
> + IfrOpHeader.__init__(
> + self,
> + self.QuestionRef3_2.Header,
> + EFI_IFR_QUESTION_REF3_OP,
> + sizeof(EFI_IFR_QUESTION_REF3_2),
> + )
> + 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
> +
> + def GetInfo(self):
> + return self.QuestionRef3_2
> +
> +
> +class IfrQuestionRef3_3(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.QuestionRef3_3 = EFI_IFR_QUESTION_REF3_3()
> + IfrOpHeader.__init__(
> + self,
> + self.QuestionRef3_3.Header,
> + EFI_IFR_QUESTION_REF3_OP,
> + sizeof(EFI_IFR_QUESTION_REF3_3),
> + )
> + 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
> +
> + def GetInfo(self):
> + return self.QuestionRef3_3
> +
> +
> +class IfrRuleRef(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.RuleRef = EFI_IFR_RULE_REF()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.RuleRef
> +
> +
> +class IfrStringRef1(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.StringRef1 = EFI_IFR_STRING_REF1()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.StringRef1
> +
> +
> +class IfrStringRef2(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.StringRef2 = EFI_IFR_STRING_REF2()
> + IfrOpHeader.__init__(self, self.StringRef2.Header,
> EFI_IFR_STRING_REF2_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.StringRef2.Header
> +
> + def GetInfo(self):
> + return self.StringRef2
> +
> +
> +class IfrThis(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.This = EFI_IFR_THIS()
> + IfrOpHeader.__init__(self, self.This.Header, EFI_IFR_THIS_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.This.Header
> +
> + def GetInfo(self):
> + return self.This
> +
> +
> +class IfrSecurity(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Security = EFI_IFR_SECURITY()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.Security
> +
> +
> +class IfrGet(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Get = EFI_IFR_GET()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.Get
> +
> +
> +class IfrSet(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Set = EFI_IFR_SET()
> + IfrOpHeader.__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
> +
> + def GetInfo(self):
> + return self.Set
> +
> +
> +class IfrTrue(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.TrueOp = EFI_IFR_TRUE()
> + IfrOpHeader.__init__(self, self.TrueOp.Header, EFI_IFR_TRUE_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.TrueOp.Header
> +
> + def GetInfo(self):
> + return self.TrueOp
> +
> +
> +class IfrFalse(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.FalseOp = EFI_IFR_TRUE()
> + IfrOpHeader.__init__(self, self.FalseOp.Header, EFI_IFR_FALSE_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.FalseOp.Header
> +
> + def GetInfo(self):
> + return self.FalseOp
> +
> +
> +class IfrOne(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.One = EFI_IFR_ONE()
> + IfrOpHeader.__init__(self, self.One.Header, EFI_IFR_ONE_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.One.Header
> +
> + def GetInfo(self):
> + return self.One
> +
> +
> +class IfrOnes(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Ones = EFI_IFR_ONE()
> + IfrOpHeader.__init__(self, self.Ones.Header, EFI_IFR_ONES_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.Ones.Header
> +
> + def GetInfo(self):
> + return self.Ones
> +
> +
> +class IfrZero(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Zero = EFI_IFR_ZERO()
> + IfrOpHeader.__init__(self, self.Zero.Header, EFI_IFR_ZERO_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.Zero.Header
> +
> + def GetInfo(self):
> + return self.Zero
> +
> +
> +class IfrUndefined(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Undefined = EFI_IFR_ZERO()
> + IfrOpHeader.__init__(self, self.Undefined.Header,
> EFI_IFR_UNDEFINED_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.Undefined.Header
> +
> + def GetInfo(self):
> + return self.Undefined
> +
> +
> +class IfrVersion(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Version = EFI_IFR_VERSION()
> + IfrOpHeader.__init__(self, self.Version.Header, EFI_IFR_VERSION_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetHeader(self):
> + return self.Version.Header
> +
> + def GetInfo(self):
> + return self.Version
> +
> +
> +class IfrLength(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.Length = EFI_IFR_LENGTH()
> + IfrOpHeader.__init__(self, self.Length.Header, EFI_IFR_LENGTH_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.Length
> +
> +
> +class IfrBitWiseNot(IfrLine, IfrOpHeader):
> + def __init__(self, LineNo):
> + self.BitWiseNot = EFI_IFR_BITWISE_NOT()
> + IfrOpHeader.__init__(self, self.BitWiseNot.Header,
> EFI_IFR_BITWISE_NOT_OP)
> + self.SetLineNo(LineNo)
> +
> + def GetInfo(self):
> + return self.BitWiseNot
> +
> +
> +class ExpressionInfo:
> + def __init__(self):
> + self.RootLevel = 0
> + self.ExpOpCount = 0
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> b/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> new file mode 100644
> index 0000000000..cd78b31d9d
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> @@ -0,0 +1,262 @@
> +## @file
> +# The file is used to preprocess the source file.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +import re
> +import os
> +import json
> +import Common.EdkLogger as EdkLogger
> +from antlr4 import *
> +from pathlib import Path
> +from Common.BuildToolError import *
> +from VfrCompiler.IfrCtypes import EFI_GUID
> +from VfrCompiler.IfrUtility import VfrVarDataTypeDB
> +from Common.LongFilePathSupport import LongFilePath
> +from VfrCompiler.IfrCommon import GUID_BUFFER_VALUE_LEN
> +
> +
> +class Options:
> + def __init__(self):
> + # open/close VfrCompiler
> + self.LanuchVfrCompiler = False
> + self.ModuleName = None
> + self.Workspace = None
> + self.VFRPP = None
> + self.InputFileName = None
> + self.BaseFileName = None
> + self.IncludePaths = []
> + self.OutputDirectory = None
> + self.DebugDirectory = None
> + self.CreateRecordListFile = True
> + self.RecordListFileName = None
> + self.CreateIfrPkgFile = True
> + self.PkgOutputFileName = None
> + self.COutputFileName = None
> + self.SkipCPreprocessor = True
> + self.CPreprocessorOptions = None
> + self.CProcessedVfrFileName = None
> + self.HasOverrideClassGuid = False
> + self.OverrideClassGuid = None
> + self.WarningAsError = False
> + self.AutoDefault = False
> + self.CheckDefault = False
> + self.CreateYamlFile = True
> + self.YamlFileName = None
> + self.CreateJsonFile = True
> + self.JsonFileName = None
> + self.UniStrDefFileName = None
> + self.YamlOutputFileName = None
> + self.UniStrDisplayFile = None
> +
> +
> +class KV:
> + def __init__(self, Key, Value) -> None:
> + self.Key = Key
> + self.Value = Value
> +
> +
> +class ValueDB:
> + def __init__(self, PreVal, PostVal) -> None:
> + self.PreVal = PreVal
> + self.PostVal = PostVal
> +
> +
> +class PreProcessDB:
> + def __init__(self, Options: Options) -> None:
> + self.Options = Options
> + self.VfrVarDataTypeDB = VfrVarDataTypeDB()
> + self.Preprocessed = False
> +
> + def Preprocess(self):
> + self.HeaderFiles = self._ExtractHeaderFiles()
> + # Read Uni string token/id definitions in StrDef.h file
> + self.UniDict, self.UniDisPlayDict = self._GetUniDicts()
> + # Read definitions in vfr file
> + self.VfrDict = self._GetVfrDicts()
> + self.Preprocessed = True
> +
> + def TransValue(self, Value):
> + if type(Value) == EFI_GUID:
> + return Value
> + else:
> + StrValue = str(Value)
> + if self._IsDigit(StrValue):
> + return self._ToDigit(StrValue)
> + else:
> + GuidList = re.findall(r"0x[0-9a-fA-F]+", StrValue)
> + GuidList = [int(num, 16) for num in GuidList]
> + Guid = EFI_GUID()
> + Guid.from_list(GuidList)
> + return Guid
> +
> + def RevertValue(self, Value) -> str:
> + if type(Value) == EFI_GUID:
> + return Value.to_string()
> + elif ("0x" in Value) or ("0X" in Value):
> + StrValue = hex(Value)
> + else:
> + StrValue = str(Value)
> + return StrValue
> +
> + def DisplayValue(self, Value, Flag=False):
> + if type(Value) == EFI_GUID:
> + return Value.to_string()
> + StrValue = str(Value)
> + if self._IsDigit(StrValue):
> + if Flag:
> + return f"STRING_TOKEN({StrValue})"
> + return int(StrValue, 0)
> + return StrValue
> +
> + def GetKey(self, Value):
> + if type(Value) == EFI_GUID:
> + Value = Value.to_string()
> + if Value in self.UniDict:
> + return self.UniDict[Value]
> + if Value in self.VfrDict:
> + return self.VfrDict[Value]
> + else:
> + Value = "0x%04x" % Value
> + Value = Value[:2] + Value[2:].upper()
> + if Value in self.UniDict:
> + return self.UniDict[Value]
> + return Value
> +
> + def _ExtractHeaderFiles(self):
> + FileName = self.Options.InputFileName
> + HeaderFiles = []
> + try:
> + with open(LongFilePath(FileName), mode="r") as fFile:
> + lines = fFile.readlines()
> + for line in lines:
> + if "#include" in line:
> + if line.find("<") != -1:
> + HeaderFile = line[line.find("<") + 1 : line.find(">")]
> + HeaderFiles.append(HeaderFile)
> + elif line.find('"') != -1:
> + l = line.find('"') + 1
> + r = l + line[l:].find('"')
> + HeaderFile = line[l:r]
> + HeaderFiles.append(HeaderFile)
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler", FILE_PARSE_FAILURE, "File parse failed for %s" %
> FileName, None
> + )
> + return HeaderFiles
> +
> + def _GetUniDicts(self):
> + if self.Options.UniStrDefFileName is None:
> + self.Options.UniStrDefFileName = str(
> + Path(self.Options.DebugDirectory) /
> f"{self.Options.ModuleName}StrDefs.h"
> + )
> + # find UniFile
> + FileName = self.Options.UniStrDefFileName
> + UniDict = {}
> + self._ParseDefines(FileName, UniDict)
> + DisPlayUniDict = {}
> + if self.Options.UniStrDisplayFile is None:
> + self.Options.UniStrDisplayFile = str(Path(self.Options.OutputDirectory)
> / f"{self.Options.ModuleName}Uni.json")
> + # String Token : DisPlay String}
> + if os.path.exists(self.Options.UniStrDisplayFile):
> + with open(self.Options.UniStrDisplayFile) as f:
> + Dict = json.load(f)
> + Dict = Dict["OrderedStringTestDict"]["en-US"]
> + for Key in Dict.keys():
> + for UniKey in UniDict.keys():
> + if Key == UniDict[UniKey]:
> + DisPlayUniDict[UniKey] = Dict[Key]
> + break
> +
> + return UniDict, DisPlayUniDict
> +
> +
> + def _GetVfrDicts(self):
> + VfrDict = {}
> + if self.Options.LanuchVfrCompiler:
> + FileName = self.Options.InputFileName
> + self._ParseDefines(FileName, VfrDict, True)
> + return VfrDict
> +
> + def _IsDigit(self, String):
> + return String.isdigit() or (
> + String.startswith(("0x", "0X"))
> + and all(char in "0123456789ABCDEFabcdef" for char in String[2:])
> + )
> +
> + def _ToDigit(self, String):
> + if String.startswith(("0x", "0X")):
> + return int(String, 16)
> + return int(String)
> +
> + def _ParseDefines(self, FileName, Dict, IsVfrDef=False):
> + Pattern = r"#define\s+(\w+)\s+(.*?)(?:(?<!\\)\n|$)"
> + with open(FileName) as File:
> + Content = File.read()
> +
> + Matches = re.findall(Pattern, Content, re.DOTALL)
> + for Match in Matches:
> + Key = Match[0]
> + Value = re.sub(r"\s+", " ", Match[1].replace("\\\n", "").strip())
> + SubDefineMatches = re.findall(
> + r"#define\s+(\w+)\s+(.*?)(?:(?<!\\)\n|$)", Value, re.DOTALL
> + )
> + if SubDefineMatches:
> + for SubMatch in SubDefineMatches:
> + SubKey = SubMatch[0]
> + SubValue = re.sub(r"\s+", " ", SubMatch[1].replace("\\\n",
> "").strip())
> + if SubValue.find("//") != -1:
> + SubValue = SubValue.split("//")[0].strip()
> +
> + if SubValue.find("{") != -1:
> + GuidList = re.findall(r"0x[0-9a-fA-F]+", SubValue)
> + GuidList = [int(num, 16) for num in GuidList]
> + SubValue = EFI_GUID()
> + if len(GuidList) == GUID_BUFFER_VALUE_LEN:
> + SubValue.from_list(GuidList)
> +
> + if self.Options.LanuchVfrCompiler:
> + # GUID is unique, to transfer GUID Parsed Value -> GUID
> Defined Key.
> + if IsVfrDef:
> + # Save def info for yaml generation
> + Dict[SubKey] = SubValue
> + # tranfer value to key for yaml generation
> + if type(SubValue) == EFI_GUID:
> + Dict[SubValue.to_string()] = SubKey
> + else:
> + SubValue = (
> + str(SubValue)
> + if type(SubValue) != EFI_GUID
> + else SubValue.to_string()
> + )
> + Dict[SubValue] = SubKey
> + else:
> + if Value.find("//") != -1:
> + Value = Value.split("//")[0].strip()
> + if Value.find("{") != -1:
> + GuidList = re.findall(r"0x[0-9a-fA-F]+", Value)
> + GuidList = [int(num, 16) for num in GuidList]
> + Value = EFI_GUID()
> + if len(GuidList) == GUID_BUFFER_VALUE_LEN:
> + Value.from_list(GuidList)
> +
> + if self.Options.LanuchVfrCompiler:
> + # GUID is unique, to transfer GUID Parsed Value -> GUID Defined
> Key.
> + if IsVfrDef:
> + Dict[Key] = Value
> + if type(Value) == EFI_GUID:
> + Dict[Value.to_string()] = Key
> + else:
> + Value = str(Value) if type(Value) != EFI_GUID else
> Value.to_string()
> + Dict[Value] = Key
> +
> + def _FindIncludeHeaderFile(self, IncludePaths, File):
> + FileList = []
> + Name = File.split("/")[-1]
> + for Start in IncludePaths:
> + Matches = list(Path(Start).rglob(Name))
> + for MatchFile in Matches:
> + FileList.append(str(MatchFile))
> + return list(set(FileList))
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrTree.py
> b/BaseTools/Source/Python/VfrCompiler/IfrTree.py
> new file mode 100644
> index 0000000000..64915761c8
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrTree.py
> @@ -0,0 +1,1734 @@
> +## @file
> +# The file is used to define vfr tree structure and related operations.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +import Common.EdkLogger as EdkLogger
> +from Common.BuildToolError import *
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrFormPkg import *
> +from VfrCompiler.IfrUtility import gVfrBufferConfig
> +from VfrCompiler.IfrPreProcess import PreProcessDB, Options
> +
> +
> +VFR_COMPILER_VERSION = "2.01 (UEFI 2.4)"
> +BUILD_VERSION = "Developer Build based on Revision: Unknown"
> +BYTES_PRE_LINE = 0x10
> +
> +
> +# Ifr related Info -> ctypes obj
> +# conditional Info
> +# Structure Info
> +class IfrTreeNode:
> + def __init__(self, OpCode=None, Data=None, Buffer=None,
> Position=None):
> + self.OpCode = OpCode
> + self.Data = Data
> + self.Buffer = Buffer
> + self.Position = Position
> + self.Condition = None
> + self.Expression = None
> + self.Dict = {}
> + self.Offset = None
> + self.Parent = None
> + self.Child = []
> + self.Level = -1
> +
> + def hasCondition(self):
> + return self.Condition
> +
> + def hasChild(self):
> + return self.Child == []
> +
> + def isFinalChild(self):
> + ParTree = self.Parent
> + if ParTree and ParTree.Child[-1] == self:
> + return True
> + return False
> +
> + def insertChild(self, NewNode, pos: int = None):
> + if NewNode is not None:
> + if not pos:
> + self.Child.append(NewNode)
> + else:
> + self.Child.insert(pos, NewNode)
> +
> + NewNode.Parent = self
> +
> + def insertRel(self, newNode):
> + 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):
> + 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
> + return None
> +
> +
> +ExpOps = [
> + EFI_IFR_DUP_OP,
> + EFI_IFR_EQ_ID_VAL_OP,
> + EFI_IFR_QUESTION_REF1_OP,
> + EFI_IFR_EQ_ID_VAL_OP,
> + EFI_IFR_EQ_ID_ID_OP,
> + EFI_IFR_EQ_ID_VAL_LIST_OP,
> + EFI_IFR_RULE_REF_OP,
> + EFI_IFR_STRING_REF1_OP,
> + EFI_IFR_THIS_OP,
> + EFI_IFR_SECURITY_OP,
> + EFI_IFR_GET_OP,
> + EFI_IFR_TRUE_OP,
> + EFI_IFR_FALSE_OP,
> + EFI_IFR_ONE_OP,
> + EFI_IFR_ONES_OP,
> + EFI_IFR_ZERO_OP,
> + EFI_IFR_UNDEFINED_OP,
> + EFI_IFR_VERSION_OP,
> + EFI_IFR_UINT64_OP,
> + EFI_IFR_QUESTION_REF2_OP,
> + EFI_IFR_QUESTION_REF3_OP,
> + EFI_IFR_SET_OP,
> + EFI_IFR_DEFAULTSTORE_OP,
> + EFI_IFR_OR_OP,
> +]
> +
> +DefaultDictList = []
> +
> +
> +class ReCordNode(Structure):
> + def __init__(self, Record, LineNo):
> + self.Record = Record
> + self.LineNo = LineNo
> +
> +
> +class IfrTree:
> + def __init__(self, Root: IfrTreeNode, PreProcessDB: PreProcessDB, Options:
> Options) -> None:
> + self.Root = Root
> + self.Options = Options
> + self.PreProcessDB = PreProcessDB
> +
> + def GenBinaryFiles(self):
> + RecordLines = []
> + HpkFile = self.Options.PkgOutputFileName
> + CFile = self.Options.COutputFileName
> + LstFile = self.Options.RecordListFileName
> + if self.Options.CreateIfrPkgFile:
> + # GenBinary
> + PkgHdr = gFormPkg.BuildPkgHdr()
> + try:
> + with open(HpkFile, "wb") as Hpk:
> + Hpk.write(gFormPkg.StructToStream(PkgHdr))
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, f"File open failed for
> {HpkFile}: {e}"
> + )
> +
> + # GenCFile
> + try:
> + with open(CFile, "w") as C:
> + C.write("//\n")
> + C.write("//" + " " + "DO NOT EDIT -- auto-generated file\n")
> + C.write("//\n")
> + C.write("//" + " " + "This file is generated by the vfrcompiler
> utility\n")
> + C.write("//\n\n")
> + BaseName = "unsigned char " + self.Options.BaseFileName +
> "Bin[] = {\n"
> + C.write(BaseName)
> + C.write(" // ARRAY LENGTH\n\n")
> + PkgLength = PkgHdr.Length + sizeof(c_uint32)
> + for B in PkgLength.to_bytes(4, byteorder="little", signed=True):
> + C.write(" 0x%02X," % B)
> + C.write("\n\n")
> + C.write(" // PACKAGE HEADER\n\n")
> + HeaderBuffer = gFormPkg.StructToStream(PkgHdr)
> + for B in HeaderBuffer:
> + C.write(" 0x%02X," % B)
> + C.write("\n\n")
> + C.write(" //" + " " + "PACKAGE DATA\n\n")
> + self.Index = 0
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, f"File open failed for {CFile}:
> {e}"
> + )
> +
> + if self.Options.CreateRecordListFile:
> + # GenRecordList
> + try:
> + with open(LstFile, "w") as Lst:
> + Lst.write(
> + f"//\n// VFR compiler version {VFR_COMPILER_VERSION}
> {BUILD_VERSION}\n//\n"
> + )
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, f"File open failed for
> {LstFile}: {e}"
> + )
> +
> + self._GenBinaryFilesDfs(self.Root, HpkFile, CFile, RecordLines)
> +
> + if self.Options.CreateIfrPkgFile:
> + # GenCFile
> + try:
> + with open(CFile, "a") as C:
> + C.write("\n};\n")
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler", FILE_WRITE_FAILURE, f"File write failed for {CFile}:
> {e}", None
> + )
> +
> + if self.Options.CreateRecordListFile:
> + # GenRecordList
> + InFileLines = []
> + try:
> + with open(self.Options.CProcessedVfrFileName, "r") as In:
> + for Line in In:
> + InFileLines.append(Line)
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_OPEN_FAILURE,
> + f"File open failed for {self.Options.CProcessedVfrFileName}: {e}",
> + None,
> + )
> + try:
> + with open(LstFile, "a") as Lst:
> + InsertedLine = 0
> + for RecordLine in RecordLines:
> + InFileLines.insert(RecordLine.LineNo + InsertedLine,
> RecordLine.Record)
> + InsertedLine += 1
> + for Line in InFileLines:
> + Lst.write(f"{Line}")
> + Lst.write("//\n// All Opcode Record List\n//\n")
> + for RecordLine in RecordLines:
> + Lst.write(f"{RecordLine.Record}")
> + Lst.write(f"\nTotal Size of all record is {gFormPkg.Offset:0>8x}")
> + gVfrVarDataTypeDB.Dump(Lst)
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler", FILE_WRITE_FAILURE, f"File write failed for
> {LstFile}: {e}", None
> + )
> +
> + def _GenBinaryFilesDfs(self, Root, HpkFile, CFile, RecordLines):
> + if Root is None:
> + return
> +
> + if Root.OpCode is not None:
> + if Root.OpCode in ExpOps:
> + # The Data is likely to be modified, so generate buffer here
> + Root.Buffer = gFormPkg.StructToStream(Root.Data.GetInfo())
> + if Root.Buffer is not None:
> + if self.Options.CreateIfrPkgFile and self.Options.CreateRecordListFile:
> + try:
> + with open(HpkFile, "ab") as Hpk:
> + Hpk.write(Root.Buffer)
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" %
> (self.Options.PkgOutputFileName),
> + )
> +
> + try:
> + with open(CFile, "a") as C:
> + LineBuffer = ""
> + for i in range(0, len(Root.Buffer)):
> + self.Index += 1
> + Data = Root.Buffer[i]
> + if self.Index % BYTES_PRE_LINE == 1:
> + C.write(" ")
> + C.write("0x%02X" % Data)
> + if self.Index != gFormPkg.PkgLength:
> + if self.Index % BYTES_PRE_LINE == 0:
> + C.write(",\n")
> + else:
> + C.write(", ")
> +
> + LineBuffer += f"{Root.Buffer[i]:0>2X} "
> +
> + Record = f">{Root.Offset:0>8X}: {LineBuffer}\n"
> + LineNo = Root.Data.GetLineNo()
> + RecordLines.append(ReCordNode(Record, LineNo))
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" % (self.Options.COutputFileName),
> + )
> +
> + if self.Options.CreateIfrPkgFile and not
> self.Options.CreateRecordListFile:
> + try:
> + with open(HpkFile, "ab") as Hpk:
> + Hpk.write(Root.Buffer)
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" %
> (self.Options.PkgOutputFileName),
> + )
> +
> + try:
> + with open(CFile, "a") as C:
> + for i in range(0, len(Root.Buffer)):
> + self.Index += 1
> + Data = Root.Buffer[i]
> + if self.Index % BYTES_PRE_LINE == 1:
> + C.write(" ")
> + C.write("0x%02X" % Data)
> + if self.Index != gFormPkg.PkgLength:
> + if self.Index % BYTES_PRE_LINE == 0:
> + C.write(",\n")
> + else:
> + C.write(", ")
> + except Exception as e:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + f"File write failed for {self.Options.COutputFileName} : {e}",
> + )
> +
> + if not self.Options.CreateIfrPkgFile and
> self.Options.CreateRecordListFile:
> + LineBuffer = ""
> + for i in range(0, len(Root.Buffer)):
> + LineBuffer += f"{Root.Buffer[i]:0>2X} "
> + Record = f">{Root.Offset:0>8X}: {LineBuffer}\n"
> + LineNo = Root.Data.GetLineNo()
> + RecordLines.append(ReCordNode(Record, LineNo))
> +
> + if Root.Child != []:
> + for ChildNode in Root.Child:
> + self._GenBinaryFilesDfs(ChildNode, HpkFile, CFile, RecordLines)
> +
> + def GenRecordListFile(self):
> + FileName = self.Options.RecordListFileName
> + RecordLines = []
> + self._GenRecordListFileDfs(self.Root, RecordLines)
> +
> + try:
> + Out = open(FileName, "w")
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> FileName, None
> + )
> +
> + try:
> + Out.write("//\n// All Opcode Record List\n//\n")
> + for RecordLine in RecordLines:
> + Out.write(f"{RecordLine}\n")
> + Out.write(f"\nTotal Size of all record is {gFormPkg.Offset:0>8x}")
> + gVfrVarDataTypeDB.Dump(Out)
> + Out.close()
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler", FILE_WRITE_FAILURE, "File write failed for %s" %
> FileName
> + )
> +
> + def _GenRecordListFileDfs(self, Root, RecordLines):
> + if Root is None:
> + return
> + if Root.OpCode is not None:
> + LineBuffer = ""
> + if Root.Buffer is not None:
> + for i in range(0, len(Root.Buffer)):
> + LineBuffer += f"{Root.Buffer[i]:0>2X} "
> + Record = f">{Root.Offset:0>8X}: {LineBuffer}\n"
> + RecordLines.append(Record)
> +
> + if Root.Child != []:
> + for ChildNode in Root.Child:
> + self._GenRecordListFileDfs(ChildNode, RecordLines)
> +
> + def DumpJson(self):
> + FileName = self.Options.JsonFileName
> + try:
> + with open(FileName, "w") as f:
> + f.write("{\n")
> + f.write(' "DataStruct" : {\n')
> + pNode = gVfrVarDataTypeDB.GetDataTypeList()
> + while pNode is not None:
> + f.write(f' "{pNode.TypeName}" : [\n')
> + FNode = pNode.Members
> + while FNode is not None:
> + f.write("{\n")
> + f.write(f' "Name": "{FNode.FieldName}",\n')
> + if FNode.ArrayNum > 0:
> + f.write(f' "Type":
> "{FNode.FieldType.TypeName}[{FNode.ArrayNum}]",\n')
> + else:
> + f.write(f' "Type": "{FNode.FieldType.TypeName}",\n')
> + f.write(f' "Offset": {FNode.Offset}\n')
> + if FNode.Next is None:
> + f.write("}\n")
> + else:
> + f.write("}, \n")
> + FNode = FNode.Next
> + if pNode.Next is None:
> + f.write(" ]\n")
> + else:
> + f.write(" ],\n")
> + pNode = pNode.Next
> + f.write(" },\n")
> + f.write(' "DataStructAttribute": {\n')
> + pNode = gVfrVarDataTypeDB.GetDataTypeList()
> + while pNode is not None:
> + f.write(f' "{pNode.TypeName}": {{\n')
> + f.write(f' "Alignment": {pNode.Align},\n')
> + f.write(f' "TotalSize": {pNode.TotalSize}\n')
> + if pNode.Next is None:
> + f.write("}\n")
> + else:
> + f.write("},\n")
> + pNode = pNode.Next
> + f.write(" },\n")
> + f.write(' "VarDefine" : {\n')
> + pVsNode = gVfrDataStorage.GetBufferVarStoreList()
> + while pVsNode is not None:
> + f.write(f' "{pVsNode.VarStoreName}": {{\n')
> + f.write(f' "Type": "{pVsNode.DataType.TypeName}",\n')
> + f.write(f' "Attributes": {pVsNode.Attributes},\n')
> + f.write(f' "VarStoreId": {pVsNode.VarStoreId},\n')
> + f.write(f' "VendorGuid": {pVsNode.Guid.to_string()}\n')
> + if pVsNode.Next is None:
> + f.write("}\n")
> + else:
> + f.write("},\n")
> +
> + pVsNode = pVsNode.Next
> + f.write(" },\n")
> + f.write(' "Data" : [\n')
> + pVsNode = gVfrBufferConfig.GetVarItemList()
> + while pVsNode is not None:
> + if pVsNode.Id is None:
> + pVsNode = pVsNode.Next
> + continue
> + pInfoNode = pVsNode.InfoStrList
> + while pInfoNode is not None:
> + f.write("{\n")
> + f.write(f' "VendorGuid": {pVsNode.Guid.to_string()},\n')
> + f.write(f' "VarName": "{pVsNode.Name}",\n')
> + f.write(f' "DefaultStore": "{pVsNode.Id}",\n')
> + f.write(f' "Size": "{pInfoNode.Width}",\n')
> + f.write(f' "Offset": {pInfoNode.Offset},\n')
> + if (
> + pInfoNode.Type == EFI_IFR_TYPE_DATE
> + and type(pInfoNode.Value) == EFI_HII_DATE
> + ):
> + f.write(
> + f' "Value":
> "{pInfoNode.Value.Year}/{pInfoNode.Value.Month}/{pInfoNode.Value.Day}"\n'
> + )
> + elif (
> + pInfoNode.Type == EFI_IFR_TYPE_TIME
> + and type(pInfoNode.Value) == EFI_HII_TIME
> + ):
> + f.write(
> + f' "Value":
> "{pInfoNode.Value.Hour}:{pInfoNode.Value.Minute}:{pInfoNode.Value.Second
> }"\n'
> + )
> + elif (
> + pInfoNode.Type == EFI_IFR_TYPE_REF
> + and type(pInfoNode.Value) == EFI_HII_REF
> + ):
> + f.write(
> + f' "Value":
> "{pInfoNode.Value.QuestionId};{pInfoNode.Value.FormId};{pInfoNode.Value.F
> ormSetGuid.to_string()};{pInfoNode.Value.DevicePath}"\n'
> + )
> + else:
> + f.write(f' "Value": "{pInfoNode.Value}"\n')
> +
> + 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 Exception:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> FileName, None
> + )
> +
> + def _DumpQuestionInfosForXMLCLI(self, Root, f, ValueIndent):
> + Info = Root.Data.GetInfo()
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + if Root.Data.QName is not None:
> + f.write(f"{ValueIndent}name: {Root.Data.QName} # Optional
> Input\n")
> +
> + if Root.Data.VarIdStr != "":
> + f.write(f"{ValueIndent}varid: {Root.Data.VarIdStr} # Optional
> Input\n")
> + if Root.Data.HasQuestionId:
> + f.write(
> + f"{ValueIndent}questionid: {'0x%x' % Info.Question.QuestionId} #
> Optional Input\n"
> + )
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Question.Header.Prompt)}'\n")
> + f.write(f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Question.Header.Help)}'\n")
> + if Root.Data.FlagsStream != "":
> + f.write(f"{ValueIndent}flags: {Root.Data.FlagsStream} # Optional
> input , flags\n")
> + if Root.Data.HasKey:
> + f.write(
> + f"{ValueIndent}key: {'0x%0x ' % Info.Question.QuestionId} #
> Optional input, key\n"
> + )
> +
> + def _DisplayUniStr(self, Key):
> + StrId = f"0x{Key:04x}"
> + FormatedStrId = StrId[:2] + StrId[2:].upper()
> + if FormatedStrId in self.PreProcessDB.UniDisPlayDict:
> + return self.PreProcessDB.UniDisPlayDict[FormatedStrId]
> + return FormatedStrId
> + #return f"STRING_TOKEN({FormatedStrId})"
> +
> + def DumpYamlForXMLCLI(self):
> + FileName = self.Options.YamlFileName
> + try:
> + with open(FileName, "w", encoding="utf-8") as f:
> + f.write("## DO NOT REMOVE -- YAML Mode\n")
> + self._DumpYamlForXMLCLIDfs(self.Root, f)
> + f.close()
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> FileName, None
> + )
> +
> + def DumpYamlForConfigEditor(self):
> + FileName = self.Options.YamlOutputFileName
> + try:
> + with open(FileName, "w", encoding="utf-8") as f:
> + f.write("## DO NOT REMOVE -- YAML Mode\n")
> + # if self.PreProcessDB.HeaderFiles != []:
> + # f.write("include:\n")
> + # for HeaderFile in self.PreProcessDB.HeaderFiles:
> + # f.write("- " + HeaderFile + "\n")
> + # f.write("\n")
> + self._DumpYamlForConfigEditorDfs(self.Root, f)
> + f.close()
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> FileName, None
> + )
> +
> + def _DumpYamlForConfigEditorDfs(self, Root, f):
> + try:
> + if Root.OpCode is not None:
> + if Root.Level == 0:
> + KeyIndent = ""
> + ValueIndent = ""
> + else:
> + KeyIndent = " " * ((Root.Level * 2 - 1) * 2)
> + ValueIndent = " " * ((Root.Level * 2 + 1) * 2)
> +
> + Info = Root.Data.GetInfo()
> +
> + if Root.OpCode == EFI_IFR_FORM_SET_OP:
> + f.write(KeyIndent + "formset:\n")
> + ValueIndent = " " * (Root.Level + 1) * 2
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> + f.write(f"{ValueIndent}help: '{self._DisplayUniStr(Info.Help)}'\n")
> + f.write(f"{ValueIndent}title:
> '{self._DisplayUniStr(Info.FormSetTitle)}'\n")
> + for i in range(0, len(Root.Data.GetClassGuid())):
> + Guid = Root.Data.GetClassGuid()[i]
> + if Guid != EFI_HII_PLATFORM_SETUP_FORMSET_GUID:
> + f.write(
> + f"{ValueIndent}classguid{i + 1}: '{{{Guid.Data1:#x},
> {Guid.Data2:#x}, {Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Guid.Data4)}}}}}'\n"
> + )
> + if (
> + Root.Child != []
> + and Root.Child[0].OpCode != EFI_IFR_END_OP
> + and type(Root.Child[0].Data) != IfrSubClass
> + and type(Root.Child[0].Data) != IfrClass
> + ):
> + f.write(ValueIndent + "component: \n")
> + elif (
> + type(Root.Child[0].Data) == IfrClass
> + and type(Root.Child[1].Data) == IfrSubClass
> + ):
> + Root.Child[0].Data.HasSubClass = True
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_OP:
> + f.write(KeyIndent + "- varstore:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> + # f.write(ValueIndent + 'type: {} # for
> reference\n'.format(Root.Data.Type))
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> + f.write(f"{ValueIndent}varid: {Info.VarStoreId:#04x} # Optional
> Input\n")
> + f.write(f"{ValueIndent}size: {Info.Size} # Need to Compute\n")
> + Name = "".join(chr(x) for x in Info.Name)
> + f.write(f"{ValueIndent}name: {Name}\n")
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_EFI_OP:
> + f.write(KeyIndent + "- efivarstore:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> + # f.write(ValueIndent + 'type: {}# for
> reference\n'.format(Root.Data.Type))
> + f.write(f"{ValueIndent}varid: {Info.VarStoreId:#04x} # Optional
> Input\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> + f.write(f"{ValueIndent}attribute: {Info.Attributes}\n")
> + f.write(f"{ValueIndent}size: {Info.Size} # Need to Compute\n")
> + Name = "".join(chr(x) for x in Info.Name)
> + f.write(f"{ValueIndent}name: {Name}\n")
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_NAME_VALUE_OP:
> + f.write(KeyIndent + "- namevaluevarstore:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> + # f.write(ValueIndent + 'type: {} # for
> reference\n'.format(Root.Data.Type))
> + f.write(f"{ValueIndent}varid: {Info.VarStoreId:#04x} # Optional
> Input\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> + f.write(f"{ValueIndent}nametable: # for reference\n")
> + for NameItem in Root.Data.NameItemList:
> + f.write(f"{ValueIndent} - name:
> '{self._DisplayUniStr(NameItem)}'\n")
> +
> + if Root.OpCode == EFI_IFR_DEFAULTSTORE_OP:
> + gVfrDefaultStore.UpdateDefaultType(Root)
> + Info = Root.Data.GetInfo()
> + Type = Root.Data.Type
> + if Type not in ("Standard Defaults", "Standard ManuFacturing"):
> + f.write(KeyIndent + "- defaultstore:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> + # f.write(ValueIndent + 'type: {} # for
> reference\n'.format(Type))
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.DefaultName)}'\n"
> + )
> + f.write(f"{ValueIndent}attribute: {Info.DefaultId:#04x} # Default
> ID\n")
> +
> + if Root.OpCode == EFI_IFR_FORM_OP:
> + f.write(f"{KeyIndent}- form: \n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + f.write(f"{ValueIndent}formid: {Info.FormId}\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}title:
> '{self._DisplayUniStr(Info.FormTitle)}'\n")
> +
> + if Root.Child and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(f"{ValueIndent}component: \n")
> +
> + if Root.OpCode == EFI_IFR_FORM_MAP_OP:
> + MethodMapList = Root.Data.GetMethodMapList()
> + f.write(KeyIndent + "- formmap: \n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + f.write(f"{ValueIndent}formid: {Info.FormId} # FormId
> STRING_ID\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + if MethodMapList != []:
> + f.write(ValueIndent + "map: # optional input, for reference\n")
> + for MethodMap in MethodMapList:
> + f.write(f"{ValueIndent}- maptitle:
> {MethodMap.MethodTitle}\n")
> + f.write(
> + f"{ValueIndent} mapguid: '{{{{"
> + f"{MethodMap.MethodIdentifier.Data1},
> {MethodMap.MethodIdentifier.Data2},
> {MethodMap.MethodIdentifier.Data3},"
> + f"{{ {', '.join('0x%x' % x for x in
> MethodMap.MethodIdentifier.Data4)} }}"
> + f"}}}}'\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_IMAGE_OP:
> + f.write(KeyIndent + "- image:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}id: {Info.Id}\n")
> +
> + if Root.OpCode == EFI_IFR_RULE_OP: #
> + f.write(KeyIndent + "- rule:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}name: {Root.Data.GetRuleName()} # for
> reference \n")
> + f.write(f"{ValueIndent}ruleid: {Info.RuleId}\n")
> + f.write(f"{ValueIndent}expression: {Root.Expression}\n")
> +
> + if Root.OpCode == EFI_IFR_SUBTITLE_OP:
> + f.write(KeyIndent + "- subtitle:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + # f.write(ValueIndent + 'prompt: {} # Statement Prompt
> STRING_ID\n'.format('0x%04x' % (Info.Statement.Prompt)))
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Statement.Prompt)}'\n"
> + )
> + f.write(f"{ValueIndent}flags: {Info.Flags} # Optional Input\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_TEXT_OP:
> + f.write(KeyIndent + "- text:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + if type(Info) == EFI_IFR_TEXT:
> + # f.write(ValueIndent + 'help: {} # Statement Help
> STRING_ID\n'.format('0x%04x' % (Info.Statement.Help)))
> + # f.write(ValueIndent + 'prompt: {} # Statement Prompt
> STRING_ID\n'.format('0x%04x' % (Info.Statement.Prompt)))
> + f.write(
> + f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Statement.Help)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Statement.Prompt)}'\n"
> + )
> + if Info.TextTwo != EFI_STRING_ID_INVALID:
> + f.write(f"{ValueIndent}text:
> '{self._DisplayUniStr(Info.TextTwo)}'\n")
> +
> + if type(Info) == EFI_IFR_ACTION:
> + # f.write(ValueIndent + 'help: {} # Question Help
> STRING_ID\n'.format('0x%04x' % (Info.Question.Header.Help)))
> + # f.write(ValueIndent + 'prompt: {} # Question Prompt
> STRING_ID\n'.format('0x%04x' % (Info.Question.Header.Prompt)))
> + f.write(
> + f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Question.Header.Help)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Question.Header.Prompt)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}flags: {Info.Question.Flags} # Optional Input,
> Question Flags\n"
> + )
> + f.write(
> + f"{ValueIndent}key: {'0x%04x' % Info.Question.QuestionId} #
> Optional Input, Question QuestionId\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_ACTION_OP:
> + f.write(KeyIndent + "- action:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}config: {Info.QuestionConfig} #
> QuestionConfig\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_ONE_OF_OP:
> + f.write(KeyIndent + "- oneof:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}maximum: {Info.Data.MaxValue} #
> Optional Input\n")
> + f.write(f"{ValueIndent}minimum: {Info.Data.MinValue} # Optional
> Input\n")
> + f.write(f"{ValueIndent}step: {'0x%0x' % Info.Data.Step} # Optional
> Input\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_ONE_OF_OPTION_OP:
> + f.write(KeyIndent + "- option: \n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + # f.write(ValueIndent + 'text: {} # Option
> STRING_ID\n'.format('0x%04x' % (Info.Option)))
> + f.write(f"{ValueIndent}text: '{self._DisplayUniStr(Info.Option)}'\n")
> + f.write(f"{ValueIndent}flags: {Info.Flags} # Optional Input\n")
> + f.write(f"{ValueIndent}type: {'0x%04x' % Info.Type} # Optional
> Input\n")
> +
> + if type(Root.Data) == IfrOneOfOption:
> + if Root.Position is not None:
> + f.write(f"{ValueIndent}position: '{Root.Position}' # for
> reference\n")
> + f.write(f"{ValueIndent}value: {Root.Data.ValueStream}\n")
> + # need to save the ValueStream in YamlTree.py
> + # f.write(ValueIndent + "value: {}\n".format(Info.Value))
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_DEFAULT_OP:
> + f.write(KeyIndent + "- default:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}defaultId: {Info.DefaultId}\n")
> + f.write(f"{ValueIndent}type: {Info.Type}\n")
> + if type(Root.Data) == IfrDefault: # vfrConstantValueField[Node]
> + # if Root.Data.ValueStream != "":
> + # if "formsetguid" in Root.Dict:
> + # Root.Data.ValueStream.replace =
> Root.Data.ValueStream.replace(
> + # Root.Dict["formsetguid"].Key,
> + #
> self.PreProcessDB.RevertValue(Root.Dict["formsetguid"].Value),
> + # )
> + # if "devicepath" in Root.Dict:
> + # Root.Data.ValueStream.replace =
> Root.Data.ValueStream.replace(
> + # Root.Dict["devicepath"].Key,
> + #
> self.PreProcessDB.RevertValue(Root.Dict["devicepath"].Value),
> + # )
> + # if "string" in Root.Dict:
> + # Root.Data.ValueStream.replace =
> Root.Data.ValueStream.replace(Root.Dict["string"].Key,\
> + # self.PreProcessDB.RevertValue(Root.Dict["string"].Value))
> + f.write(f"{ValueIndent}value: {Root.Data.ValueStream}\n")
> +
> + elif type(Root.Data) == IfrDefault2:
> + f.write(f"{ValueIndent}value_exp:
> '{Root.Child[0].Expression}'\n")
> +
> + # if Root.Data.DefaultStore != '':
> + # f.write(ValueIndent + 'defaultstore: {} # for
> reference\n'.format(Root.Data.DefaultStore))
> +
> + if Root.OpCode == EFI_IFR_ORDERED_LIST_OP:
> + f.write(KeyIndent + "- orderedlist:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}maxcontainers: {Info.MaxContainers} ##
> Optional Input\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_NUMERIC_OP:
> + f.write(KeyIndent + "- numeric:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}maximum: {Info.Data.MaxValue} #
> Optional Input\n")
> + f.write(f"{ValueIndent}minimum: {Info.Data.MinValue} # Optional
> Input\n")
> + f.write(f"{ValueIndent}step: {Info.Data.Step} # Optional Input\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_CHECKBOX_OP:
> + f.write(KeyIndent + "- checkbox:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_TIME_OP:
> + f.write(KeyIndent + "- time:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_DATE_OP:
> + f.write(KeyIndent + "- date:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_STRING_OP:
> + f.write(KeyIndent + "- string:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}minsize: {Info.MinSize}\n")
> + f.write(f"{ValueIndent}maxsize: {Info.MaxSize}\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_PASSWORD_OP:
> + f.write(KeyIndent + "- password:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}minsize: {Info.MinSize}\n")
> + f.write(f"{ValueIndent}maxsize: {Info.MaxSize}\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_RESET_BUTTON_OP:
> + f.write(KeyIndent + "- resetbutton:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + # f.write(ValueIndent + 'prompt: {} # Statement Prompt
> STRING_ID\n'.format('0x%04x' % (Info.Statement.Prompt)))
> + # f.write(ValueIndent + 'help: {} # Statement Help
> STRING_ID\n'.format('0x%04x' % (Info.Statement.Help)))
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Statement.Prompt)}'\n"
> + )
> + f.write(f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Statement.Help)}'\n")
> + f.write(f"{ValueIndent}defaultid: {Info.DefaultId}\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_REF_OP:
> + f.write(KeyIndent + "- goto:\n")
> + self.DumpQuestionInfos(Root, f, ValueIndent)
> +
> + if type(Root.Data) == IfrRef4:
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(
> + f"{ValueIndent}formsetguid: '{{{Info.FormSetId.Data1:#x},
> {Info.FormSetId.Data2:#x}, {Info.FormSetId.Data3:#x}, {{ {', '.join(f'{x:#x}' for x
> in Info.FormSetId.Data4)}}}}}' # Optional Input\n"
> + )
> + # f.write(ValueIndent + 'question: {} # Optional
> Input\n'.format('0x%x' % (Info.QuestionId)))
> + f.write(
> + f"{ValueIndent}devicepath:
> '{self._DisplayUniStr(Info.DevicePath)}' # Optional Input\n"
> + )
> + # f.write(
> + # f"{ValueIndent}devicepath: {'0x%04x' % Info.DevicePath} #
> Optional Input\n"
> + # )
> +
> + if type(Root.Data) == IfrRef3:
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(
> + f"{ValueIndent}formsetguid: '{{{Info.FormSetId.Data1:#x},
> {Info.FormSetId.Data2:#x}, {Info.FormSetId.Data3:#x}, {{ {', '.join(f'{x:#x}' for x
> in Info.FormSetId.Data4)}}}}}' # Optional Input\n"
> + )
> + f.write(
> + f"{ValueIndent}question: {'0x%x' % Info.QuestionId} #
> Optional Input\n"
> + )
> +
> + if type(Root.Data) == IfrRef2:
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(f"{ValueIndent}question: {Info.QuestionId} # Optional
> Input\n")
> +
> + if type(Root.Data) == IfrRef:
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(
> + f"{ValueIndent}question: {'0x%04x' %
> Info.Question.QuestionId} # Optional Input\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_REFRESH_OP:
> + f.write(KeyIndent + "- refresh:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}interval: {Info.RefreshInterval} #
> RefreshInterval\n")
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_DEVICE_OP:
> + f.write(KeyIndent + "- varstoredevice:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}devicepath: {Info.DevicePath} #
> DevicePath\n")
> +
> + if Root.OpCode == EFI_IFR_REFRESH_ID_OP:
> + f.write(KeyIndent + "- refreshguid:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.RefreshEventGroupId.Data1:#x},
> {Info.RefreshEventGroupId.Data2:#x}, {Info.RefreshEventGroupId.Data3:#x},
> {{ {', '.join(f'{x:#x}' for x in Info.RefreshEventGroupId.Data4)}}}}}' \n"
> + )
> +
> + if Root.OpCode == EFI_IFR_WARNING_IF_OP:
> + f.write(KeyIndent + "- warningif:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}prompt: '{self._DisplayUniStr(Info.Warning)}' #
> Optional Input\n"
> + )
> + # f.write(f"{ValueIndent}warning: {Info.Warning}\n") #pending
> + f.write(f"{ValueIndent}timeout: {Info.TimeOut} # optional
> input\n")
> + f.write(f"{ValueIndent}expression: {Root.Expression}\n")
> +
> + if Root.OpCode == EFI_IFR_GUID_OP:
> + if type(Root.Data) == IfrLabel: # type(Info) ==
> EFI_IFR_GUID_LABEL
> + f.write(KeyIndent + "- label:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}number: {'0x%x' % Info.Number} #
> Number\n")
> +
> + if type(Root.Data) == IfrBanner:
> + f.write(KeyIndent + "- banner:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}title: '{self._DisplayUniStr(Info.Title)}' #
> Optional Input\n"
> + )
> + # f.write(f"{ValueIndent}title: {Info.Title}\n")
> + f.write(f"{ValueIndent}line: {Info.LineNumber}\n")
> + f.write(f"{ValueIndent}align: {Info.Alignment}\n")
> +
> + if type(Root.Data) == IfrTimeout:
> + f.write(KeyIndent + "- timeout in banner:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}timeout: {Info.TimeOut}\n")
> +
> + if type(Root.Data) == IfrClass:
> + f.write(f"{KeyIndent}class: {Info.Class}\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if not Root.Data.HasSubClass:
> + f.write(KeyIndent + "component: \n")
> +
> + if type(Root.Data) == IfrSubClass:
> + f.write(f"{KeyIndent}subclass: {Info.SubClass}\n")
> + f.write(KeyIndent + "component: \n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if type(Root.Data) == IfrExtensionGuid:
> + if type(Root.Parent.Data) == IfrExtensionGuid:
> + Root.Level -= 1
> + KeyIndent = " " * ((Root.Level * 2 - 1) * 2)
> + ValueIndent = " " * ((Root.Level * 2 + 1) * 2)
> + f.write(KeyIndent + "- guidop:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}' \n"
> + )
> + if Root.Data.GetDataType() != "":
> + # f.write(ValueIndent + 'databuffer: #optional input\n')
> + f.write(f"{ValueIndent}{Root.Data.GetDataType()}: \n")
> + for data in Root.Data.GetFieldList():
> + f.write(f"{ValueIndent} {data[0]}: {'0x%x' % data[1]}\n")
> +
> + if Root.OpCode == EFI_IFR_INCONSISTENT_IF_OP:
> + if type(Root.Data) == IfrInconsistentIf2: #
> + f.write(KeyIndent + "- inconsistentif:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + # f.write(ValueIndent + 'prompt: {} #
> STRING_ID\n'.format('0x%04x' % (Info.Error)))
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Error)}'\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_NO_SUBMIT_IF_OP:
> + f.write(KeyIndent + "- nosubmitif:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + # f.write(ValueIndent + 'prompt: {} #
> STRING_ID\n'.format('0x%04x' % (Info.Error)))
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Error)}'\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_READ_OP:
> + f.write(KeyIndent + "- read:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_WRITE_OP:
> + f.write(KeyIndent + "- write:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_VALUE_OP and Root.Parent.OpCode !=
> EFI_IFR_DEFAULT_OP: #
> + f.write(KeyIndent + "- value:\n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_MODAL_TAG_OP:
> + f.write(KeyIndent + "- modal: \n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + if Root.OpCode == EFI_IFR_LOCKED_OP:
> + f.write(KeyIndent + "- locked: \n")
> + # f.write(f"{ValueIndent}buffer: {self.DumpBuffer(Root)}\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + self.LastOp = Root.OpCode
> +
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" % (self.Options.YamlFileName),
> + None,
> + )
> +
> + if Root.Child != []:
> + for ChildNode in Root.Child:
> + if Root.OpCode in ConditionOps and type(Root.Data) !=
> IfrInconsistentIf2:
> + if (
> + ChildNode.OpCode in ConditionOps
> + and type(ChildNode.Data) != IfrInconsistentIf2
> + ):
> + ChildNode.Condition = Root.Condition + " | " +
> ChildNode.Condition
> + else:
> + ChildNode.Condition = Root.Condition
> +
> + if type(ChildNode.Data) == IfrInconsistentIf2:
> + ChildNode.Level = Root.Level + 1
> + else:
> + ChildNode.Level = Root.Level
> + else:
> + if type(Root.Data) == IfrGuid and (
> + ChildNode.OpCode
> + in [EFI_IFR_CHECKBOX_OP, EFI_IFR_NUMERIC_OP,
> EFI_IFR_ONE_OF_OP]
> + ):
> + ChildNode.Level = Root.Level
> + else:
> + ChildNode.Level = Root.Level + 1
> +
> + self._DumpYamlForConfigEditorDfs(ChildNode, f)
> +
> + def _DumpYamlForXMLCLIDfs(self, Root, f):
> + try:
> + if Root is None:
> + return
> + if Root.OpCode is not None:
> + if Root.Level == 0:
> + KeyIndent = ""
> + ValueIndent = ""
> + else:
> + KeyIndent = " " * ((Root.Level * 2 - 1) * 2)
> + ValueIndent = " " * ((Root.Level * 2 + 1) * 2)
> +
> + Info = Root.Data.GetInfo()
> +
> + if Root.OpCode == EFI_IFR_FORM_SET_OP:
> + f.write(KeyIndent + "formset:\n")
> + ValueIndent = " " * (Root.Level + 1) * 2
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> + f.write(f"{ValueIndent}title:
> '{self._DisplayUniStr(Info.FormSetTitle)}'\n")
> + f.write(f"{ValueIndent}help: '{self._DisplayUniStr(Info.Help)}'\n")
> +
> + if Root.Data.ClassGuidNum != 0:
> + f.write(ValueIndent + "classguid: ")
> + for i in range(0, len(Root.Data.ClassGuid)):
> + Guid = Root.Data.GetClassGuid()[i]
> + if i != len(Root.Data.ClassGuid) - 1:
> + f.write(
> + f"'{{{Guid.Data1:#x}, {Guid.Data2:#x}, {Guid.Data3:#x},
> {{ {', '.join(f'{x:#x}' for x in Guid.Data4)}}}}}' | "
> + )
> + else:
> + f.write(
> + f"'{{{Guid.Data1:#x}, {Guid.Data2:#x}, {Guid.Data3:#x},
> {{ {', '.join(f'{x:#x}' for x in Guid.Data4)}}}}}' # Optional Input \n"
> + )
> +
> + if (
> + Root.Child != []
> + and Root.Child[0].OpCode != EFI_IFR_END_OP
> + and type(Root.Child[0].Data) != IfrSubClass
> + and type(Root.Child[0].Data) != IfrClass
> + ):
> + f.write(ValueIndent + "component: \n")
> + elif (
> + type(Root.Child[0].Data) == IfrClass
> + and type(Root.Child[1].Data) == IfrSubClass
> + ):
> + Root.Child[0].Data.HasSubClass = True
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_OP:
> + f.write(KeyIndent + "- varstore:\n")
> + f.write(f"{ValueIndent}type: {Root.Data.Type}\n")
> + if Root.Data.HasVarStoreId:
> + f.write(f"{ValueIndent}varid: {Info.VarStoreId:#04x} # Optional
> Input\n")
> + Name = "".join(chr(x) for x in Info.Name)
> + f.write(f"{ValueIndent}name: {Name}\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_EFI_OP:
> + f.write(KeyIndent + "- efivarstore:\n")
> + f.write(f"{ValueIndent}type: {Root.Data.Type}\n")
> + if Root.Data.HasVarStoreId:
> + if "varid" in Root.Dict:
> + f.write(
> + f"{ValueIndent}varid: {Info.VarStoreId:#04x} # Optional
> Input\n"
> + )
> + f.write(f"{ValueIndent}attribute: {Root.Data.AttributesText} \n")
> + if Root.Data.NameStringId:
> + f.write(
> + f"{ValueIndent}name:
> '{self._DisplayUniStr(Root.Data.NameStringId)}'\n"
> + )
> + f.write(ValueIndent + "varsize: " + Root.Data.VarSize + "\n")
> + else:
> + Name = "".join(chr(x) for x in Info.Name)
> + f.write(f"{ValueIndent}name: {Name}\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_NAME_VALUE_OP:
> + f.write(KeyIndent + "- namevaluevarstore:\n")
> + f.write(f"{ValueIndent}type: {Root.Data.Type}\n")
> + if Root.Data.HasVarStoreId:
> + f.write(f"{ValueIndent}varid: {Info.VarStoreId:#04x} # Optional
> Input\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}'\n"
> + )
> + if Root.Data.NameItemList != []:
> + f.write(ValueIndent + "nametable: \n")
> + for NameItem in Root.Data.NameItemList:
> + f.write(f"{ValueIndent} - name:
> '{self._DisplayUniStr(NameItem)}'\n")
> +
> + if Root.OpCode == EFI_IFR_DEFAULTSTORE_OP:
> + gVfrDefaultStore.UpdateDefaultType(Root)
> +
> + if Root.OpCode == EFI_IFR_SHOWN_DEFAULTSTORE_OP:
> + f.write(KeyIndent + "- defaultstore:\n")
> + f.write(f"{ValueIndent}type: {Root.Data.Type}\n")
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.DefaultName)}'\n")
> + if Root.Data.HasAttr:
> + f.write(
> + f"{ValueIndent}attribute: {'0x%04x' % Info.DefaultId} #
> Default ID, Optional input\n"
> + )
> +
> + if Root.OpCode == EFI_IFR_FORM_OP:
> + f.write(KeyIndent + "- form: \n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId} \n")
> + f.write(f"{ValueIndent}title:
> '{self._DisplayUniStr(Info.FormTitle)}'\n")
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_FORM_MAP_OP:
> + MethodMapList = Root.Data.GetMethodMapList()
> + f.write(KeyIndent + "- formmap: \n")
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId} \n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + if MethodMapList != []:
> + f.write(ValueIndent + "map: # optional input\n")
> + for MethodMap in MethodMapList:
> + f.write(f"{ValueIndent}- maptitle:
> {MethodMap.MethodTitle}\n")
> + f.write(
> + f"{ValueIndent} mapguid: '{{{{"
> + f"{MethodMap.MethodIdentifier.Data1},
> {MethodMap.MethodIdentifier.Data2},
> {MethodMap.MethodIdentifier.Data3},"
> + f"{{ {', '.join('0x%x' % x for x in
> MethodMap.MethodIdentifier.Data4)} }}"
> + f"}}}}'\n"
> + )
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_IMAGE_OP:
> + f.write(f"{ValueIndent}image: '{self._DisplayUniStr(Info.Id)}'\n")
> + if Root.OpCode == EFI_IFR_RULE_OP: #
> + f.write(f"{KeyIndent}- rule:\n")
> +
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + f.write(
> + f"{ValueIndent}name: {Root.Data.GetRuleName()}\n"
> + f"{ValueIndent}expression: {Root.Expression} \n"
> + )
> +
> + if Root.OpCode == EFI_IFR_SUBTITLE_OP:
> + f.write(KeyIndent + "- subtitle:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}text:
> '{self._DisplayUniStr(Info.Statement.Prompt)}'\n")
> +
> + if Root.Data.FlagsStream != "":
> + f.write(f"{ValueIndent}flags: {Root.Data.FlagsStream} #
> Optional Input\n")
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(f"{ValueIndent}component: \n")
> +
> + if Root.OpCode == EFI_IFR_TEXT_OP:
> + f.write(KeyIndent + "- text:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + if type(Info) == EFI_IFR_TEXT:
> + f.write(
> + f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Statement.Help)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Statement.Prompt)}'\n"
> + )
> + if Root.Data.HasTextTwo:
> + f.write(f"{ValueIndent}text:
> '{self._DisplayUniStr(Info.TextTwo)}'\n")
> + if type(Info) == EFI_IFR_ACTION:
> + f.write(
> + f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Question.Header.Help)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Question.Header.Prompt)}'\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + f"{ValueIndent}flags: {Root.Data.FlagsStream} # Optional
> Input, Question Flags\n"
> + )
> + if Root.Data.HasKey:
> + f.write(
> + f"{ValueIndent}key: {'0x%04x' % Info.Question.QuestionId}
> # Optional Input, Question QuestionId\n"
> + )
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_ACTION_OP:
> + f.write(KeyIndent + "- action:\n")
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}config: {Info.QuestionConfig} #
> QuestionConfig\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_ONE_OF_OP:
> + f.write(KeyIndent + "- oneof:\n")
> +
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> +
> + if Root.Data.HasMinMax:
> + f.write(
> + f"{ValueIndent}maximum: {'0x%0x' % Info.Data.MaxValue} #
> Optional Input\n"
> + )
> + f.write(
> + f"{ValueIndent}minimum: {'0x%0x' % Info.Data.MinValue} #
> Optional Input\n"
> + )
> +
> + if Root.Data.HasStep:
> + f.write(f"{ValueIndent}step: {Info.Data.Step} # Optional
> Input\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_ONE_OF_OPTION_OP:
> + f.write(KeyIndent + "- option: \n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}text: '{self._DisplayUniStr(Info.Option)}'\n")
> +
> + if type(Root.Data) == IfrOneOfOption:
> + if Root.Data.ValueStream != "":
> + f.write(f"{ValueIndent}value: {Root.Data.ValueStream}\n")
> +
> + if Root.Data.FlagsStream != "":
> + f.write(f"{ValueIndent}flags: {Root.Data.FlagsStream} #
> Optional Input\n")
> +
> + if Root.Data.IfrOptionKey is not None:
> + f.write(
> + f"{ValueIndent}key: {'0x%04x' %
> Root.Data.GetIfrOptionKey()} # Optional Input\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_DEFAULT_OP:
> + # specific condition here
> + if Root.Position != "Do not display":
> + f.write(KeyIndent + "- default:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + if type(Root.Data) == IfrDefault:
> + Str = Root.Data.ValueStream
> + if Str.find(";") != -1:
> + RefList = Str.split(";")
> + Str = (
> + RefList[0]
> + + ";"
> + + RefList[1]
> + + ";"
> + + f"{{{Info.Value[0].FormSetGuid.Data1:#x},
> {Info.Value[0].FormSetGuid.Data2:#x}, {Info.Value[0].FormSetGuid.Data3:#x},
> {{ {', '.join(f'{x:#x}' for x in Info.Value[0].FormSetGuid.Data4)}}}}}"
> + + ";"
> + + self._DisplayUniStr(Info.Value[0].DevicePath)
> + )
> +
> + if Str != "":
> + Str = Str.replace("{", "[").replace("}", "]")
> + if (
> + Str.find(":") != -1
> + or Str.find("/") != -1
> + or Str.find(";") != -1
> + ):
> + Str = "(" + Str + ")"
> + f.write(f"{ValueIndent}value: {Str}\n")
> +
> + elif type(Root.Data) == IfrDefault2:
> + f.write(f"{ValueIndent}value_exp:
> '{Root.Child[0].Expression}'\n")
> +
> + if Root.Data.DefaultStore != "":
> + f.write(f"{ValueIndent}defaultstore:
> {Root.Data.DefaultStore}\n")
> +
> + if Root.OpCode == EFI_IFR_ORDERED_LIST_OP:
> + f.write(KeyIndent + "- orderedlist:\n")
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + if Root.Data.HasMaxContainers:
> + f.write(
> + f"{ValueIndent}maxcontainers: {Info.MaxContainers} #
> Optional Input\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_NUMERIC_OP:
> + f.write(KeyIndent + "- numeric:\n")
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}maximum: {'0x%0x' %
> Info.Data.MaxValue}\n")
> + f.write(f"{ValueIndent}minimum: {'0x%0x' %
> Info.Data.MinValue}\n")
> +
> + if Root.Data.HasStep:
> + f.write(f"{ValueIndent}step: {Info.Data.Step} # Optional
> Input\n")
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_CHECKBOX_OP:
> + f.write(KeyIndent + "- checkbox:\n")
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_TIME_OP:
> + f.write(KeyIndent + "- time:\n")
> + if Root.Data.Hour is None:
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode !=
> EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> + else:
> + f.write(f"{ValueIndent}hour: {Root.Data.Hour}\n")
> +
> + if Root.Data.D_Hour is not None:
> + f.write(f"{ValueIndent}default_hour:
> {Root.Data.D_Hour}\n")
> +
> + f.write(f"{ValueIndent}minute: {Root.Data.Minute}\n")
> +
> + if Root.Data.D_Minute is not None:
> + f.write(f"{ValueIndent}default_minute:
> {Root.Data.D_Minute}\n")
> +
> + f.write(f"{ValueIndent}second: {Root.Data.Second}\n")
> +
> + if Root.Data.D_Second is not None:
> + f.write(f"{ValueIndent}default_second:
> {Root.Data.D_Second}\n")
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Question.Header.Prompt)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Question.Header.Help)}'\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + f"{ValueIndent}flags: {Root.Data.FlagsStream} # Optional
> input , flags\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode !=
> EFI_IFR_DEFAULT_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_DATE_OP:
> + f.write(KeyIndent + "- date:\n")
> + if Root.Data.Year is None:
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode !=
> EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> + else:
> + f.write(f"{ValueIndent}year: {Root.Data.Year}\n")
> + f.write(f"{ValueIndent}min_year: {Root.Data.Min}\n")
> + f.write(f"{ValueIndent}max_year: {Root.Data.Max}\n")
> +
> + if Root.Data.D_Year is not None:
> + f.write(f"{ValueIndent}default_year: {Root.Data.D_Year}\n")
> +
> + f.write(f"{ValueIndent}month: {Root.Data.Month}\n")
> +
> + if Root.Data.D_Month is not None:
> + f.write(f"{ValueIndent}default_month:
> {Root.Data.D_Month}\n")
> +
> + f.write(f"{ValueIndent}day: {Root.Data.Day}\n")
> +
> + if Root.Data.D_Day is not None:
> + f.write(f"{ValueIndent}default_day: {Root.Data.D_Day}\n")
> +
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Question.Header.Prompt)}'\n"
> + )
> + f.write(
> + f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Question.Header.Help)}'\n"
> + )
> +
> + if Root.Data.FlagsStream != "":
> + f.write(
> + f"{ValueIndent}flags: {Root.Data.FlagsStream} # Optional
> input , flags\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode !=
> EFI_IFR_DEFAULT_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_STRING_OP:
> + f.write(KeyIndent + "- string:\n")
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + f.write(f"{ValueIndent}minsize: {Info.MinSize}\n")
> + f.write(f"{ValueIndent}maxsize: {Info.MaxSize}\n")
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(f"{ValueIndent}component: \n")
> +
> + if Root.OpCode == EFI_IFR_PASSWORD_OP:
> + f.write(KeyIndent + "- password:\n")
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> + f.write(
> + f"{ValueIndent}minsize: {Root.Dict['minsize'].Key if 'minsize' in
> Root.Dict else Info.MinSize}\n"
> + )
> + f.write(
> + f"{ValueIndent}maxsize: {Root.Dict['maxsize'].Key if 'maxsize' in
> Root.Dict else Info.MaxSize}\n"
> + )
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(f"{ValueIndent}component: \n")
> +
> + if Root.OpCode == EFI_IFR_RESET_BUTTON_OP:
> + f.write(KeyIndent + "- resetbutton:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}defaultstore: {Root.Data.DefaultStore}\n")
> + f.write(
> + f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Statement.Prompt)}'\n"
> + )
> + f.write(f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Statement.Help)}'\n")
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_REF_OP:
> + f.write(KeyIndent + "- goto:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> +
> + if type(Root.Data) == IfrRef4:
> + f.write(
> + f"{ValueIndent}devicepath:
> '{self._DisplayUniStr(Info.DevicePath)}' # Optional Input\n"
> + )
> + f.write(
> + f"{ValueIndent}formsetguid: '{{{Info.FormSetId.Data1:#x},
> {Info.FormSetId.Data2:#x}, {Info.FormSetId.Data3:#x}, {{ {', '.join(f'{x:#x}' for x
> in Info.FormSetId.Data4)}}}}}' # Optional Input\n"
> + )
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(
> + f"{ValueIndent}question: {'0x%x' % Info.QuestionId} #
> Optional Input\n"
> + )
> +
> + if type(Root.Data) == IfrRef3:
> + f.write(
> + f"{ValueIndent}formsetguid: '{{{Info.FormSetId.Data1:#x},
> {Info.FormSetId.Data2:#x}, {Info.FormSetId.Data3:#x}, {{ {', '.join(f'{x:#x}' for x
> in Info.FormSetId.Data4)}}}}}' # Optional Input\n"
> + )
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(
> + f"{ValueIndent}question: {'0x%x' % Info.QuestionId} #
> Optional Input\n"
> + )
> +
> + if type(Root.Data) == IfrRef2:
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> + f.write(
> + f"{ValueIndent}question: {'0x%x' % Info.QuestionId} #
> Optional Input\n"
> + )
> +
> + if type(Root.Data) == IfrRef:
> + f.write(f"{ValueIndent}formid: {'0x%x' % Info.FormId}\n")
> +
> + self._DumpQuestionInfosForXMLCLI(Root, f, ValueIndent)
> +
> + if Root.Child != [] and Root.Child[0].OpCode != EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_REFRESH_OP:
> + f.write(KeyIndent + "- refresh:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}interval: {Info.RefreshInterval} #
> RefreshInterval\n")
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_DEVICE_OP:
> + f.write(KeyIndent + "- varstoredevice:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}devicepath: {Info.DevicePath} #
> DevicePath\n")
> +
> + if Root.OpCode == EFI_IFR_REFRESH_ID_OP:
> + f.write(KeyIndent + "- refreshguid:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.RefreshEventGroupId.Data1:#x},
> {Info.RefreshEventGroupId.Data2:#x}, {Info.RefreshEventGroupId.Data3:#x},
> {{ {', '.join(f'{x:#x}' for x in Info.RefreshEventGroupId.Data4)}}}}}' \n"
> + )
> +
> + if Root.OpCode == EFI_IFR_WARNING_IF_OP:
> + f.write(KeyIndent + "- warningif:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}prompt: '{self._DisplayUniStr(Info.Warning)}' #
> Optional Input\n"
> + )
> + if Root.Data.HasTimeOut:
> + f.write(f"{ValueIndent}timeout: {Info.TimeOut} # optional input
> \n")
> + f.write(f"{ValueIndent}expression: {Root.Expression}\n")
> +
> + if Root.OpCode == EFI_IFR_GUID_OP:
> + if type(Root.Data) == IfrLabel:
> + f.write(KeyIndent + "- label:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}number: {'0x%x' % Info.Number} #
> Number\n")
> +
> + if type(Root.Data) == IfrBanner:
> + f.write(KeyIndent + "- banner:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}title: '{self._DisplayUniStr(Info.Title)}' #
> Optional Input\n"
> + )
> + if not Root.Data.HasTimeOut:
> + if "line" in Root.Dict:
> + f.write(f"{ValueIndent}line: {Root.Dict['line'].Key}\n")
> + else:
> + f.write(f"{ValueIndent}line: {Info.LineNumber}\n")
> + f.write(f"{ValueIndent}align: {Root.Dict['align'].Key}\n")
> + else:
> + f.write(f"{ValueIndent}timeout: {Root.Data.TimeOut}\n")
> +
> + if type(Root.Data) == IfrClass:
> + f.write(KeyIndent + "class: " + Root.Data.ClassStr + "\n")
> + if not Root.Data.HasSubClass:
> + f.write(KeyIndent + "component: \n")
> +
> + if type(Root.Data) == IfrSubClass:
> + f.write(KeyIndent + "subclass: " + Root.Data.SubClassStr + "\n")
> + f.write(KeyIndent + "component: \n")
> +
> + if type(Root.Data) == IfrExtensionGuid:
> + if type(Root.Parent.Data) == IfrExtensionGuid:
> + Root.Level -= 1
> + KeyIndent = " " * ((Root.Level * 2 - 1) * 2)
> + ValueIndent = " " * ((Root.Level * 2 + 1) * 2)
> + f.write(KeyIndent + "- guidop:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(
> + f"{ValueIndent}guid: '{{{Info.Guid.Data1:#x},
> {Info.Guid.Data2:#x}, {Info.Guid.Data3:#x}, {{ {', '.join(f'{x:#x}' for x in
> Info.Guid.Data4)}}}}}' \n"
> + )
> + if Root.Data.GetDataType() != "":
> + f.write(f"{ValueIndent}{Root.Data.GetDataType()}: \n")
> + for data in Root.Data.GetFieldList():
> + f.write(f"{ValueIndent} {data[0]}: {data[1]:#x}\n")
> +
> + if Root.OpCode == EFI_IFR_NO_SUBMIT_IF_OP:
> + f.write(KeyIndent + "- nosubmitif:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Error)}'\n")
> + if Root.Data.FlagsStream != "":
> + f.write(ValueIndent + "flags: " + Root.Data.FlagsStream + "\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_READ_OP:
> + f.write(KeyIndent + "- read:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_WRITE_OP:
> + f.write(KeyIndent + "- write:\n")
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_VALUE_OP and Root.Parent.OpCode !=
> EFI_IFR_DEFAULT_OP: #
> + f.write(KeyIndent + "- value:\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> +
> + if Root.OpCode == EFI_IFR_MODAL_TAG_OP:
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(KeyIndent + "- modal: null\n")
> +
> + if Root.OpCode == EFI_IFR_LOCKED_OP:
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + f.write(KeyIndent + "- locked: null\n")
> +
> + if Root.OpCode == EFI_IFR_SUPPRESS_IF_OP:
> + f.write(KeyIndent + "- suppressif:\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> + if len(Root.Child) > 2 and Root.Child[len(Root.Child) - 2].OpCode
> not in ExpOps:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_DISABLE_IF_OP:
> + # If the disable node is inserted after the formset ends, do not
> show it in source yml
> + # use the expression content to tell if the disable node is inserted
> after the formset ends
> + if Root.Expression is not None:
> + f.write(KeyIndent + "- disableif:\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> + if (
> + len(Root.Child) > 2
> + and Root.Child[len(Root.Child) - 2].OpCode not in ExpOps
> + ):
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_GRAY_OUT_IF_OP:
> + f.write(KeyIndent + "- grayoutif:\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> + if len(Root.Child) > 2 and Root.Child[len(Root.Child) - 2].OpCode
> not in ExpOps:
> + f.write(ValueIndent + "component: \n")
> +
> + if Root.OpCode == EFI_IFR_INCONSISTENT_IF_OP:
> + f.write(KeyIndent + "- inconsistentif:\n")
> + f.write(f"{ValueIndent}expression: '{Root.Expression}'\n")
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Error)}'\n")
> + if Root.Data.FlagsStream != "":
> + f.write(ValueIndent + "flags: " + Root.Data.FlagsStream + "\n")
> + self.LastOp = Root.OpCode
> +
> + except Exception:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" % (self.Options.YamlFileName),
> + None,
> + )
> +
> + if Root.Child != []:
> + for ChildNode in Root.Child:
> + if Root.OpCode in ConditionOps:
> + ChildNode.Level = Root.Level + 1
> + elif type(Root.Data) == IfrGuid and (
> + ChildNode.OpCode in [EFI_IFR_CHECKBOX_OP,
> EFI_IFR_NUMERIC_OP, EFI_IFR_ONE_OF_OP]
> + ):
> + ChildNode.Level = Root.Level
> + else:
> + ChildNode.Level = Root.Level + 1
> +
> + self._DumpYamlForXMLCLIDfs(ChildNode, f)
> +
> + return
> +
> + def DumpQuestionInfos(self, Root, f, ValueIndent):
> + Info = Root.Data.GetInfo()
> + if Root.Condition is not None:
> + f.write(f"{ValueIndent}condition: '{Root.Condition}'\n")
> + if Root.Position is not None:
> + f.write(f"{ValueIndent}position: '{Root.Position}' # for reference\n")
> + f.write(f"{ValueIndent}questionid: {Info.Question.QuestionId}\n")
> + f.write(f"{ValueIndent}varstoreid: {Info.Question.VarStoreId} # Optional
> Input\n")
> + f.write(
> + f"{ValueIndent}varname: {Info.Question.VarStoreInfo.VarName} #
> Question VarName\n"
> + )
> + f.write(
> + f"{ValueIndent}varoffset: {Info.Question.VarStoreInfo.VarOffset} #
> Question VarOffset\n"
> + )
> + f.write(f"{ValueIndent}questionflags: {Info.Question.Flags} # Optional
> Input\n")
> + f.write(f"{ValueIndent}prompt:
> '{self._DisplayUniStr(Info.Question.Header.Prompt)}'\n")
> + f.write(f"{ValueIndent}help:
> '{self._DisplayUniStr(Info.Question.Header.Help)}'\n")
> + if (
> + Root.OpCode != EFI_IFR_REF_OP
> + and Root.OpCode != EFI_IFR_ACTION_OP
> + and Root.OpCode != EFI_IFR_PASSWORD_OP
> + ):
> + f.write(f"{ValueIndent}opcodeflags: {Info.Flags:#x} # optional
> input\n")
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> new file mode 100644
> index 0000000000..6c94d1ff39
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> @@ -0,0 +1,2226 @@
> +## @file
> +# Vfr common library functions.
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +import os
> +from enum import Enum
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrError import gVfrErrorHandle, VfrReturnCode
> +from VfrCompiler.IfrCommon import EFI_SUCCESS, EFI_NOT_FOUND,
> RETURN_SUCCESS
> +from abc import ABCMeta, abstractmethod
> +from Common.LongFilePathSupport import LongFilePath
> +
> +VFR_PACK_SHOW = 0x02
> +VFR_PACK_ASSIGN = 0x01
> +VFR_PACK_PUSH = 0x04
> +VFR_PACK_POP = 0x08
> +DEFAULT_PACK_ALIGN = 0x8
> +DEFAULT_ALIGN = 1
> +ZERO_ALIGN = 0
> +MAX_PACK_ALIGN = 0x10
> +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:
> + def __init__(self, Identifier, Number):
> + self.Identifier = Identifier
> + self.Number = Number
> + self.Next = None
> +
> + def Match(self, Identifier):
> + if Identifier is None:
> + return True
> + elif self.Identifier is None:
> + return False
> + return self.Identifier == Identifier
> +
> +
> +class SVfrDataType:
> + 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:
> + 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(c_ulonglong), sizeof(c_ulonglong)),
> + InternalTypes("UINT32", EFI_IFR_TYPE_NUM_SIZE_32, sizeof(c_ulong),
> sizeof(c_ulong)),
> + InternalTypes("UINT16", EFI_IFR_TYPE_NUM_SIZE_16, sizeof(c_ushort),
> sizeof(c_ushort)),
> + InternalTypes("UINT8", EFI_IFR_TYPE_NUM_SIZE_8, sizeof(c_ubyte),
> sizeof(c_ubyte)),
> + InternalTypes("BOOLEAN", EFI_IFR_TYPE_BOOLEAN, sizeof(c_ubyte),
> sizeof(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(c_ushort)),
> + InternalTypes("EFI_STRING_ID", EFI_IFR_TYPE_STRING, sizeof(c_ushort),
> sizeof(c_ushort)),
> + InternalTypes("EFI_HII_TIME", EFI_IFR_TYPE_TIME, sizeof(EFI_HII_TIME),
> sizeof(c_ubyte)),
> + InternalTypes("EFI_HII_REF", EFI_IFR_TYPE_REF, sizeof(EFI_HII_REF),
> sizeof(EFI_GUID)),
> +]
> +
> +
> +class VfrVarDataTypeDB:
> + 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 Clear(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
> + pNewType.Next = self.DataTypeList
> + self.DataTypeList = 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))
> + gVfrErrorHandle.PrintMsg(LineNum, "Warning", Msg)
> +
> + if Action & VFR_PACK_PUSH:
> + pNew = SVfrPackStackNode(Identifier, self.PackAlign)
> + if pNew is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> + pNew.Next = self.PackStack
> + self.PackStack = pNew
> +
> + if Action & VFR_PACK_POP:
> + pNode = None
> + if self.PackStack is None:
> + gVfrErrorHandle.PrintMsg(LineNum, "Error", "#pragma
> pack(pop...) : more pops than pushes")
> +
> + pNode = self.PackStack
> + while pNode is not None:
> + if pNode.Match(Identifier) is 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 == ZERO_ALIGN or PackAlign > MAX_PACK_ALIGN:
> + gVfrErrorHandle.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 is None:
> + return VfrReturnCode.VFR_RETURN_ERROR_SKIPED
> +
> + if Type is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> + # need to limit the value of the type
> + self.NewDataType.Type = 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 is None:
> + return VfrReturnCode.VFR_RETURN_ERROR_SKIPED
> +
> + if TypeName is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + if len(TypeName) >= MAX_NAME_LEN:
> + return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
> +
> + pType = self.DataTypeList
> + while pType is not 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.NewDataType.Next = self.DataTypeList
> + self.DataTypeList = self.NewDataType
> + if self.FirstNewDataTypeName is None:
> + self.FirstNewDataTypeName = self.NewDataType.TypeName
> +
> + self.NewDataType = None
> +
> + # two definitions
> + def GetDataTypeSizeByTypeName(self, TypeName):
> + Size = 0
> + pDataType = self.DataTypeList
> + while pDataType is not 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 is not 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
> +
> + if VarStr[s] == ".":
> + s += 1
> + return ArrayIdx, s, FName, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + if 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
> +
> + if 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 is None or Type is None:
> + return None, VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + pField = Type.Members
> + while pField is not 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 is not None and pField.IsBitField:
> + return True, ReturnCode
> + return False, ReturnCode
> +
> + def GetFieldOffset(self, Field, ArrayIdx, IsBitField):
> + if Field is 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 is None:
> + return 0
> + return Field.FieldType.Type
> +
> + def GetFieldSize(self, Field, ArrayIdx, BitField):
> + if Field is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + if (ArrayIdx == INVALID_ARRAY_INDEX) and (Field.ArrayNum != 0):
> + return Field.FieldType.TotalSize * Field.ArrayNum
> + elif BitField:
> + return Field.BitWidth
> + 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 is 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 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 is not None:
> + if pTmp.FieldName == FieldName:
> + return VfrReturnCode.VFR_RETURN_REDEFINED
> + pTmp = pTmp.Next
> +
> + Align = min(self.PackAlign, pFieldType.Align)
> + pNewField = SVfrDataField()
> + if pNewField is 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 is None:
> + self.NewDataType.Members = pNewField
> + pNewField.Next = None
> + else:
> + pTmp = self.NewDataType.Members
> + while pTmp.Next is not 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 is not None) and (len(FieldName) >= MAX_NAME_LEN):
> + return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
> +
> + if Width == 0 and FieldName is not None:
> + return VfrReturnCode.VFR_RETURN_INVALID_PARAMETER
> +
> + pTmp = self.NewDataType.Members
> + while pTmp is not None:
> + if FieldName is not 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 is 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 is None:
> + self.NewDataType.Members = pNewField
> + pNewField.Next = None
> + else:
> + pTmp = self.NewDataType.Members
> + while pTmp.Next is not 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 is not None) and (pTmp.IsBitField) and
> (pTmp.FieldType.TypeName == pNewField.FieldType.TypeName)
> + cond2 = (pTmp is not 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 is None:
> + return None, VfrReturnCode.VFR_RETURN_ERROR_SKIPED
> +
> + DataType = self.DataTypeList
> + while DataType is not 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 is None:
> + return False
> +
> + pType = self.DataTypeList
> + while pType is not None:
> + if pType.TypeName == TypeName:
> + break
> + pType = pType.Next
> +
> + if pType is None:
> + return False
> +
> + pTmp = pType.Members
> + while pTmp is not None:
> + if pTmp.IsBitField:
> + return True
> + pTmp = pTmp.Next
> + return False
> +
> + def Dump(self, f):
> + f.write("\n\n*************\n")
> + f.write("\t\tPackAlign = " + str(self.PackAlign) + "\n")
> + pNode = self.DataTypeList
> + while pNode is not None:
> + f.write("\t\tstruct {} : Align : [{}] TotalSize :
> [{:#x}]\n\n".format(pNode.TypeName, pNode.Align, pNode.TotalSize))
> + f.write("\t\tstruct {}".format(str(pNode.TypeName)) + "\t{\n")
> + FNode = pNode.Members
> + while FNode is not None:
> + if FNode.ArrayNum > 0:
> + f.write("\t\t\t+{:0>8d}[{:0>8x}] {}[{}] <{}>\n".format(FNode.Offset,
> FNode.Offset, FNode.FieldName, FNode.ArrayNum,
> FNode.FieldType.TypeName))
> + f.write("\t\t\t+{:0>8d}[{:0>8x}] {}[{}] <{}>\n".format(FNode.Offset,
> FNode.BitOffset, FNode.FieldName, FNode.ArrayNum,
> FNode.FieldType.TypeName))
> + elif FNode.FieldName is not None:
> + f.write("\t\t\t+{:0>8d}[{:0>8x}] {} <{}>\n".format(FNode.Offset,
> FNode.Offset, FNode.FieldName, FNode.FieldType.TypeName))
> + f.write("\t\t\t+{:0>8d}[{:0>8x}] {} <{}>\n".format(FNode.Offset,
> FNode.BitOffset, FNode.FieldName, FNode.FieldType.TypeName))
> + else:
> + f.write("\t\t\t+{:0>8d}[{:0>8x}] <{}>\n".format(FNode.Offset,
> FNode.Offset, FNode.FieldType.TypeName))
> + f.write("\t\t\t+{:0>8d}[{:0>8x}] <{}>\n".format(FNode.Offset,
> FNode.BitOffset, FNode.FieldType.TypeName))
> + FNode = FNode.Next
> + f.write("\t\t};\n")
> + f.write("---------------------------------------------------------------\n")
> + pNode = pNode.Next
> +
> f.write("*********************************************************
> ******\n")
> +
> +
> +class SVfrDefaultStoreNode:
> + 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 VfrDefaultStore:
> + def __init__(self):
> + self.DefaultStoreList = None
> +
> + def Clear(self):
> + self.DefaultStoreList = None
> +
> + def RegisterDefaultStore(self, ObjAddr: EFI_IFR_DEFAULTSTORE, RefName,
> DefaultStoreNameId, DefaultId):
> + if RefName == "" or RefName is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + pNode = self.DefaultStoreList
> + while pNode is not None:
> + if pNode.RefName == RefName:
> + return VfrReturnCode.VFR_RETURN_REDEFINED
> + pNode = pNode.Next
> +
> + pNode = SVfrDefaultStoreNode(ObjAddr, RefName,
> DefaultStoreNameId, DefaultId)
> +
> + if pNode is None:
> + return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode.Next = self.DefaultStoreList
> + self.DefaultStoreList = pNode
> +
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def UpdateDefaultType(self, DefaultNode):
> + pNode = self.DefaultStoreList
> + while pNode is not None:
> + if pNode.ObjAddr.DefaultId == DefaultNode.Data.GetDefaultId():
> + DefaultNode.Data.SetType(pNode.RefName)
> + pNode = pNode.Next
> +
> + def DefaultIdRegistered(self, DefaultId):
> + pNode = self.DefaultStoreList
> + while pNode is not None:
> + if pNode.DefaultId == DefaultId:
> + return True
> + pNode = pNode.Next
> +
> + return False
> +
> + def ReRegisterDefaultStoreById(self, DefaultId, RefName,
> DefaultStoreNameId):
> + pNode = self.DefaultStoreList
> + while pNode is not None:
> + if pNode.DefaultId == DefaultId:
> + break
> + pNode = pNode.Next
> +
> + if pNode is None:
> + return None, VfrReturnCode.VFR_RETURN_UNDEFINED
> +
> + if pNode.DefaultStoreNameId == EFI_STRING_ID_INVALID:
> + pNode.DefaultStoreNameId = DefaultStoreNameId
> + pNode.RefName = RefName
> + if pNode.ObjAddr is not 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 is not 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 is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> + pNode = self.DefaultStoreList
> + while pNode is not None:
> + if pNode.DefaultId == DefaultId:
> + break
> + pNode = pNode.Next
> + if pNode is None:
> + return VfrReturnCode.VFR_RETURN_UNDEFINED
> + gVfrBufferConfig.Open()
> + if gVfrBufferConfig.Select(VarStoreName, VarStoreGuid) == 0:
> + Returnvalue = gVfrBufferConfig.Write(
> + "a",
> + VarStoreName,
> + VarStoreGuid,
> + pNode.DefaultId,
> + Type,
> + BaseInfo.Info.VarOffset,
> + BaseInfo.VarTotalSize,
> + Value,
> + )
> + if Returnvalue != 0:
> + gVfrBufferConfig.Close()
> + return VfrReturnCode(Returnvalue)
> + gVfrBufferConfig.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 is not None:
> + self.VarstoreType = EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI
> + elif DataType is not 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
> + self.Guid = Guid
> + self.Id = Id
> + if Type is not 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):
> + self.Type = Type
> + self.Offset = Offset
> + self.Width = Width
> + self.Next = None
> + self.Value = Value
> +
> +
> +class VfrBufferConfig:
> + __metaclass__ = ABCMeta
> +
> + def __init__(self):
> + self.ItemListHead = None
> + 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 is None or Guid is None:
> + self.ItemListPos = self.ItemListHead
> + return 0
> + p = self.ItemListHead
> + while p is not None:
> + if p.Name != Name or p.Guid.__cmp__(Guid) is False:
> + p = p.Next
> + continue
> + if Id is not None:
> + if p.Id is None or p.Id != Id:
> + p = p.Next
> + continue
> + elif p.Id is not 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 is None:
> + return 2
> + if self.ItemListHead is 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):
> + Ret = self.Select(Name, Guid)
> + if Ret != 0:
> + return Ret
> +
> + if Mode == "a":
> + if self.Select(Name, Guid, Id) != 0:
> + pItem = SConfigItem(Name, Guid, Id, Type, Offset, Width, Value)
> + if pItem is None:
> + return 2
> +
> + if self.ItemListHead is 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 is not None:
> + if pInfo.Offset == Offset:
> + return 0
> + pInfo = pInfo.Next
> +
> + pInfo = SConfigInfo(Type, Offset, Width, Value)
> + if pInfo is None:
> + return 2
> +
> + pInfo.Next = self.ItemListPos.InfoStrList
> + self.ItemListPos.InfoStrList = pInfo
> +
> + elif Mode == "d":
> + 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":
> + if Id is not None:
> + self.ItemListPos.Id = Id
> + else:
> + return 1
> + return 0
> +
> +
> +gVfrBufferConfig = VfrBufferConfig()
> +
> +
> +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 VfrDataStorage:
> + def __init__(self):
> + # SVfrVarStorageNode
> + self.BufferVarStoreList = None
> + 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 Clear(self):
> + # SVfrVarStorageNode
> + self.BufferVarStoreList = None
> + self.EfiVarStoreList = None
> + self.NameVarStoreList = None
> + self.CurrVarStorageNode = None
> + self.NewVarStorageNode = None
> + self.BufferFieldInfoListHead = None
> + self.mBufferFieldInfoListTail = None
> + self.FreeVarStoreIdBitMap = []
> + for _ 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 is not None:
> + # If has guid info, compare the guid field.
> + 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 is not None:
> + if pNode.DataType.TypeName != DataTypeName:
> + pNode = pNode.Next
> + continue
> + if VarGuid is not None:
> + if pNode.Guid.__cmp__(VarGuid):
> + return pNode, VfrReturnCode.VFR_RETURN_SUCCESS
> + elif MatchNode is 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 is 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 is not 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 is not 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 is not 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 is not 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 is None or Guid is None or DataTypeDB is 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) is False:
> + return VfrReturnCode.VFR_RETURN_VARSTOREID_REDEFINED
> + self.MarkVarStoreIdUsed(VarStoreId)
> + pNew = SVfrVarStorageNode(StoreName, VarStoreId, Guid, Attr, Flag,
> None, DataType, IsBitVarStore)
> +
> + if pNew is None:
> + return VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNew.Next = self.BufferVarStoreList
> + self.BufferVarStoreList = pNew
> +
> + if gVfrBufferConfig.Register(StoreName, Guid) != 0:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def DeclareNameVarStoreBegin(self, StoreName, VarStoreId):
> + if StoreName is 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) is False:
> + return VfrReturnCode.VFR_RETURN_VARSTOREID_REDEFINED
> + self.MarkVarStoreIdUsed(VarStoreId)
> +
> + pNode = SVfrVarStorageNode(StoreName, VarStoreId)
> +
> + if pNode is 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 is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + if self.CurrVarStorageNode is 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 is not None:
> + if pNode.VarStoreId == VarStoreId:
> + return pNode.VarstoreType
> + pNode = pNode.Next
> +
> + pNode = self.EfiVarStoreList
> + while pNode is not None:
> + if pNode.VarStoreId == VarStoreId:
> + return pNode.VarstoreType
> + pNode = pNode.Next
> +
> + pNode = self.NameVarStoreList
> + while pNode is not None:
> + if pNode.VarStoreId == VarStoreId:
> + return pNode.VarstoreType
> + pNode = pNode.Next
> +
> + return VarStoreType
> +
> + def GetVarStoreName(self, VarStoreId):
> + pNode = self.BufferVarStoreList
> + while pNode is not None:
> + if pNode.VarStoreId == VarStoreId:
> + return pNode.VarStoreName,
> VfrReturnCode.VFR_RETURN_SUCCESS
> + pNode = pNode.Next
> +
> + pNode = self.EfiVarStoreList
> + while pNode is not None:
> + if pNode.VarStoreId == VarStoreId:
> + return pNode.VarStoreName,
> VfrReturnCode.VFR_RETURN_SUCCESS
> + pNode = pNode.Next
> +
> + pNode = self.NameVarStoreList
> + while pNode is not 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 is not 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 is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + if self.CurrVarStorageNode is None:
> + return VfrReturnCode.VFR_RETURN_GET_EFIVARSTORE_ERROR
> +
> + BaseInfo.Info.VarName = self.CurrVarStorageNode.EfiVar.EfiVarName
> + BaseInfo.VarTotalSize = self.CurrVarStorageNode.EfiVar.EfiVarSize
> +
> + if BaseInfo.VarTotalSize == EFI_IFR_TYPE_NUM_8_BIT_SIZE:
> + BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_8
> + elif BaseInfo.VarTotalSize == EFI_IFR_TYPE_NUM_16_BIT_SIZE:
> + BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_16
> + elif BaseInfo.VarTotalSize == EFI_IFR_TYPE_NUM_32_BIT_SIZE:
> + BaseInfo.VarType = EFI_IFR_TYPE_NUM_SIZE_32
> + elif BaseInfo.VarTotalSize == EFI_IFR_TYPE_NUM_64_BIT_SIZE:
> + 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 is not None:
> + if pNode.VarStoreId == VarStoreId:
> + VarGuid = pNode.Guid
> + return VarGuid
> + pNode = pNode.Next
> +
> + pNode = self.EfiVarStoreList
> + while pNode is not None:
> + if pNode.VarStoreId == VarStoreId:
> + VarGuid = pNode.Guid
> + return VarGuid
> + pNode = pNode.Next
> +
> + pNode = self.NameVarStoreList
> + while pNode is not 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 is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + if self.BufferFieldInfoListHead is None:
> + self.BufferFieldInfoListHead = pNew
> + self.mBufferFieldInfoListTail = pNew
> + else:
> + self.mBufferFieldInfoListTail.Next = pNew
> + self.mBufferFieldInfoListTail = pNew
> +
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> +
> +class VfrStringDB:
> + def __init__(self):
> + self.StringFileName = None
> +
> + def SetStringFileName(self, StringFileName):
> + self.StringFileName = StringFileName
> +
> + def GetBestLanguage(self, SupportedLanguages, Language):
> + if SupportedLanguages is None or Language is None:
> + return False
> +
> + LanguageLength = 0
> + # Determine the length of the first RFC 4646 language code in Language
> + while LanguageLength < len(Language) and
> Language[LanguageLength] != 0 and Language[LanguageLength] != ";":
> + LanguageLength += 1
> +
> + Supported = SupportedLanguages
> + # Trim back the length of Language used until it is empty
> + while LanguageLength > 0:
> + # Loop through all language codes in SupportedLanguages
> + while len(Supported) > 0:
> + # Skip ';' characters in Supported
> + while len(Supported) > 0 and Supported[0] == ";":
> + Supported = Supported[1:]
> +
> + CompareLength = 0
> + # Determine the length of the next language code in Supported
> + while CompareLength < len(Supported) and
> Supported[CompareLength] != 0 and Supported[CompareLength] != ";":
> + CompareLength += 1
> +
> + # If Language is longer than the Supported, then skip to the next
> language
> + if LanguageLength > CompareLength:
> + continue
> +
> + # See if the first LanguageLength characters in Supported match
> Language
> + if Supported[:LanguageLength] == Language:
> + return True
> +
> + Supported = Supported[CompareLength:]
> +
> + # Trim Language from the right to the next '-' character
> + LanguageLength -= 1
> + while LanguageLength > 0 and Language[LanguageLength] != "-":
> + LanguageLength -= 1
> +
> + # No matches were found
> + return False
> +
> + def GetUnicodeStringTextSize(self, StringSrc):
> + StringSize = sizeof(c_ushort)
> + StringStr = cast(StringSrc, POINTER(c_ushort))
> +
> + while StringStr.contents.value != "\0":
> + StringSize += sizeof(c_ushort)
> + StringStr = cast(addressof(StringStr.contents) + sizeof(c_ushort),
> POINTER(c_ushort))
> +
> + return StringSize
> +
> + def FindStringBlock(self, string_data, string_id):
> + current_string_id = 1
> + block_hdr = string_data
> + block_size = 0
> + offset = 0
> +
> + while block_hdr[0] != EFI_HII_SIBT_END:
> + block_type = block_hdr[0]
> +
> + if block_type == EFI_HII_SIBT_STRING_SCSU:
> + offset = sizeof(EFI_HII_STRING_BLOCK)
> + string_text_ptr = block_hdr + offset
> + block_size += offset + len(str(string_text_ptr)) + 1
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRING_SCSU_FONT:
> + offset = sizeof(EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK) -
> sizeof(c_uint8)
> + string_text_ptr = block_hdr + offset
> + block_size += offset + len(str(string_text_ptr)) + 1
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRINGS_SCSU:
> + string_count = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint16)],
> + byteorder="little",
> + )
> + string_text_ptr = block_hdr +
> sizeof(EFI_HII_SIBT_STRINGS_SCSU_BLOCK) - sizeof(c_uint8)
> + block_size += string_text_ptr - block_hdr
> +
> + for _ in range(string_count):
> + block_size += len(str(string_text_ptr)) + 1
> +
> + if current_string_id == string_id:
> + block_type = block_hdr[0]
> + string_text_offset = string_text_ptr - string_data
> + return EFI_SUCCESS
> +
> + string_text_ptr = string_text_ptr + len(str(string_text_ptr)) + 1
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRINGS_SCSU_FONT:
> + string_count = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) + sizeof(c_uint16)],
> + byteorder="little",
> + )
> + string_text_ptr = block_hdr +
> sizeof(EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK) - sizeof(c_uint8)
> + block_size += string_text_ptr - block_hdr
> +
> + for _ in range(string_count):
> + block_size += len(str(string_text_ptr)) + 1
> +
> + if current_string_id == string_id:
> + block_type = block_hdr[0]
> + string_text_offset = string_text_ptr - string_data
> + return EFI_SUCCESS
> +
> + string_text_ptr = string_text_ptr + len(str(string_text_ptr)) + 1
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRING_UCS2:
> + offset = sizeof(EFI_HII_STRING_BLOCK)
> + string_text_ptr = block_hdr + offset
> + string_size = self.GetUnicodeStringTextSize(string_text_ptr)
> + block_size += offset + string_size
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRING_UCS2_FONT:
> + offset = sizeof(EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK) -
> sizeof(c_ushort)
> + string_text_ptr = block_hdr + offset
> + string_size = self.GetUnicodeStringTextSize(string_text_ptr)
> + block_size += offset + string_size
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRINGS_UCS2:
> + offset = len(EFI_HII_SIBT_STRINGS_UCS2_BLOCK) - len(c_ushort)
> + string_text_ptr = block_hdr + offset
> + block_size += offset
> + string_count = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint16)],
> + byteorder="little",
> + )
> +
> + for _ in range(string_count):
> + string_size = self.GetUnicodeStringTextSize(string_text_ptr)
> + block_size += string_size
> +
> + if current_string_id == string_id:
> + block_type = block_hdr[0]
> + string_text_offset = string_text_ptr - string_data
> + return EFI_SUCCESS
> +
> + string_text_ptr = string_text_ptr + string_size
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_STRINGS_UCS2_FONT:
> + offset = len(EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK) -
> len(c_ushort)
> + string_text_ptr = block_hdr + offset
> + block_size += offset
> + string_count = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) + sizeof(c_uint16)],
> + byteorder="little",
> + )
> +
> + for _ in range(string_count):
> + string_size = self.GetUnicodeStringTextSize(string_text_ptr)
> + block_size += string_size
> +
> + if current_string_id == string_id:
> + block_type = block_hdr[0]
> + string_text_offset = string_text_ptr - string_data
> + return EFI_SUCCESS
> +
> + string_text_ptr = string_text_ptr + string_size
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_DUPLICATE:
> + if current_string_id == string_id:
> + string_id = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint16)],
> + byteorder="little",
> + )
> + current_string_id = 1
> + block_size = 0
> + else:
> + block_size += sizeof(EFI_HII_SIBT_DUPLICATE_BLOCK)
> + current_string_id += 1
> +
> + elif block_type == EFI_HII_SIBT_SKIP1:
> + skip_count =
> int.from_bytes(block_hdr[sizeof(EFI_HII_STRING_BLOCK)], byteorder="little")
> + current_string_id += skip_count
> + block_size += sizeof(EFI_HII_SIBT_SKIP1_BLOCK)
> +
> + elif block_type == EFI_HII_SIBT_SKIP2:
> + skip_count = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint16)],
> + byteorder="little",
> + )
> + current_string_id += skip_count
> + block_size += sizeof(EFI_HII_SIBT_SKIP2_BLOCK)
> +
> + elif block_type == EFI_HII_SIBT_EXT1:
> + length8 = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) + sizeof(c_uint8)],
> + byteorder="little",
> + )
> + block_size += length8
> +
> + elif block_type == EFI_HII_SIBT_EXT2:
> + length32 = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) :
> sizeof(EFI_HII_STRING_BLOCK) + sizeof(c_uint8) + sizeof(c_uint32)],
> + byteorder="little",
> + )
> + block_size += length32
> +
> + if string_id > 0 and string_id != (c_uint16)(-1):
> + block_type = block_hdr[0]
> +
> + if string_id == current_string_id - 1:
> + if block_type in (EFI_HII_SIBT_SKIP2, EFI_HII_SIBT_SKIP1):
> + return EFI_NOT_FOUND
> + return EFI_SUCCESS
> +
> + if string_id < current_string_id - 1:
> + return EFI_NOT_FOUND
> +
> + block_hdr = string_data + block_size
> +
> + return EFI_NOT_FOUND
> +
> + def GetVarStoreNameFormStringId(self, StringId):
> + pInFile = None
> + NameOffset = 0
> + Length = 0
> + StringPtr = None
> + StringName = None
> + UnicodeString = None
> + VarStoreName = None
> + DestTmp = None
> + Current = None
> + Status = None
> + BlockType = 0
> + PkgHeader = None
> +
> + if self.StringFileName is None:
> + return None
> +
> + try:
> + with open(LongFilePath(self.StringFileName), "rb") as pInFile:
> + # Get file length
> + pInFile.seek(0, os.SEEK_END)
> + Length = pInFile.tell()
> + pInFile.seek(0, os.SEEK_SET)
> +
> + # Get file data
> + StringPtr = bytearray(pInFile.read())
> + except Exception:
> + return None
> +
> + PkgHeader = EFI_HII_STRING_PACKAGE_HDR.from_buffer(StringPtr)
> +
> + # Check the String package
> + if PkgHeader.Header.Type != EFI_HII_PACKAGE_STRINGS:
> + return None
> +
> + # Search the language, get best language based on RFC 4647 matching
> algorithm
> + Current = StringPtr
> + while not self.GetBestLanguage("en", PkgHeader.Language):
> + Current += PkgHeader.Header.Length
> + PkgHeader = EFI_HII_STRING_PACKAGE_HDR.from_buffer(Current)
> +
> + # If can't find string package based on language, just return the first
> string package
> + if Current - StringPtr >= Length:
> + Current = StringPtr
> + PkgHeader = EFI_HII_STRING_PACKAGE_HDR.from_buffer(StringPtr)
> + break
> +
> + Current += PkgHeader.HdrSize
> +
> + # Find the string block according to the stringId
> + Status, NameOffset, BlockType = self.FindStringBlock(Current, StringId)
> + if Status != RETURN_SUCCESS:
> + return None
> +
> + # Get varstore name according to the string type
> + if BlockType in [
> + EFI_HII_SIBT_STRING_SCSU,
> + EFI_HII_SIBT_STRING_SCSU_FONT,
> + EFI_HII_SIBT_STRINGS_SCSU,
> + EFI_HII_SIBT_STRINGS_SCSU_FONT,
> + ]:
> + StringName = Current + NameOffset
> + VarStoreName = StringName.decode("utf-8")
> + elif BlockType in [
> + EFI_HII_SIBT_STRING_UCS2,
> + EFI_HII_SIBT_STRING_UCS2_FONT,
> + EFI_HII_SIBT_STRINGS_UCS2,
> + EFI_HII_SIBT_STRINGS_UCS2_FONT,
> + ]:
> + UnicodeString = Current + NameOffset
> + Length = self.GetUnicodeStringTextSize(UnicodeString)
> + DestTmp = bytearray(Length // 2 + 1)
> + VarStoreName = DestTmp
> + index = 0
> + while UnicodeString[index] != "\0":
> + DestTmp[index] = ord(UnicodeString[index])
> + index += 1
> + DestTmp[index] = "\0"
> + else:
> + return None
> +
> + return VarStoreName
> +
> +
> +gVfrStringDB = VfrStringDB()
> +
> +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 VfrRulesDB:
> + def __init__(self):
> + self.RuleList = None
> + self.FreeRuleId = EFI_VARSTORE_ID_START
> +
> + def RegisterRule(self, RuleName):
> + if RuleName is None:
> + return
> +
> + pNew = SVfrRuleNode(RuleName, self.FreeRuleId)
> + if pNew is None:
> + return
> + self.FreeRuleId += 1
> + pNew.Next = self.RuleList
> + self.RuleList = pNew
> +
> + def GetRuleId(self, RuleName):
> + if RuleName is None:
> + return EFI_RULE_ID_INVALID
> +
> + pNode = self.RuleList
> + while pNode is not 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 VfrQuestionDB:
> + 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 is None:
> + return VfrReturnCode.VFR_RETURN_FATAL_ERROR
> +
> + pNode = self.QuestionList
> + while pNode is not 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 is not 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, gFormPkg):
> + if (Name is not None) and (self.FindQuestionByName(Name) ==
> VfrReturnCode.VFR_RETURN_SUCCESS):
> + return QuestionId, VfrReturnCode.VFR_RETURN_REDEFINED
> +
> + pNode = SVfrQuestionNode(Name, VarIdStr)
> + if pNode is None:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + if QuestionId == EFI_QUESTION_ID_INVALID:
> + QuestionId = self.GetFreeQuestionId()
> + else:
> + if self.CheckQuestionIdFree(QuestionId) is False:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_QUESTIONID_REDEFINED
> + self.MarkQuestionIdUsed(QuestionId)
> +
> + pNode.QuestionId = QuestionId
> + pNode.Next = self.QuestionList
> + self.QuestionList = pNode
> +
> + gFormPkg.DoPendingAssign(VarIdStr, QuestionId)
> +
> + return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def UpdateQuestionId(self, QId, NewQId, gFormPkg):
> + if QId == NewQId:
> + # don't update
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + if self.CheckQuestionIdFree(NewQId) is False:
> + return VfrReturnCode.VFR_RETURN_REDEFINED
> +
> + pNode = self.QuestionList
> + TempList = []
> + while pNode is not 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
> + gFormPkg.DoPendingAssign(pNode.VarIdStr, NewQId)
> +
> + self.MarkQuestionIdUsed(NewQId)
> +
> + return VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def GetQuestionId(self, Name, VarIdStr=None, QType=None):
> + QuestionId = EFI_QUESTION_ID_INVALID
> + BitMask = 0x00000000
> + if QType is not None:
> + QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> +
> + if Name is None and VarIdStr is None:
> + return QuestionId, BitMask, QType
> +
> + pNode = self.QuestionList
> + while pNode is not None:
> + if Name is not None:
> + if pNode.Name != Name:
> + pNode = pNode.Next
> + continue
> +
> + if VarIdStr is not None:
> + if pNode.VarIdStr != VarIdStr:
> + pNode = pNode.Next
> + continue
> +
> + QuestionId = pNode.QuestionId
> + BitMask = pNode.BitMask
> + if QType is not None:
> + QType = pNode.QType
> + break
> +
> + return QuestionId, BitMask, QType
> +
> + def RegisterNewDateQuestion(self, Name, BaseVarId, QuestionId,
> gFormPkg):
> + if BaseVarId == "" and Name is None:
> + if QuestionId == EFI_QUESTION_ID_INVALID:
> + QuestionId = self.GetFreeQuestionId()
> + else:
> + if self.CheckQuestionIdFree(QuestionId) is 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 is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[1],
> DATE_MONTH_BITMASK)
> + if pNode is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[2], DATE_DAY_BITMASK)
> + if pNode is not 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) is 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]
> +
> + gFormPkg.DoPendingAssign(VarIdStrList[0], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[1], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[2], QuestionId)
> +
> + return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def RegisterNewTimeQuestion(self, Name, BaseVarId, QuestionId,
> gFormPkg):
> + if BaseVarId == "" and Name is None:
> + if QuestionId == EFI_QUESTION_ID_INVALID:
> + QuestionId = self.GetFreeQuestionId()
> + else:
> + if self.CheckQuestionIdFree(QuestionId) is 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 is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[1],
> TIME_MINUTE_BITMASK)
> + if pNode is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[2],
> TIME_SECOND_BITMASK)
> + if pNode is not 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) is 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]
> +
> + gFormPkg.DoPendingAssign(VarIdStrList[0], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[1], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[2], QuestionId)
> +
> + return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def RegisterRefQuestion(self, Name, BaseVarId, QuestionId, gFormPkg):
> + if BaseVarId == "" and Name is 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 is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[1])
> + if pNode is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[2])
> + if pNode is not None:
> + pNodeList.append(pNode)
> + else:
> + return QuestionId,
> VfrReturnCode.VFR_RETURN_OUT_FOR_RESOURCES
> +
> + pNode = SVfrQuestionNode(Name, VarIdStrList[3])
> + if pNode is not 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) is 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]
> +
> + gFormPkg.DoPendingAssign(VarIdStrList[0], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[1], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[2], QuestionId)
> + gFormPkg.DoPendingAssign(VarIdStrList[3], QuestionId)
> +
> + return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def RegisterOldDateQuestion(self, YearVarId, MonthVarId, DayVarId,
> QuestionId, gFormPkg):
> + pNodeList = []
> + if YearVarId == "" or MonthVarId == "" or DayVarId == "" or \
> + YearVarId is None or MonthVarId is None or DayVarId is None:
> + return QuestionId, VfrReturnCode.VFR_RETURN_ERROR_SKIPED
> +
> + pNode = SVfrQuestionNode(None, YearVarId, DATE_YEAR_BITMASK)
> + if pNode is not 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 is not 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 is not 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) is 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]
> +
> + gFormPkg.DoPendingAssign(YearVarId, QuestionId)
> + gFormPkg.DoPendingAssign(MonthVarId, QuestionId)
> + gFormPkg.DoPendingAssign(DayVarId, QuestionId)
> +
> + return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def RegisterOldTimeQuestion(self, HourVarId, MinuteVarId, SecondVarId,
> QuestionId, gFormPkg):
> + pNodeList = []
> + if HourVarId == "" or MinuteVarId == "" or SecondVarId == "" \
> + or HourVarId is None or MinuteVarId is None or SecondVarId is None:
> + return QuestionId, VfrReturnCode.VFR_RETURN_ERROR_SKIPED
> +
> + pNode = SVfrQuestionNode(None, HourVarId, TIME_HOUR_BITMASK)
> + if pNode is not 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 is not 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 is not 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) is 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]
> +
> + gFormPkg.DoPendingAssign(HourVarId, QuestionId)
> + gFormPkg.DoPendingAssign(MinuteVarId, QuestionId)
> + gFormPkg.DoPendingAssign(SecondVarId, QuestionId)
> +
> + return QuestionId, VfrReturnCode.VFR_RETURN_SUCCESS
> +
> + def PrintAllQuestion(self, FileName):
> + with open(FileName, "w") as f:
> + pNode = self.QuestionList
> + while pNode is not None:
> + f.write("Question VarId is {} and QuestionId is
> ".format(pNode.VarIdStr))
> + f.write("%d\n" % (pNode.QuestionId))
> + pNode = pNode.Next
> +
> + f.close()
> diff --git a/BaseTools/Source/Python/VfrCompiler/README.md
> b/BaseTools/Source/Python/VfrCompiler/README.md
> index e91d41c88d..b50a7b23cf 100644
> --- a/BaseTools/Source/Python/VfrCompiler/README.md
> +++ b/BaseTools/Source/Python/VfrCompiler/README.md
> @@ -1,20 +1,68 @@
> -# 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/VfrCom
> pile.
>
> -
>
> -### 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
> +# Python VfrCompiler Tool
> +## Overview
> +This python VfrCompiler tool is the python implementation of the edk2
> VfrCompiler tool which C implementation locates at
> https://github.com/tianocore/edk2/tree/master/BaseTools/Source/C/VfrCom
> pile.
> +
> +This python implementation not only covers the same usage as the C version
> VfrCompiler, but also extends several new features.
> +
> +### Introduction
> +The core function of the original C VfrCompiler tool is to convert VFR files
> into IFR binaries. However, the VFR format syntax is uncommon and has poor
> readability for users. Additionally, the C tool doesn't gather or store default
> variable information, except for binary generation. When modifications are
> required, developers have to deal with the abstract IFR binary, resulting in
> inefficiency. To address these challenges, this python tool generates YAML
> format files from VFR files. This approach allows for preservation of the VFR
> file's opcode layout and hierarchy, simplifying readability. Moreover, the tool
> generates an additional JSON file to provide a more accessible presentation of
> variable-related information. In a few words, the new tool offers the same
> usage as the original C VfrCompiler while expanding functionality with the
> YAML/JSON output, enhancing readability and adaptability.
> +
> +### 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 grammars and functions.
> +- Cover the same usage as the edk2 C VfrCompiler. The tool is able to
> compiles VFR into .c/lst/hpk output files.
> +- Extract variable information from each VFR file to JSON. The output JSON
> file stores the data structures and default values of variables.
> +- Convert each VFR source format to an equivalent YAML. The generated
> YAML file covers the same format contents in the Vfr file.
> +
> +### Known issues
> +- Issue 1 - Test Coverage and Method
> + - The current python vfrcompiler tool does not have a full code coverage
> test.
> + - Should add unit tests for higher code coverage.
> + - The test should be enabled into Azure pipelines for retriggering.
> + - The current test script uses some output binaries for test input, will
> remove these binaries, and save the necessary part content of it directly into
> the test script itself.
> +- Issue 2 - Code style
> + - The current python vfrcompiler tool has some coding style still like C style
> which not follows the python standardize rule.
> + - Should enhance GUID usage with 'uuid' pip module;
> + - Should figure out common way for Status Code processing;
> + - The current python vfrcompiler tool need docstring description for code
> explanation.
> +- Issue 3 - New generated YAML format
> + - The current YAML format is a reference version, and we warmly welcome
> everyone to provide feedback.
> +- Future extension
> + - The tool will extend new functions, which is able to compile yaml files.
> This feature will be added in future update.
> +
> +### Use with Build System
> +To use the VfrCompiler Python Tool with Build System, please do the
> following steps in the build command.
> +1. Locate the **VfrCompiler** folder to path
> **'\edk2\BaseTools\Source\Python'.**
> +1. Open **'build_rule.template'** file in path
> **'\edk2\BaseTools\Conf\'.**
> + - Find the C VFR command line `$(VFR)" $(VFR_FLAGS) --string-db
> $(OUTPUT_DIR)(+)$(MODULE_NAME)StrDefs.hpk --output-directory
> ${d_path} $(OUTPUT_DIR)(+)${s_base}.i` in **build_rule.template** file.
> There are two C VFR commands in it.
> + - Add new command line `"$(PYVFR)" ${src} --string-db
> $(OUTPUT_DIR)(+)$(MODULE_NAME)StrDefs.hpk -w $(WORKSPACE) -m
> $(MODULE_NAME) -o $(OUTPUT_DIR) --vfr` after each VFR command lines.
> +2. Open **'tools_def.template'** file in path **'\edk2\BaseTools\Conf\'.**
> + - Find the C VFR_PATH command line `*_*_*_VFR_PATH =
> VfrCompile` in **tools_def.template** file.
> + - Add new command line `*_*_*_PYVFR_PATH = PyVfrCompile`
> after the VFR_PATH command line.
> +3. For windows build, create a **PyVfrCompile.bat** file in path
> **'C:\edk2\BaseTools\BinWrappers\WindowsLike'.**
> + - Add the following lines in the created **PyVfrCompile.bat** file.
> + ```
> + @setlocal
> + @set ToolName=IfrCompiler
> + @set
> PYTHONPATH=%PYTHONPATH%;%BASE_TOOLS_PATH%\Source\Python;%BAS
> E_TOOLS_PATH%\Source\Python\VfrCompiler
> + @%PYTHON_COMMAND% -m %ToolName% %*
> + ```
> +4. For Unix build, create a **PyVfrCompile** file in path
> **'C:\edk2\BaseTools\BinWrappers\PosixLike'.**
> + - Add the following lines in the created **PyVfrCompile** file.
> + ```
> + #!/usr/bin/env bash
> + #python `dirname $0`/RunToolFromSource.py `basename $0` $*
> +
> + # If a ${PYTHON_COMMAND} command is available, use it in preference
> to python
> + if command -v ${PYTHON_COMMAND} >/dev/null 2>&1; then
> + python_exe=${PYTHON_COMMAND}
> + fi
> + full_cmd=${BASH_SOURCE:-$0} # see
> http://mywiki.wooledge.org/BashFAQ/028 for a discussion of why $0 is not a
> good choice here
> + dir=$(dirname "$full_cmd")
> + cmd=${full_cmd##*/}
> +
> + export
> PYTHONPATH="$dir/../../Source/Python:$dir/../../Source/Python/VfrCompiler
> :$dir/../../Source/Python${PYTHONPATH:+:"$PYTHONPATH"}"
> + exec "${python_exe:-python}" -m IfrCompiler "$@"
> + ```
> +5. Add Env: run `pip install antlr4-python3-runtime==4.7.1` based on the
> original build environment.
> +6. Run Build Command: `build -p OvmfPkg\OvmfPkgIa32X64.dsc -a IA32 -a
> X64 -j build.log`
> +`
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrError.py
> b/BaseTools/Source/Python/VfrCompiler/VfrError.py
> deleted file mode 100644
> index 31c479a7d1..0000000000
> --- a/BaseTools/Source/Python/VfrCompiler/VfrError.py
> +++ /dev/null
> @@ -1,162 +0,0 @@
> -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_OPCO
> DE:
>
> - ": 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/BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py
> b/BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py
> deleted file mode 100644
> index 944b1fe193..0000000000
> --- a/BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py
> +++ /dev/null
> @@ -1,2738 +0,0 @@
> -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/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> index 39de106a52..1768586e1c 100644
> --- a/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> @@ -1,1887 +1,1921 @@
> -grammar VfrSyntax;
>
> -options {
>
> - language=Python;
>
> -}
>
> -@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
> +//// @file
> +// vfr syntax
> +//
> +// Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +// SPDX-License-Identifier: BSD-2-Clause-Patent
> +////
> +grammar VfrSyntax;
> +options {
> + language=Python;
> +}
> +@header{
> +
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrFormPkg import *
> +from VfrCompiler.IfrUtility import *
> +from VfrCompiler.IfrTree import *
> +from VfrCompiler.IfrError import *
> +from VfrCompiler.IfrPreProcess 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 ';'
> + ;
> +
> +// VFR FormSet Definition
> +vfrFormSetDefinition
> +locals[Node=IfrTreeNode(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=IfrTreeNode(EFI_IFR_GUID_OP)]
> + : validClassNames ('|' validClassNames)*
> + ;
> +
> +validClassNames
> +locals[ClassName=0]
> + : ClassNonDevice
> + | ClassDiskDevice
> + | ClassVideoDevice
> + | ClassNetworkDevice
> + | ClassInputDevice
> + | ClassOnBoardDevice
> + | ClassOtherDevice
> + | Number
> + ;
> +
> +subclassDefinition
> +locals[Node=IfrTreeNode(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=IfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)]
> + : 'defaultstore' N=StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' S=Number ')'
> + (',' 'attribute' '=' A=Number)? ';'
> + ;
> +
> +//2.7 VFR Variable Store Definition
> +vfrStatementVarStoreLinear
> +locals[Node=IfrTreeNode(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=IfrTreeNode(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=IfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)]
> + : 'namevaluevarstore' SN=StringIdentifier ','
> + ('varid' '=' ID=Number ',')?
> + ('name' '=' 'STRING_TOKEN' '(' Number ')' ',')+
> + 'guid' '=' guidDefinition ';'
> + ;
> +
> +vfrStatementDisableIfFormSet
> +locals[Node=IfrTreeNode(EFI_IFR_DISABLE_IF_OP)]
> + : 'disableif' vfrStatementExpression[localctx.Node] ';'
> + vfrFormSetList[localctx.Node]
> + 'endif' ';'
> + ;
> +
> +vfrStatementSuppressIfFormSet
> +locals[Node=IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
> + : 'suppressif' vfrStatementExpression[localctx.Node] ';'
> + vfrFormSetList[localctx.Node]
> + 'endif' ';'
> + ;
> +
> +guidSubDefinition[Guid]
> + : Number ',' Number ',' Number ',' Number ','
> + Number ',' Number ',' Number ',' Number
> + ;
> +
> +guidDefinition
> +locals[Node=IfrTreeNode(), Guid=EFI_GUID()]
> + : '{'
> + Number ',' Number ',' Number ','
> + ( '{' guidSubDefinition[localctx.Guid] '}'
> + | guidSubDefinition[localctx.Guid]
> + )
> + '}'
> + ;
> +
> +getStringId
> +locals[StringId='']
> + : 'STRING_TOKEN' '(' Number ')'
> + ;
> +
> +vfrQuestionHeader[Node, QType]
> + : vfrQuestionBaseInfo[Node, QType]
> + vfrStatementHeader[Node]
> + ;
> +
> +vfrQuestionBaseInfo[Node, QType]
> +locals[BaseInfo=EFI_VARSTORE_INFO(), QId=EFI_QUESTION_ID_INVALID,
> CheckFlag=True, QName=None, VarIdStr='']
> + : ('name' '=' QN=StringIdentifier ',')?
> + ('varid' '=' vfrStorageVarId[localctx.BaseInfo, localctx.CheckFlag] ',')?
> + ('questionid' '=' ID=Number ',')?
> + ;
> +
> +vfrStatementHeader[Node]
> + : '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[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=IfrTreeNode(EFI_IFR_IMAGE_OP)]
> + : 'image' '=' 'IMAGE_TOKEN' '(' Number ')'
> + ;
> +
> +vfrLockedTag
> +locals[Node=IfrTreeNode(EFI_IFR_LOCKED_OP)]
> + : 'locked'
> + ;
> +
> +vfrStatementStatTag
> +locals[Node]
> + : vfrImageTag | vfrLockedTag
> + ;
> +
> +vfrStatementStatTagList[Node]
> + : vfrStatementStatTag (',' vfrStatementStatTag)*
> + ;
> +
> +vfrFormDefinition
> +locals[Node=IfrTreeNode(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=IfrTreeNode(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=IfrTreeNode(EFI_IFR_RULE_OP)]
> + : 'rule' StringIdentifier ','
> + vfrStatementExpression[localctx.Node]
> + 'endrule' ';'
> + ;
> +
> +vfrStatementStat
> +locals[Node]
> + : vfrStatementSubTitle
> + | vfrStatementStaticText
> + | vfrStatementCrossReference
> + ;
> +
> +vfrStatementSubTitle
> +locals[Node=IfrTreeNode(EFI_IFR_SUBTITLE_OP)]
> + : '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=IfrTreeNode(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=IfrTreeNode(EFI_IFR_REF_OP),
> 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 ',')
> + )
> + |
> + ( N=Number ',' )
> + )?
> + vfrQuestionHeader[localctx.Node, localctx.QType]
> + (',' 'flags' '=' vfrGotoFlags)?
> + (',' 'key' '=' Number)?
> + (E=',' vfrStatementQuestionOptionList[localctx.Node])? ';'
> + ;
> +
> +vfrGotoFlags
> +locals[GotoFlags=0]
> + : gotoFlagsField('|' gotoFlagsField)*
> + ;
> +
> +gotoFlagsField
> +locals[Flag=0]
> + : N=Number | questionheaderFlagsField
> + ;
> +
> +vfrStatementResetButton
> +locals[Node=IfrTreeNode(EFI_IFR_RESET_BUTTON_OP)]
> + : 'resetbutton'
> + 'defaultstore' '=' N=StringIdentifier ','
> + vfrStatementHeader[localctx.Node] ','
> + (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=IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)]
> + : 'inconsistentif'
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node]
> + 'endif' (';')?
> + ;
> +
> +vfrStatementNoSubmitIf //
> +locals[Node=IfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)]
> + : 'nosubmitif'
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node]
> + 'endif' (';')?
> + ;
> +
> +vfrStatementDisableIfQuest
> +locals[Node=IfrTreeNode(EFI_IFR_DISABLE_IF_OP)]
> + : 'disableif' vfrStatementExpression[localctx.Node] ';'
> + vfrStatementQuestionOptionList[localctx.Node]
> + 'endif' (';')?
> + ;
> +
> +vfrStatementRefresh
> +locals[Node=IfrTreeNode(EFI_IFR_REFRESH_OP)]
> + : 'refresh' 'interval' '=' Number
> + ;
> +
> +vfrStatementVarstoreDevice
> +locals[Node=IfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)]
> + : 'varstoredevice' '=' 'STRING_TOKEN' '(' Number ')' ','
> + ;
> +
> +vfrStatementRefreshEvent
> +locals[Node=IfrTreeNode(EFI_IFR_REFRESH_ID_OP)]
> + : 'refreshguid' '=' guidDefinition ','
> + ;
> +
> +vfrStatementWarningIf //
> +locals[Node=IfrTreeNode(EFI_IFR_WARNING_IF_OP)]
> + : 'warningif'
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + ('timeout' '=' Number ',')?
> + vfrStatementExpression[localctx.Node]
> + '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=IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
> + : 'suppressif' vfrStatementExpression[localctx.Node] ';'
> + ('flags' '=' flagsField ('|' flagsField )* ',')?
> + vfrStatementQuestionOptionList[localctx.Node]
> + 'endif' (';')?
> + ;
> +
> +vfrStatementGrayOutIfQuest
> +locals[Node=IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
> + : 'grayoutif' vfrStatementExpression[localctx.Node] ';'
> + ('flags' '=' flagsField ('|' flagsField )* ',')?
> + vfrStatementQuestionOptionList[localctx.Node]
> + 'endif' (';')?
> + ;
> +
> +
> +vfrStatementDefault
> +locals[Node=IfrTreeNode(EFI_IFR_DEFAULT_OP)]
> + : D='default'
> + ( ( V=vfrStatementValue ','
> + | '=' vfrConstantValueField ','
> + )
> + ( 'defaultstore' '=' SN=StringIdentifier ','
> + )?
> + )
> + ;
> +
> +vfrStatementValue
> +locals[Node=IfrTreeNode(EFI_IFR_VALUE_OP)]
> + : 'value' '=' vfrStatementExpression[localctx.Node]
> + ;
> +
> +vfrStatementOptions
> +locals[Node]
> + : vfrStatementOneOfOption
> + ;
> +
> +vfrStatementOneOfOption
> +locals[Node=IfrTreeNode(EFI_IFR_ONE_OF_OPTION_OP)]
> + : 'option'
> + 'text' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'value' '=' vfrConstantValueField ','
> + F='flags' '=' vfrOneOfOptionFlags (',' 'key' '=' KN=Number) ? (T=','
> 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=IfrTreeNode(EFI_IFR_READ_OP)]
> + : 'read' vfrStatementExpression[localctx.Node] ';'
> + ;
> +
> +vfrStatementWrite
> +locals[Node=IfrTreeNode(EFI_IFR_WRITE_OP)]
> + : 'write' vfrStatementExpression[localctx.Node] ';'
> + ;
> +
> +vfrStatementQuestionOptionList[Node]
> + : (vfrStatementQuestionOption)*
> + ;
> +
> +
> +
> +vfrStatementQuestionOption
> +locals[Node]
> + : vfrStatementQuestionTag | vfrStatementQuestionOptionTag
> + ;
> +
> +vfrStatementBooleanType
> +locals[Node]
> + : vfrStatementCheckBox | vfrStatementAction
> + ;
> +
> +vfrStatementCheckBox
> +locals[Node=IfrTreeNode(EFI_IFR_CHECKBOX_OP),GuidNode=IfrTreeNode(EF
> I_IFR_GUID_OP), QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : L='checkbox'
> + vfrQuestionBaseInfo[localctx.Node, localctx.QType]
> + vfrStatementHeader[localctx.Node] ','
> + (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=IfrTreeNode(EFI_IFR_ACTION_OP),
> QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : 'action'
> + vfrQuestionHeader[localctx.Node, 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=IfrTreeNode(EFI_IFR_NUMERIC_OP),
> GuidNode=IfrTreeNode(EFI_IFR_GUID_OP),
> QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : 'numeric'
> + vfrQuestionBaseInfo[localctx.Node, localctx.QType]
> + vfrStatementHeader[localctx.Node] ','
> + (F='flags' '=' vfrNumericFlags ',')?
> + ('key' '=' Number ',')?
> + vfrSetMinMaxStep[localctx.Node]
> + vfrStatementQuestionOptionList[localctx.Node]
> + 'endnumeric' ';'
> + ;
> +
> +vfrSetMinMaxStep[Node] // CIfrMinMaxStepData
> + : 'minimum' '=' (N1='-')? I=Number ','
> + 'maximum' '=' (N2='-')? A=Number ','
> + ('step' '=' S=Number ',')?
> + ;
> +
> +vfrNumericFlags
> +locals[HFlags=0, LFlags=0, IsDisplaySpecified=False, UpdateVarType=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=IfrTreeNode(EFI_IFR_ONE_OF_OP),
> GuidNode=IfrTreeNode(EFI_IFR_GUID_OP),
> QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : 'oneof'
> + vfrQuestionBaseInfo[localctx.Node, localctx.QType]
> + vfrStatementHeader[localctx.Node] ','
> + (F='flags' '=' vfrOneofFlagsField ',')? //
> + (vfrSetMinMaxStep[localctx.Node])?
> + vfrStatementQuestionOptionList[localctx.Node]
> + 'endoneof' ';'
> + ;
> +
> +vfrOneofFlagsField
> +locals[HFlags=0, LFlags=0, UpdateVarType=False]
> + : numericFlagsField ('|' numericFlagsField)*
> + ;
> +
> +vfrStatementStringType
> +locals[Node]
> + : vfrStatementString | vfrStatementPassword
> + ;
> +
> +vfrStatementString
> +locals[Node=IfrTreeNode(EFI_IFR_STRING_OP),
> QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : 'string'
> + vfrQuestionHeader[localctx.Node, 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=IfrTreeNode(EFI_IFR_PASSWORD_OP),
> QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : 'password'
> + vfrQuestionHeader[localctx.Node, 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=IfrTreeNode(EFI_IFR_ORDERED_LIST_OP),
> QType=EFI_QUESION_TYPE.QUESTION_NORMAL]
> + : 'orderedlist'
> + vfrQuestionHeader[localctx.Node, 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=IfrTreeNode(EFI_IFR_DATE_OP),
> QType=EFI_QUESION_TYPE.QUESTION_DATE, Val=EFI_HII_DATE()]
> + : 'date'
> + ( ( vfrQuestionHeader[localctx.Node, localctx.QType] ','
> + (F1='flags' '=' vfrDateFlags ',')?
> + vfrStatementQuestionOptionList[localctx.Node]
> + )
> + |
> + ( 'year' 'varid' '=' StringIdentifier '.' StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
> + minMaxDateStepDefault[localctx.Node, localctx.Val, 0]
> + 'month' 'varid' '=' StringIdentifier '.' StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
> + minMaxDateStepDefault[localctx.Node, localctx.Val, 1]
> + 'day' 'varid' '=' StringIdentifier '.' StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
> + minMaxDateStepDefault[localctx.Node, localctx.Val, 2]
> + (F2='flags' '=' vfrDateFlags ',')?
> + (vfrStatementInconsistentIf)*
> + )
> + )
> + 'enddate' ';'
> + ;
> +
> +minMaxDateStepDefault[Node, 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=IfrTreeNode(EFI_IFR_TIME_OP),
> QType=EFI_QUESION_TYPE.QUESTION_TIME, Val=EFI_HII_TIME()]
> + : 'time'
> + ( ( vfrQuestionHeader[localctx.Node, localctx.QType] ','
> + (F1='flags' '=' vfrTimeFlags ',')?
> + vfrStatementQuestionOptionList[localctx.Node]
> + )
> + |
> + (
> + 'hour' 'varid' '=' StringIdentifier '.' StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
> + minMaxTimeStepDefault[localctx.Node, localctx.Val, 0]
> + 'minute' 'varid' '=' StringIdentifier '.' StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
> + minMaxTimeStepDefault[localctx.Node, localctx.Val, 1]
> + 'second' 'varid' '=' StringIdentifier '.' StringIdentifier ','
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + 'help' '=' 'STRING_TOKEN' '(' Number ')' ','
> + minMaxTimeStepDefault[localctx.Node, localctx.Val, 2]
> + (F2='flags' '=' vfrTimeFlags ',')?
> + (vfrStatementInconsistentIf)*
> + )
> + )
> + 'endtime' ';'
> + ;
> +
> +minMaxTimeStepDefault[Node, 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=IfrTreeNode(EFI_IFR_DISABLE_IF_OP)]
> + : 'disableif' vfrStatementExpression[localctx.Node] ';'
> + (vfrStatementStatList)*
> + 'endif' ';'
> + ;
> +
> +
> +// Compatible for framework vfr file
> +vfrStatementgrayoutIfSuppressIf
> +locals[Node]
> + : 'suppressif'
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node] ';'
> + ;
> +
> +vfrStatementsuppressIfGrayOutIf
> +locals[Node]
> + : 'grayoutif'
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node] ';'
> + ;
> +
> +vfrStatementSuppressIfStatNew
> +locals[Node=IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)]
> + : 'suppressif'
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node] ';'
> + (vfrStatementStatList)*
> + 'endif' ';'
> + ;
> +
> +vfrStatementGrayOutIfStatNew
> +locals[Node=IfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)]
> + : 'grayoutif'
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node] ';'
> + (vfrStatementStatList)*
> + 'endif' ';'
> + ;
> +
> +vfrStatementInconsistentIfStat
> +locals[Node=IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)]
> + : 'inconsistentif'
> + 'prompt' '=' 'STRING_TOKEN' '(' Number ')' ','
> + ('flags' '=' flagsField ('|' flagsField)* ',')?
> + vfrStatementExpression[localctx.Node]
> + '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=IfrTreeNode(EFI_IFR_GUID_OP)]
> + : 'label' Number ';'
> + ;
> +
> +vfrStatementBanner
> +locals[Node=IfrTreeNode(EFI_IFR_GUID_OP)]
> + : 'banner' (',')?
> + 'title' '=' 'STRING_TOKEN' '(' Number ')' ','
> + ( ( 'line' Number ','
> + 'align' ('left' | 'center' | 'right') ';'
> + )
> + |
> + ( 'timeout' '=' Number ';'
> + )
> + )
> + ;
> +
> +vfrStatementExtension
> +locals[Node=IfrTreeNode(EFI_IFR_GUID_OP), Buffer=None, 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)*
> + )?
> + (
> + ',' (vfrStatementExtension)*
> + 'endguidop'
> + )?
> + ';'
> + ;
> +
> +
> +vfrExtensionData
> +locals[TFName='', FName='', TFValue=None]
> + : ',' 'data' ('[' I=Number ']')?
> + ( '.' arrayName)* '=' N=Number
> + ;
> +
> +
> +vfrStatementModal
> +locals[Node]
> + : vfrModalTag ';'
> + ;
> +
> +vfrModalTag
> +locals[Node=IfrTreeNode(EFI_IFR_MODAL_TAG_OP)]
> + : 'modal'
> + ;
> +
> +vfrStatementExpression[ParentNode]
> +locals[ExpInfo=ExpressionInfo(), Nodes=[]]
> + : andTerm[localctx.ExpInfo] (L='OR' andTerm[localctx.ExpInfo])*
> + ;
> +
> +vfrStatementExpressionSub[ParentNodes]
> +locals[ExpInfo=ExpressionInfo(), Nodes=[]]
> + : andTerm[localctx.ExpInfo] ('OR' andTerm[localctx.ExpInfo])*
> + ;
> +
> +andTerm[ExpInfo]
> +locals[Nodes=[], Line]
> + : bitwiseorTerm[ExpInfo] (L='AND' bitwiseorTerm[ExpInfo])*
> + ;
> +
> +bitwiseorTerm[ExpInfo]
> +locals[Nodes=[], Line]
> + : bitwiseandTerm[ExpInfo] (L='|' bitwiseandTerm[ExpInfo])*
> + ;
> +
> +
> +bitwiseandTerm[ExpInfo]
> +locals[Nodes=[], Line]
> + : equalTerm[ExpInfo] (L='&' equalTerm[ExpInfo])*
> + ;
> +
> +
> +equalTerm[ExpInfo]
> +locals[Nodes=[], Line]
> + : compareTerm[ExpInfo]
> + (equalTermSupplementary[ExpInfo])*
> + ;
> +
> +
> +equalTermSupplementary[ExpInfo]
> +locals[Nodes=[]]
> + : ('==' compareTerm[ExpInfo]) # equalTermEqualRule
> + |
> + ('!=' compareTerm[ExpInfo]) # equalTermNotEqualRule
> + ;
> +
> +compareTerm[ExpInfo]
> +locals[Nodes=[]]
> + : shiftTerm[ExpInfo]
> + (compareTermSupplementary[ExpInfo])*
> + ;
> +
> +compareTermSupplementary[ExpInfo]
> +locals[Nodes=[]]
> + : ('<' shiftTerm[ExpInfo]) # compareTermLessRule
> + |
> + ('<=' shiftTerm[ExpInfo]) # compareTermLessEqualRule
> + |
> + ('>' shiftTerm[ExpInfo]) # compareTermGreaterRule
> + |
> + ('>=' shiftTerm[ExpInfo]) # compareTermGreaterEqualRule
> + ;
> +
> +shiftTerm[ExpInfo]
> +locals[Nodes=[]]
> + : addMinusTerm[ExpInfo]
> + (shiftTermSupplementary[ExpInfo])*
> + ;
> +
> +shiftTermSupplementary[ExpInfo]
> +locals[Nodes=[]]
> + : ('<<' addMinusTerm[ExpInfo]) # shiftTermLeft
> + |
> + ('>>' addMinusTerm[ExpInfo]) # shiftTermRight
> + ;
> +
> +addMinusTerm[ExpInfo]
> +locals[Nodes=[]]
> + : multdivmodTerm[ExpInfo]
> + (addMinusTermSupplementary[ExpInfo])*
> + ;
> +
> +addMinusTermSupplementary[ExpInfo]
> +locals[Nodes=[]]
> + : ('+' multdivmodTerm[ExpInfo]) # addMinusTermpAdd
> + |
> + ('-' multdivmodTerm[ExpInfo]) # addMinusTermSubtract
> + ;
> +
> +multdivmodTerm[ExpInfo]
> +locals[Nodes=[]]
> + : castTerm[ExpInfo]
> + (multdivmodTermSupplementary[ExpInfo])*
> + ;
> +
> +multdivmodTermSupplementary[ExpInfo]
> +locals[Nodes=[]]
> + : ('*' castTerm[ExpInfo]) # multdivmodTermMul
> + |
> + ('/' castTerm[ExpInfo]) # multdivmodTermDiv
> + |
> + ('%' castTerm[ExpInfo]) # multdivmodTermModulo
> + ;
> +
> +castTerm[ExpInfo]
> +locals[Nodes=[]]
> + : (castTermSub)*
> + atomTerm[ExpInfo]
> + ;
> +
> +castTermSub
> +locals[CastType=0xFF]
> + : '('
> + ( 'BOOLEAN'
> + | 'UINT64'
> + | 'UINT32'
> + | 'UINT16'
> + | 'UINT8'
> + )
> + ')'
> +
> + ;
> +
> +atomTerm[ExpInfo]
> +locals[Nodes=[]]
> + : vfrExpressionCatenate[ExpInfo]
> + | vfrExpressionMatch[ExpInfo]
> + | vfrExpressionMatch2[ExpInfo]
> + | vfrExpressionParen[ExpInfo]
> + | vfrExpressionBuildInFunction[ExpInfo]
> + | vfrExpressionConstant[ExpInfo]
> + | vfrExpressionUnaryOp[ExpInfo]
> + | vfrExpressionTernaryOp[ExpInfo]
> + | vfrExpressionMap[ExpInfo]
> + | ('NOT' atomTerm[ExpInfo])
> + ;
> +
> +vfrExpressionCatenate[ExpInfo]
> +locals[Nodes=[]]
> + : 'catenate'
> + '(' vfrStatementExpressionSub[localctx.Nodes] ','
> vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +vfrExpressionMatch[ExpInfo]
> +locals[Nodes=[]]
> + : 'match'
> + '(' vfrStatementExpressionSub[localctx.Nodes] ','
> vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +vfrExpressionMatch2[ExpInfo]
> +locals[Nodes=[]]
> + : 'match2'
> + '(' vfrStatementExpressionSub[localctx.Nodes] ','
> + vfrStatementExpressionSub[localctx.Nodes] ','
> + guidDefinition ')'
> + ;
> +
> +vfrExpressionParen[ExpInfo]
> +locals[Nodes=[]]
> + : '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +vfrExpressionBuildInFunction[ExpInfo]
> +locals[Node]
> + : 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[Node=IfrTreeNode(EFI_IFR_DUP_OP)]
> + : 'dup'
> + ;
> +
> +
> +vareqvalExp[ExpInfo]
> +locals[Node]
> + : 'vareqval'
> + 'var' '(' VN=Number ')'
> + ( '==' Number
> + | '<=' Number
> + | '<' Number
> + | '>=' Number
> + | '>' Number
> + )
> + ;
> +
> +ideqvalExp[ExpInfo]
> +locals[Node]
> + : I='ideqval' vfrQuestionDataFieldName
> + ( '==' Number
> + | '<=' Number
> + | '<' Number
> + | '>=' Number
> + | '>' Number
> + )
> + ;
> +
> +ideqidExp[ExpInfo]
> +locals[Node]
> + : I='ideqid' vfrQuestionDataFieldName
> + ( E='==' vfrQuestionDataFieldName
> + | LE='<=' vfrQuestionDataFieldName
> + | L='<' vfrQuestionDataFieldName
> + | BE='>=' vfrQuestionDataFieldName
> + | B='>' vfrQuestionDataFieldName
> + )
> + ;
> +
> +ideqvallistExp[ExpInfo]
> +locals[Node]
> + : '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]
> +locals[Node=IfrTreeNode(EFI_IFR_QUESTION_REF1_OP)]
> + : 'questionref'
> + '(' ( StringIdentifier | Number ) ')'
> + ;
> +
> +rulerefExp[ExpInfo]
> +locals[Node=IfrTreeNode(EFI_IFR_RULE_REF_OP)]
> + : 'ruleref' '(' StringIdentifier ')'
> + ;
> +
> +stringref1Exp[ExpInfo]
> +locals[Node=IfrTreeNode(EFI_IFR_STRING_REF1_OP)]
> + : 'stringref' '('
> + (
> + 'STRING_TOKEN' '(' Number ')'
> + | Number
> + )
> +
> +
> + ')'
> + ;
> +
> +pushthisExp[ExpInfo]
> +locals[Node=IfrTreeNode(EFI_IFR_THIS_OP)]
> + : 'pushthis'
> + ;
> +
> +securityExp[ExpInfo]
> +locals[Node=IfrTreeNode(EFI_IFR_SECURITY_OP)]
> + : 'security' '(' guidDefinition ')'
> + ;
> +
> +numericVarStoreType
> +locals[VarType]
> + : 'NUMERIC_SIZE_1'
> + | 'NUMERIC_SIZE_2'
> + | 'NUMERIC_SIZE_4'
> + | 'NUMERIC_SIZE_8'
> + ;
> +
> +getExp[ExpInfo]
> +locals[BaseInfo=EFI_VARSTORE_INFO(),
> Node=IfrTreeNode(EFI_IFR_GET_OP)]
> + : 'get' '(' vfrStorageVarId[localctx.BaseInfo, False]('|' 'flags' '='
> numericVarStoreType)? ')'
> + ;
> +
> +vfrExpressionConstant[ExpInfo]
> +locals[Node]
> + : 'TRUE'
> + | 'FALSE'
> + | 'ONE'
> + | 'ONES'
> + | 'ZERO'
> + | 'UNDEFINED'
> + | 'VERSION'
> + | Number
> + ;
> +
> +vfrExpressionUnaryOp[ExpInfo]
> +locals[Nodes]
> + : lengthExp[ExpInfo]
> + | bitwisenotExp[ExpInfo]
> + | question23refExp[ExpInfo]
> + | stringref2Exp[ExpInfo]
> + | toboolExp[ExpInfo]
> + | tostringExp[ExpInfo]
> + | unintExp[ExpInfo]
> + | toupperExp[ExpInfo]
> + | tolwerExp[ExpInfo]
> + | setExp[ExpInfo]
> + ;
> +
> +lengthExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'length' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +bitwisenotExp[ExpInfo]
> +locals[Nodes=[]]
> + : '~' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +question23refExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'questionrefval'
> + '('
> + (DevicePath '=' 'STRING_TOKEN' '(' Number ')' ',' )?
> + (Uuid '=' guidDefinition ',' )?
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +stringref2Exp[ExpInfo]
> +locals[Nodes=[]]
> + : 'stringrefval' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +toboolExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'boolval' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +tostringExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'stringval' ('format' '=' Number ',' )?
> + '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +unintExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'unintval' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +toupperExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'toupper' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +tolwerExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'tolower' '(' vfrStatementExpressionSub[localctx.Nodes] ')'
> + ;
> +
> +setExp[ExpInfo]
> +locals[BaseInfo=EFI_VARSTORE_INFO(), Nodes=[]]
> + : 'set'
> + '('
> + vfrStorageVarId[localctx.BaseInfo, False]('|' 'flags' '='
> numericVarStoreType)? ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +vfrExpressionTernaryOp[ExpInfo]
> +locals[Nodes]
> + : conditionalExp[ExpInfo]
> + | findExp[ExpInfo]
> + | midExp[ExpInfo]
> + | tokenExp[ExpInfo]
> + | spanExp[ExpInfo]
> + ;
> +
> +conditionalExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'cond'
> + '('
> + vfrStatementExpressionSub[localctx.Nodes]
> + '?'
> + vfrStatementExpressionSub[localctx.Nodes]
> + ':'
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +findExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'find'
> + '('
> + findFormat[ExpInfo] ('|' findFormat[ExpInfo])*
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +findFormat[ExpInfo]
> +locals[Format=0]
> + : 'SENSITIVE' | 'INSENSITIVE'
> + ;
> +
> +midExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'mid'
> + '('
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +tokenExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'token'
> + '('
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +spanExp[ExpInfo]
> +locals[Nodes=[]]
> + : 'span'
> + '('
> + 'flags' '=' spanFlags ('|' spanFlags)*
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ','
> + vfrStatementExpressionSub[localctx.Nodes]
> + ')'
> + ;
> +
> +spanFlags
> +locals[Flag=0]
> + : Number
> + | 'LAST_NON_MATCH'
> + | 'FIRST_NON_MATCH'
> + ;
> +
> +vfrExpressionMap[ExpInfo]
> +locals[Nodes=[], Node=IfrTreeNode()]
> + : 'map'
> + '('
> + vfrStatementExpressionSub[localctx.Nodes]
> + ':'
> + ( vfrStatementExpression[localctx.Node]
> + ','
> + vfrStatementExpression[localctx.Node]
> + ';'
> + )*
> + ')'
> + ;
> +
> +
> +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
> + ;
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> index 2b7a5c32a3..0e165a0446 100644
> --- a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> @@ -1,16 +1,15 @@
> # Generated from VfrSyntax.g4 by ANTLR 4.7.2
>
> +
>
> +import sys
>
> 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 *
>
> -
>
> +from VfrCompiler.IfrCtypes import *
>
> +from VfrCompiler.IfrFormPkg import *
>
> +from VfrCompiler.IfrUtility import *
>
> +from VfrCompiler.IfrTree import *
>
> +from VfrCompiler.IfrError import *
>
> +from VfrCompiler.IfrPreProcess import *
>
>
>
>
>
> def serializedATN():
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> index b6af21b795..d5d61a26a9 100644
> --- a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> @@ -1,22 +1,23 @@
> # Generated from VfrSyntax.g4 by ANTLR 4.7.2
>
> # encoding: utf-8
>
> +
>
> +import os
>
> +import sys
>
> 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 *
>
> +from VfrCompiler.IfrCtypes import *
>
> +from VfrCompiler.IfrFormPkg import *
>
> +from VfrCompiler.IfrUtility import *
>
> +from VfrCompiler.IfrTree import *
>
> +from VfrCompiler.IfrError import *
>
> +from VfrCompiler.IfrPreProcess import *
>
>
>
>
>
> def serializedATN():
>
> with StringIO() as buf:
>
>
> buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u010
> 2")
>
> - 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("\u0ba7\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")
>
> @@ -54,1528 +55,1530 @@ def serializedATN():
>
> 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("\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\3\2\3\2\3\2\7")
>
> + buf.write("\2\u019c\n\2\f\2\16\2\u019f\13\2\3\2\5\2\u01a2\n\2\3\3")
>
> + buf.write("\3\3\3\4\3\4\3\4\5\4\u01a9\n\4\3\4\3\4\5\4\u01ad\n\4\3")
>
> + buf.write("\5\5\5\u01b0\n\5\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u01b8\n\6")
>
> + buf.write("\3\6\3\6\3\7\5\7\u01bd\n\7\3\7\3\7\5\7\u01c1\n\7\3\7\5")
>
> + buf.write("\7\u01c4\n\7\3\7\3\7\3\7\3\7\5\7\u01ca\n\7\3\7\3\7\3\b")
>
> +
> buf.write("\5\b\u01cf\n\b\3\b\3\b\5\b\u01d3\n\b\3\b\5\b\u01d6\n\b")
>
> + buf.write("\3\b\3\b\3\b\3\b\5\b\u01dc\n\b\3\b\3\b\3\t\3\t\3\t\3\t")
>
> + buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u01ee\n\t")
>
> + buf.write("\f\t\16\t\u01f1\13\t\3\n\3\n\3\n\3\n\3\n\5\n\u01f8\n\n")
>
> + buf.write("\3\n\3\n\3\13\3\13\3\13\3\13\3\13\5\13\u0201\n\13\3\13")
>
> + buf.write("\3\13\3\f\3\f\3\f\3\f\3\f\5\f\u020a\n\f\3\f\3\f\3\r\3")
>
> + buf.write("\r\3\r\3\r\3\r\5\r\u0213\n\r\3\r\3\r\3\16\3\16\3\16\3")
>
> + buf.write("\16\3\16\5\16\u021c\n\16\3\16\3\16\3\17\3\17\3\17\3\17")
>
> + buf.write("\3\17\5\17\u0225\n\17\3\17\3\17\3\20\3\20\3\20\3\20\3")
>
> + buf.write("\20\5\20\u022e\n\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21")
>
> + buf.write("\5\21\u0237\n\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\5")
>
> + buf.write("\22\u0240\n\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\5\23")
>
> + buf.write("\u0249\n\23\3\23\3\23\3\24\3\24\5\24\u024f\n\24\3\24\3")
>
> + buf.write("\24\3\24\3\24\3\25\3\25\5\25\u0257\n\25\3\25\3\25\3\25")
>
> + buf.write("\3\25\3\26\3\26\5\26\u025f\n\26\3\26\3\26\3\26\3\26\3")
>
> + buf.write("\27\3\27\5\27\u0267\n\27\3\27\3\27\3\27\3\27\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("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
>
> + buf.write("\5\30\u0285\n\30\3\30\3\30\3\30\3\30\3\30\5\30\u028c\n")
>
> + buf.write("\30\3\30\3\30\3\30\3\30\3\30\5\30\u0293\n\30\3\30\3\30")
>
> + buf.write("\3\30\3\30\3\31\3\31\3\31\5\31\u029c\n\31\3\31\3\31\5")
>
> +
> buf.write("\31\u02a0\n\31\3\31\3\31\5\31\u02a4\n\31\3\32\3\32\3\32")
>
> + buf.write("\7\32\u02a9\n\32\f\32\16\32\u02ac\13\32\3\33\3\33\3\34")
>
> + buf.write("\3\34\3\35\7\35\u02b3\n\35\f\35\16\35\u02b6\13\35\3\36")
>
> +
> buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u02c2")
>
> + buf.write("\n\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37")
>
> + buf.write("\3\37\3\37\3\37\5\37\u02d1\n\37\3\37\3\37\3 \3 \3 \3 ")
>
> + buf.write("\3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u02e6\n \3")
>
> + buf.write(" \3 \3 \3 \5 \u02ec\n \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!\5!\u0308")
>
> + buf.write("\n!\3!\3!\3!\3!\5!\u030e\n!\3!\3!\3!\3!\3!\7!\u0315\n")
>
> + buf.write("!\f!\16!\u0318\13!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3")
>
> + buf.write("!\3!\3!\3!\3!\5!\u032a\n!\3!\3!\3!\3!\3!\3\"\3\"\3#\3")
>
> +
> buf.write("#\3#\3#\3#\3#\3#\5#\u033a\n#\3#\3#\3#\3#\3#\3#\3#\6#\u0343")
>
> +
> buf.write("\n#\r#\16#\u0344\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\'")
>
> + buf.write("\3\'\3\'\5\'\u0376\n\'\3\'\3\'\3(\3(\3(\3(\3(\3)\3)\3")
>
> +
> buf.write(")\3*\3*\3*\3*\5*\u0386\n*\3*\3*\3*\3*\3*\5*\u038d\n*\3")
>
> +
> buf.write("*\3*\3*\3*\5*\u0393\n*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3")
>
> + buf.write("+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\5,\u03ab\n,\3-\3-\3")
>
> + buf.write("-\3-\3-\3-\3-\7-\u03b4\n-\f-\16-\u03b7\13-\5-\u03b9\n")
>
> + buf.write("-\3.\5.\u03bc\n.\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.\7.\u03e1\n.\f.\16.\u03e4\13.\3.\5.\u03e7")
>
> + buf.write("\n.\3/\3/\3/\3/\3/\3/\3/\3\60\3\60\3\61\3\61\5\61\u03f4")
>
> + buf.write("\n\61\3\62\3\62\3\62\7\62\u03f9\n\62\f\62\16\62\u03fc")
>
> + buf.write("\13\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3")
>
> + buf.write("\63\3\63\3\63\3\63\7\63\u040b\n\63\f\63\16\63\u040e\13")
>
> + buf.write("\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64")
>
> + buf.write("\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\5\64\u0422\n")
>
> + buf.write("\64\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\3\65\3\65\3\65\3\65\3\65\7\65\u0435\n\65\f")
>
> + buf.write("\65\16\65\u0438\13\65\3\65\7\65\u043b\n\65\f\65\16\65")
>
> + buf.write("\u043e\13\65\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\3")
>
> + buf.write("\67\38\38\38\38\38\38\38\39\39\39\59\u0453\n9\3:\3:\3")
>
> + buf.write(":\3:\3:\3:\3:\3:\3:\3:\3:\5:\u0460\n:\3:\3:\5:\u0464\n")
>
> + buf.write(":\3:\3:\3:\5:\u0469\n:\3:\3:\7:\u046d\n:\f:\16:\u0470")
>
> + buf.write("\13:\5:\u0472\n:\3:\3:\5:\u0476\n:\3;\3;\5;\u047a\n;\3")
>
> + buf.write("<\3<\3<\7<\u047f\n<\f<\16<\u0482\13<\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>\5")
>
> +
> buf.write(">\u049b\n>\3>\3>\3>\3>\3>\3>\7>\u04a3\n>\f>\16>\u04a6")
>
> +
> buf.write("\13>\3>\3>\3>\3>\3>\5>\u04ad\n>\3>\3>\5>\u04b1\n>\3>\3")
>
> +
> buf.write(">\3?\3?\5?\u04b7\n?\3@\3@\5@\u04bb\n@\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\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\16
> N")
>
> -
> 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\u05
> b3")
>
> -
> buf.write("\nQ\fQ\16Q\u05b6\13Q\3Q\3Q\5Q\u05ba\nQ\3Q\3Q\3Q\5Q\u05
> bf")
>
> -
> 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("A\3A\3A\5A\u04e9\nA\3A\3A\5A\u04ed\nA\3A\3A\3A\3A\3A\5")
>
> +
> buf.write("A\u04f4\nA\3A\3A\3A\3A\5A\u04fa\nA\3A\3A\5A\u04fe\nA\3")
>
> +
> buf.write("A\3A\3B\3B\3B\7B\u0505\nB\fB\16B\u0508\13B\3C\3C\5C\u050c"
> )
>
> +
> buf.write("\nC\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\5D\u0518\nD\3D\3D\3")
>
> + buf.write("D\3E\3E\3E\3E\3E\3E\5E\u0523\nE\3F\3F\3F\3F\3F\3F\3F\3")
>
> +
> buf.write("F\3F\3F\3F\5F\u0530\nF\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3")
>
> +
> buf.write("G\3G\3G\7G\u053f\nG\fG\16G\u0542\13G\3G\3G\5G\u0546\n")
>
> +
> buf.write("G\3G\3G\3G\5G\u054b\nG\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3"
> )
>
> +
> buf.write("H\3H\3H\7H\u055a\nH\fH\16H\u055d\13H\3H\3H\5H\u0561\n")
>
> + buf.write("H\3H\3H\3H\5H\u0566\nH\3I\3I\3I\3I\3I\3I\5I\u056e\nI\3")
>
> + buf.write("J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3")
>
> +
> buf.write("M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\5M\u058e\nM\3
> M\3M\3")
>
> +
> buf.write("M\5M\u0593\nM\3N\7N\u0596\nN\fN\16N\u0599\13N\3O\3O\3")
>
> +
> buf.write("O\3O\3O\3O\3O\5O\u05a2\nO\3P\3P\3P\3P\3P\3P\3P\3P\5P\u05a
> c")
>
> +
> buf.write("\nP\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u05b6\nQ\fQ\16Q\u05b9\13
> ")
>
> +
> buf.write("Q\3Q\3Q\5Q\u05bd\nQ\3Q\3Q\3Q\5Q\u05c2\nQ\3R\3R\3R\3R\3"
> )
>
> +
> buf.write("R\3R\3R\3R\7R\u05cc\nR\fR\16R\u05cf\13R\3R\3R\5R\u05d3")
>
> +
> buf.write("\nR\3R\3R\3R\5R\u05d8\nR\3S\3S\3S\3S\3S\3S\3S\3S\5S\u05e2")
>
> + buf.write("\nS\3S\3S\3S\3S\5S\u05e8\nS\3T\3T\3T\3T\3U\3U\3V\3V\3")
>
> +
> buf.write("V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u0603
> ")
>
> +
> buf.write("\nV\3V\3V\7V\u0607\nV\fV\16V\u060a\13V\3V\3V\3W\3W\3W")
>
> +
> buf.write("\7W\u0611\nW\fW\16W\u0614\13W\3X\3X\3X\3X\3X\3X\3X\3X")
>
> +
> buf.write("\3X\3X\3X\5X\u0621\nX\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3[\7[\u062c")
>
> + buf.write("\n[\f[\16[\u062f\13[\3\\\3\\\5\\\u0633\n\\\3]\3]\5]\u0637")
>
> + buf.write("\n]\3^\3^\3^\3^\3^\3^\3^\3^\3^\5^\u0642\n^\3^\3^\3^\3")
>
> + buf.write("^\5^\u0648\n^\3^\3^\3^\3^\3_\3_\3_\7_\u0651\n_\f_\16_")
>
> + buf.write("\u0654\13_\3`\3`\3`\3`\3`\3`\5`\u065c\n`\3a\3a\3a\3a\3")
>
> +
> buf.write("a\3a\3a\3a\5a\u0666\na\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3")
>
> +
> buf.write("a\3b\3b\3b\7b\u0676\nb\fb\16b\u0679\13b\3c\3c\5c\u067d")
>
> +
> buf.write("\nc\3d\3d\5d\u0681\nd\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u068c")
>
> + buf.write("\ne\3e\3e\3e\3e\5e\u0692\ne\3e\3e\3e\3e\3e\3f\3f\3f\5")
>
> + buf.write("f\u069c\nf\3f\3f\3f\3f\3f\5f\u06a3\nf\3f\3f\3f\3f\3f\3")
>
> + buf.write("f\5f\u06ab\nf\3g\3g\3g\7g\u06b0\ng\fg\16g\u06b3\13g\3")
>
> + buf.write("h\3h\3h\3h\3h\3h\3h\3h\3h\5h\u06be\nh\3i\3i\3i\3i\3i\3")
>
> + buf.write("i\3i\3i\3i\5i\u06c9\ni\3i\5i\u06cc\ni\3i\3i\3i\3i\3j\3")
>
> + buf.write("j\3j\7j\u06d5\nj\fj\16j\u06d8\13j\3k\3k\5k\u06dc\nk\3")
>
> + buf.write("l\3l\3l\3l\3l\3l\3l\3l\5l\u06e6\nl\3l\3l\3l\3l\5l\u06ec")
>
> + buf.write("\nl\3l\3l\3l\3l\3l\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\7m\u06fd")
>
> +
> buf.write("\nm\fm\16m\u0700\13m\3n\3n\3n\5n\u0705\nn\3o\3o\3o\3o")
>
> +
> buf.write("\3o\3o\3o\3o\5o\u070f\no\3o\3o\3o\3o\5o\u0715\no\3o\3")
>
> +
> buf.write("o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\5o\u0723\no\3o\3o\3o\3")
>
> +
> buf.write("o\3p\3p\3p\7p\u072c\np\fp\16p\u072f\13p\3q\3q\5q\u0733")
>
> + buf.write("\nq\3r\3r\3r\3r\3r\3r\3r\5r\u073c\nr\3r\3r\3r\3r\3r\5")
>
> + buf.write("r\u0743\nr\3r\3r\3r\3r\3s\3s\3s\7s\u074c\ns\fs\16s\u074f")
>
> + buf.write("\13s\3t\3t\3t\3t\5t\u0755\nt\3u\3u\3u\3u\3u\3u\3u\3u\5")
>
> +
> buf.write("u\u075f\nu\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\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("u\3u\3u\3u\3u\5u\u07aa\nu\3u\7u\u07ad\nu\fu\16u\u07b0")
>
> +
> buf.write("\13u\5u\u07b2\nu\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3v\3")
>
> +
> buf.write("v\3v\3v\5v\u07c3\nv\3v\3v\3v\3v\5v\u07c9\nv\3w\3w\3w\7")
>
> +
> buf.write("w\u07ce\nw\fw\16w\u07d1\13w\3x\3x\3y\3y\3y\3y\3y\3y\3")
>
> + buf.write("y\3y\5y\u07dd\ny\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\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("y\3y\3y\3y\3y\3y\3y\5y\u0828\ny\3y\7y\u082b\ny\fy\16y")
>
> + buf.write("\u082e\13y\5y\u0830\ny\3y\3y\3y\3z\3z\3z\3z\3z\3z\3z\3")
>
> + buf.write("z\3z\3z\3z\3z\5z\u0841\nz\3z\3z\3z\3z\5z\u0847\nz\3{\3")
>
> + buf.write("{\3{\7{\u084c\n{\f{\16{\u084f\13{\3|\3|\3}\3}\3}\3}\5")
>
> + buf.write("}\u0857\n}\3~\3~\3~\3~\3~\3\177\3\177\3\u0080\3\u0080")
>
> +
> buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\5\u0081")
>
> +
> buf.write("\u0868\n\u0081\3\u0082\3\u0082\3\u0082\3\u0082\5\u0082")
>
> +
> buf.write("\u086e\n\u0082\3\u0083\3\u0083\3\u0083\3\u0083\7\u0083")
>
> +
> buf.write("\u0874\n\u0083\f\u0083\16\u0083\u0877\13\u0083\3\u0083")
>
> +
> buf.write("\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084")
>
> +
> buf.write("\3\u0084\7\u0084\u0882\n\u0084\f\u0084\16\u0084\u0885")
>
> +
> buf.write("\13\u0084\3\u0084\3\u0084\5\u0084\u0889\n\u0084\3\u0084")
>
> +
> buf.write("\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085")
>
> +
> buf.write("\3\u0085\7\u0085\u0894\n\u0085\f\u0085\16\u0085\u0897")
>
> +
> buf.write("\13\u0085\3\u0085\3\u0085\5\u0085\u089b\n\u0085\3\u0085")
>
> +
> buf.write("\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086")
>
> +
> buf.write("\3\u0086\7\u0086\u08a6\n\u0086\f\u0086\16\u0086\u08a9")
>
> +
> buf.write("\13\u0086\3\u0086\3\u0086\5\u0086\u08ad\n\u0086\3\u0086")
>
> +
> buf.write("\3\u0086\3\u0086\7\u0086\u08b2\n\u0086\f\u0086\16\u0086")
>
> +
> buf.write("\u08b5\13\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087")
>
> +
> buf.write("\3\u0087\3\u0087\3\u0087\3\u0087\7\u0087\u08c0\n\u0087")
>
> +
> buf.write("\f\u0087\16\u0087\u08c3\13\u0087\3\u0087\3\u0087\5\u0087")
>
> +
> buf.write("\u08c7\n\u0087\3\u0087\3\u0087\3\u0087\7\u0087\u08cc\n")
>
> +
> buf.write("\u0087\f\u0087\16\u0087\u08cf\13\u0087\3\u0087\3\u0087")
>
> +
> buf.write("\3\u0087\3\u0088\3\u0088\3\u0088\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("\7\u0088\u08e1\n\u0088\f\u0088\16\u0088\u08e4\13\u0088")
>
> +
> buf.write("\3\u0088\3\u0088\5\u0088\u08e8\n\u0088\3\u0088\3\u0088")
>
> +
> buf.write("\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\5\u0089\u08f1")
>
> +
> buf.write("\n\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
>
> +
> buf.write("\3\u008a\3\u008a\3\u008a\3\u008a\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("\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\u008b\3\u008b\3\u008b\3\u008b\5\u008b\u0912\n\u008b")
>
> +
> buf.write("\3\u008b\3\u008b\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\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("\7\u008c\u0930\n\u008c\f\u008c\16\u008c\u0933\13\u008c")
>
> +
> buf.write("\5\u008c\u0935\n\u008c\3\u008c\3\u008c\3\u008c\3\u008c")
>
> +
> buf.write("\5\u008c\u093b\n\u008c\3\u008c\3\u008c\3\u008d\3\u008d")
>
> +
> buf.write("\3\u008d\3\u008d\3\u008e\3\u008e\5\u008e\u0945\n\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\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\u008e\3\u008e\3\u008e\5\u008e\u0958\n\u008e\3\u008f")
>
> +
> buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u0965\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u096b\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u0971\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u0977\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u097d\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u0983\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u0989\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u098f\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u0995\n\u008f\3\u008f")
>
> + buf.write("\3\u008f\3\u008f\3\u008f\5\u008f\u099b\n\u008f\5\u008f")
>
> +
> buf.write("\u099d\n\u008f\3\u008f\7\u008f\u09a0\n\u008f\f\u008f\16")
>
> + buf.write("\u008f\u09a3\13\u008f\5\u008f\u09a5\n\u008f\3\u008f\3")
>
> + buf.write("\u008f\7\u008f\u09a9\n\u008f\f\u008f\16\u008f\u09ac\13")
>
> + buf.write("\u008f\3\u008f\5\u008f\u09af\n\u008f\3\u008f\3\u008f\3")
>
> +
> buf.write("\u0090\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u09b8\n")
>
> +
> buf.write("\u0090\3\u0090\3\u0090\7\u0090\u09bc\n\u0090\f\u0090\16")
>
> +
> buf.write("\u0090\u09bf\13\u0090\3\u0090\3\u0090\3\u0090\3\u0091")
>
> +
> buf.write("\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093")
>
> +
> buf.write("\7\u0093\u09cc\n\u0093\f\u0093\16\u0093\u09cf\13\u0093")
>
> +
> buf.write("\3\u0094\3\u0094\3\u0094\7\u0094\u09d4\n\u0094\f\u0094")
>
> +
> buf.write("\16\u0094\u09d7\13\u0094\3\u0095\3\u0095\3\u0095\7\u0095")
>
> +
> buf.write("\u09dc\n\u0095\f\u0095\16\u0095\u09df\13\u0095\3\u0096")
>
> +
> buf.write("\3\u0096\3\u0096\7\u0096\u09e4\n\u0096\f\u0096\16\u0096")
>
> +
> buf.write("\u09e7\13\u0096\3\u0097\3\u0097\3\u0097\7\u0097\u09ec")
>
> +
> buf.write("\n\u0097\f\u0097\16\u0097\u09ef\13\u0097\3\u0098\3\u0098")
>
> +
> buf.write("\7\u0098\u09f3\n\u0098\f\u0098\16\u0098\u09f6\13\u0098")
>
> +
> buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u09fc\n\u0099")
>
> +
> buf.write("\3\u009a\3\u009a\7\u009a\u0a00\n\u009a\f\u009a\16\u009a")
>
> +
> buf.write("\u0a03\13\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b")
>
> +
> buf.write("\3\u009b\3\u009b\3\u009b\5\u009b\u0a0d\n\u009b\3\u009c")
>
> + buf.write("\3\u009c\7\u009c\u0a11\n\u009c\f\u009c\16\u009c\u0a14")
>
> +
> buf.write("\13\u009c\3\u009d\3\u009d\3\u009d\3\u009d\5\u009d\u0a1a")
>
> +
> buf.write("\n\u009d\3\u009e\3\u009e\7\u009e\u0a1e\n\u009e\f\u009e")
>
> +
> buf.write("\16\u009e\u0a21\13\u009e\3\u009f\3\u009f\3\u009f\3\u009f")
>
> +
> buf.write("\5\u009f\u0a27\n\u009f\3\u00a0\3\u00a0\7\u00a0\u0a2b\n")
>
> +
> buf.write("\u00a0\f\u00a0\16\u00a0\u0a2e\13\u00a0\3\u00a1\3\u00a1")
>
> +
> buf.write("\3\u00a1\3\u00a1\3\u00a1\3\u00a1\5\u00a1\u0a36\n\u00a1")
>
> +
> buf.write("\3\u00a2\7\u00a2\u0a39\n\u00a2\f\u00a2\16\u00a2\u0a3c")
>
> +
> buf.write("\13\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3")
>
> +
> buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
>
> +
> buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u0a4f\n\u00a4")
>
> +
> buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
>
> +
> buf.write("\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
>
> +
> buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
>
> +
> buf.write("\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a9")
>
> +
> buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9")
>
> +
> buf.write("\3\u00a9\3\u00a9\3\u00a9\5\u00a9\u0a77\n\u00a9\3\u00aa")
>
> +
> buf.write("\3\u00aa\3\u00ab\3\u00ab\3\u00ab\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\u00ab\3\u00ab\3\u00ab\5\u00ab\u0a94\n\u00ab")
>
> +
> buf.write("\3\u00ab\3\u00ab\5\u00ab\u0a8a\n\u00ab\3\u00ac\3\u00ac")
>
>
> 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("\3\u00ac\3\u00ac\3\u00ac\5\u00ac\u0a98\n\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\5\u00ad\u0aa6\n\u00ad")
>
> +
> buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\6\u00ae\u0aac\n\u00ae")
>
> +
> buf.write("\r\u00ae\16\u00ae\u0aad\3\u00af\3\u00af\3\u00af\3\u00af")
>
> + buf.write("\3\u00af\3\u00af\3\u00af\7\u00af\u0ab7\n\u00af\f\u00af")
>
> +
> buf.write("\16\u00af\u0aba\13\u00af\5\u00af\u0abc\n\u00af\3\u00b0")
>
> +
> buf.write("\3\u00b0\3\u00b0\3\u00b0\5\u00b0\u0ac2\n\u00b0\3\u00b1")
>
> +
> buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\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\5\u00b3\u0ad5\n\u00b3\3\u00b3\3\u00b3")
>
> +
> buf.write("\3\u00b4\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5")
>
> +
> buf.write("\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
>
> +
> buf.write("\3\u00b7\3\u00b7\5\u00b7\u0ae9\n\u00b7\3\u00b7\3\u00b7")
>
> +
> 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\5\u00b9\u0af9")
>
> +
> buf.write("\n\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb")
>
> +
> buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc")
>
> +
> buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc")
>
> +
> buf.write("\u0b0e\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
>
> +
> buf.write("\5\u00bc\u0b15\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bd")
>
> +
> buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be\3\u00be")
>
> +
> buf.write("\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf")
>
> + buf.write("\5\u00bf\u0b29\n\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf")
>
> +
> buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1")
>
> +
> buf.write("\3\u00c1\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2")
>
> +
> buf.write("\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3")
>
> +
> buf.write("\3\u00c3\5\u00c3\u0b45\n\u00c3\3\u00c3\3\u00c3\3\u00c3")
>
> +
> buf.write("\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\5\u00c4")
>
> +
> buf.write("\u0b50\n\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5")
>
> +
> buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6")
>
> +
> buf.write("\3\u00c6\3\u00c6\7\u00c6\u0b60\n\u00c6\f\u00c6\16\u00c6")
>
> +
> buf.write("\u0b63\13\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6")
>
> +
> buf.write("\3\u00c6\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c8\3\u00c8")
>
> +
> buf.write("\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8")
>
> +
> buf.write("\3\u00c9\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\7\u00ca\u0b88\n\u00ca\f\u00ca\16\u00ca")
>
> +
> buf.write("\u0b8b\13\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca")
>
> +
> buf.write("\3\u00ca\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cc\3\u00cc")
>
> +
> buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc")
>
> +
> buf.write("\7\u00cc\u0ba0\n\u00cc\f\u00cc\16\u00cc\u0ba3\13\u00cc")
>
> + buf.write("\3\u00cc\3\u00cc\3\u00cc\2\2\u00cd\2\4\6\b\n\f\16\20\22")
>
> + buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPR")
>
> + buf.write("TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088")
>
> +
> buf.write("\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a")
>
> +
> buf.write("\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac")
>
> +
> buf.write("\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be")
>
> +
> buf.write("\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0")
>
> +
> buf.write("\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2")
>
> +
> buf.write("\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4")
>
> +
> buf.write("\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106")
>
> +
> buf.write("\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118")
>
> +
> buf.write("\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a")
>
> +
> buf.write("\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c")
>
> +
> buf.write("\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e")
>
> +
> buf.write("\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160")
>
> +
> buf.write("\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172")
>
> +
> buf.write("\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184")
>
> +
> buf.write("\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194\u0196")
>
>
> 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\u052
> d")
>
> -
> 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\u063
> 1")
>
> -
> 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\u09d
> 9")
>
> -
> 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\u0a4
> b")
>
> -
> 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")
>
> + buf.write("\u00f8\u00fa\2\u0c71\2\u019d\3\2\2\2\4\u01a3\3\2\2\2\6")
>
> + buf.write("\u01a5\3\2\2\2\b\u01af\3\2\2\2\n\u01b1\3\2\2\2\f\u01bc")
>
> + buf.write("\3\2\2\2\16\u01ce\3\2\2\2\20\u01ef\3\2\2\2\22\u01f2\3")
>
> + buf.write("\2\2\2\24\u01fb\3\2\2\2\26\u0204\3\2\2\2\30\u020d\3\2")
>
> + buf.write("\2\2\32\u0216\3\2\2\2\34\u021f\3\2\2\2\36\u0228\3\2\2")
>
> + buf.write("\2
> \u0231\3\2\2\2\"\u023a\3\2\2\2$\u0243\3\2\2\2&\u024c")
>
> + buf.write("\3\2\2\2(\u0254\3\2\2\2*\u025c\3\2\2\2,\u0264\3\2\2\2")
>
> +
> buf.write(".\u026c\3\2\2\2\60\u0298\3\2\2\2\62\u02a5\3\2\2\2\64\u02ad")
>
> + buf.write("\3\2\2\2\66\u02af\3\2\2\28\u02b4\3\2\2\2:\u02c1\3\2\2")
>
> +
> buf.write("\2<\u02c3\3\2\2\2>\u02d4\3\2\2\2@\u02f6\3\2\2\2B\u0330")
>
> + buf.write("\3\2\2\2D\u0332\3\2\2\2F\u034b\3\2\2\2H\u0352\3\2\2\2")
>
> +
> buf.write("J\u0359\3\2\2\2L\u0369\3\2\2\2N\u0379\3\2\2\2P\u037e\3")
>
> +
> buf.write("\2\2\2R\u0385\3\2\2\2T\u0394\3\2\2\2V\u03aa\3\2\2\2X\u03b8")
>
> + buf.write("\3\2\2\2Z\u03e6\3\2\2\2\\\u03e8\3\2\2\2^\u03ef\3\2\2\2")
>
> + buf.write("`\u03f3\3\2\2\2b\u03f5\3\2\2\2d\u03fd\3\2\2\2f\u0421\3")
>
> +
> buf.write("\2\2\2h\u0423\3\2\2\2j\u0442\3\2\2\2l\u0445\3\2\2\2n\u0448")
>
> + buf.write("\3\2\2\2p\u0452\3\2\2\2r\u0454\3\2\2\2t\u0479\3\2\2\2")
>
> +
> buf.write("v\u047b\3\2\2\2x\u0483\3\2\2\2z\u0485\3\2\2\2|\u04b6\3")
>
> + buf.write("\2\2\2~\u04ba\3\2\2\2\u0080\u04bc\3\2\2\2\u0082\u0501")
>
> +
> buf.write("\3\2\2\2\u0084\u050b\3\2\2\2\u0086\u050d\3\2\2\2\u0088")
>
> +
> buf.write("\u0522\3\2\2\2\u008a\u052f\3\2\2\2\u008c\u0531\3\2\2\2")
>
> +
> buf.write("\u008e\u054c\3\2\2\2\u0090\u0567\3\2\2\2\u0092\u056f\3")
>
> +
> buf.write("\2\2\2\u0094\u0574\3\2\2\2\u0096\u057c\3\2\2\2\u0098\u0581")
>
> +
> buf.write("\3\2\2\2\u009a\u0597\3\2\2\2\u009c\u05a1\3\2\2\2\u009e")
>
> +
> buf.write("\u05ab\3\2\2\2\u00a0\u05ad\3\2\2\2\u00a2\u05c3\3\2\2\2")
>
> +
> buf.write("\u00a4\u05d9\3\2\2\2\u00a6\u05e9\3\2\2\2\u00a8\u05ed\3")
>
> +
> buf.write("\2\2\2\u00aa\u05ef\3\2\2\2\u00ac\u060d\3\2\2\2\u00ae\u0620")
>
> +
> buf.write("\3\2\2\2\u00b0\u0622\3\2\2\2\u00b2\u0626\3\2\2\2\u00b4")
>
> +
> buf.write("\u062d\3\2\2\2\u00b6\u0632\3\2\2\2\u00b8\u0636\3\2\2\2")
>
> +
> buf.write("\u00ba\u0638\3\2\2\2\u00bc\u064d\3\2\2\2\u00be\u065b\3")
>
> +
> buf.write("\2\2\2\u00c0\u065d\3\2\2\2\u00c2\u0672\3\2\2\2\u00c4\u067c")
>
> +
> buf.write("\3\2\2\2\u00c6\u0680\3\2\2\2\u00c8\u0682\3\2\2\2\u00ca")
>
> +
> buf.write("\u0698\3\2\2\2\u00cc\u06ac\3\2\2\2\u00ce\u06bd\3\2\2\2")
>
> +
> buf.write("\u00d0\u06bf\3\2\2\2\u00d2\u06d1\3\2\2\2\u00d4\u06db\3")
>
> +
> buf.write("\2\2\2\u00d6\u06dd\3\2\2\2\u00d8\u06f9\3\2\2\2\u00da\u0704"
> )
>
> +
> buf.write("\3\2\2\2\u00dc\u0706\3\2\2\2\u00de\u0728\3\2\2\2\u00e0")
>
> +
> buf.write("\u0732\3\2\2\2\u00e2\u0734\3\2\2\2\u00e4\u0748\3\2\2\2")
>
> +
> buf.write("\u00e6\u0754\3\2\2\2\u00e8\u0756\3\2\2\2\u00ea\u07b6\3")
>
> +
> buf.write("\2\2\2\u00ec\u07ca\3\2\2\2\u00ee\u07d2\3\2\2\2\u00f0\u07d4")
>
> + buf.write("\3\2\2\2\u00f2\u0834\3\2\2\2\u00f4\u0848\3\2\2\2\u00f6")
>
> + buf.write("\u0850\3\2\2\2\u00f8\u0856\3\2\2\2\u00fa\u0858\3\2\2\2")
>
> + buf.write("\u00fc\u085d\3\2\2\2\u00fe\u085f\3\2\2\2\u0100\u0867\3")
>
> +
> buf.write("\2\2\2\u0102\u086d\3\2\2\2\u0104\u086f\3\2\2\2\u0106\u087b")
>
> +
> buf.write("\3\2\2\2\u0108\u088d\3\2\2\2\u010a\u089f\3\2\2\2\u010c")
>
> +
> buf.write("\u08b9\3\2\2\2\u010e\u08d3\3\2\2\2\u0110\u08f0\3\2\2\2")
>
> +
> buf.write("\u0112\u08f2\3\2\2\2\u0114\u08fc\3\2\2\2\u0116\u0915\3")
>
> +
> buf.write("\2\2\2\u0118\u093e\3\2\2\2\u011a\u0942\3\2\2\2\u011c\u0959")
>
> +
> buf.write("\3\2\2\2\u011e\u09b2\3\2\2\2\u0120\u09c3\3\2\2\2\u0122")
>
> +
> buf.write("\u09c6\3\2\2\2\u0124\u09c8\3\2\2\2\u0126\u09d0\3\2\2\2")
>
> +
> buf.write("\u0128\u09d8\3\2\2\2\u012a\u09e0\3\2\2\2\u012c\u09e8\3")
>
> +
> buf.write("\2\2\2\u012e\u09f0\3\2\2\2\u0130\u09fb\3\2\2\2\u0132\u09fd")
>
> +
> buf.write("\3\2\2\2\u0134\u0a0c\3\2\2\2\u0136\u0a0e\3\2\2\2\u0138")
>
> +
> buf.write("\u0a19\3\2\2\2\u013a\u0a1b\3\2\2\2\u013c\u0a26\3\2\2\2")
>
> +
> buf.write("\u013e\u0a28\3\2\2\2\u0140\u0a35\3\2\2\2\u0142\u0a3a\3")
>
> +
> buf.write("\2\2\2\u0144\u0a3f\3\2\2\2\u0146\u0a4e\3\2\2\2\u0148\u0a50")
>
> +
> buf.write("\3\2\2\2\u014a\u0a57\3\2\2\2\u014c\u0a5e\3\2\2\2\u014e")
>
> +
> buf.write("\u0a67\3\2\2\2\u0150\u0a76\3\2\2\2\u0152\u0a78\3\2\2\2")
>
> +
> buf.write("\u0154\u0a7a\3\2\2\2\u0156\u0a8b\3\2\2\2\u0158\u0a99\3")
>
> +
> buf.write("\2\2\2\u015a\u0aa7\3\2\2\2\u015c\u0abb\3\2\2\2\u015e\u0abd"
> )
>
> +
> buf.write("\3\2\2\2\u0160\u0ac3\3\2\2\2\u0162\u0ac8\3\2\2\2\u0164")
>
> +
> buf.write("\u0acd\3\2\2\2\u0166\u0ad8\3\2\2\2\u0168\u0ada\3\2\2\2")
>
> +
> buf.write("\u016a\u0adf\3\2\2\2\u016c\u0ae1\3\2\2\2\u016e\u0aec\3")
>
> +
> buf.write("\2\2\2\u0170\u0af8\3\2\2\2\u0172\u0afa\3\2\2\2\u0174\u0aff")
>
> +
> buf.write("\3\2\2\2\u0176\u0b04\3\2\2\2\u0178\u0b19\3\2\2\2\u017a")
>
> +
> buf.write("\u0b1e\3\2\2\2\u017c\u0b23\3\2\2\2\u017e\u0b2e\3\2\2\2")
>
> +
> buf.write("\u0180\u0b33\3\2\2\2\u0182\u0b38\3\2\2\2\u0184\u0b3d\3")
>
> +
> buf.write("\2\2\2\u0186\u0b4f\3\2\2\2\u0188\u0b51\3\2\2\2\u018a\u0b5a")
>
> +
> buf.write("\3\2\2\2\u018c\u0b6c\3\2\2\2\u018e\u0b6e\3\2\2\2\u0190")
>
> +
> buf.write("\u0b77\3\2\2\2\u0192\u0b80\3\2\2\2\u0194\u0b94\3\2\2\2")
>
> +
> buf.write("\u0196\u0b96\3\2\2\2\u0198\u019c\5\n\6\2\u0199\u019c\5")
>
> + buf.write("\f\7\2\u019a\u019c\5\16\b\2\u019b\u0198\3\2\2\2\u019b")
>
> +
> buf.write("\u0199\3\2\2\2\u019b\u019a\3\2\2\2\u019c\u019f\3\2\2\2")
>
> +
> buf.write("\u019d\u019b\3\2\2\2\u019d\u019e\3\2\2\2\u019e\u01a1\3")
>
> +
> buf.write("\2\2\2\u019f\u019d\3\2\2\2\u01a0\u01a2\5.\30\2\u01a1\u01a0")
>
> +
> buf.write("\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\3\3\2\2\2\u01a3\u01a4")
>
> +
> buf.write("\7\3\2\2\u01a4\5\3\2\2\2\u01a5\u01a8\t\2\2\2\u01a6\u01a7")
>
> +
> buf.write("\7!\2\2\u01a7\u01a9\7\u00fb\2\2\u01a8\u01a6\3\2\2\2\u01a8")
>
> + buf.write("\u01a9\3\2\2\2\u01a9\u01ac\3\2\2\2\u01aa\u01ab\7!\2\2")
>
> +
> buf.write("\u01ab\u01ad\7\u00fa\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ad")
>
> + buf.write("\3\2\2\2\u01ad\7\3\2\2\2\u01ae\u01b0\7\u00fa\2\2\u01af")
>
> +
> buf.write("\u01ae\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\t\3\2\2\2\u01b1")
>
> +
> buf.write("\u01b2\7\6\2\2\u01b2\u01b3\7\7\2\2\u01b3\u01b7\7\30\2")
>
> +
> buf.write("\2\u01b4\u01b8\5\4\3\2\u01b5\u01b8\5\6\4\2\u01b6\u01b8")
>
> +
> buf.write("\5\b\5\2\u01b7\u01b4\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b7")
>
> +
> buf.write("\u01b6\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b9\3\2\2\2")
>
> +
> buf.write("\u01b9\u01ba\7\31\2\2\u01ba\13\3\2\2\2\u01bb\u01bd\7\u0084
> ")
>
> +
> buf.write("\2\2\u01bc\u01bb\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01be")
>
> +
> buf.write("\3\2\2\2\u01be\u01c0\7P\2\2\u01bf\u01c1\7O\2\2\u01c0\u01bf")
>
> + buf.write("\3\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c3\3\2\2\2\u01c2")
>
> + buf.write("\u01c4\7\u00fb\2\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2")
>
> +
> buf.write("\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c6\7\26\2\2\u01c6\u01c7")
>
> + buf.write("\5\20\t\2\u01c7\u01c9\7\27\2\2\u01c8\u01ca\7\u00fb\2\2")
>
> +
> buf.write("\u01c9\u01c8\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cb\3")
>
> + buf.write("\2\2\2\u01cb\u01cc\7 \2\2\u01cc\r\3\2\2\2\u01cd\u01cf")
>
> +
> buf.write("\7\u0084\2\2\u01ce\u01cd\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf")
>
> +
> buf.write("\u01d0\3\2\2\2\u01d0\u01d2\7Q\2\2\u01d1\u01d3\7O\2\2\u01d
> 2")
>
> +
> buf.write("\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d5\3\2\2\2")
>
> +
> buf.write("\u01d4\u01d6\7\u00fb\2\2\u01d5\u01d4\3\2\2\2\u01d5\u01d6")
>
> +
> buf.write("\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7\u01d8\7\26\2\2\u01d8")
>
> +
> buf.write("\u01d9\5\20\t\2\u01d9\u01db\7\27\2\2\u01da\u01dc\7\u00fb")
>
> +
> buf.write("\2\2\u01db\u01da\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01dd")
>
> + buf.write("\3\2\2\2\u01dd\u01de\7
> \2\2\u01de\17\3\2\2\2\u01df\u01ee")
>
> +
> buf.write("\5\22\n\2\u01e0\u01ee\5\24\13\2\u01e1\u01ee\5\26\f\2\u01e2")
>
> +
> buf.write("\u01ee\5\30\r\2\u01e3\u01ee\5\32\16\2\u01e4\u01ee\5\34")
>
> + buf.write("\17\2\u01e5\u01ee\5\36\20\2\u01e6\u01ee\5 \21\2\u01e7")
>
> +
> buf.write("\u01ee\5\"\22\2\u01e8\u01ee\5$\23\2\u01e9\u01ee\5&\24")
>
> +
> buf.write("\2\u01ea\u01ee\5(\25\2\u01eb\u01ee\5*\26\2\u01ec\u01ee")
>
> +
> buf.write("\5,\27\2\u01ed\u01df\3\2\2\2\u01ed\u01e0\3\2\2\2\u01ed")
>
> +
> buf.write("\u01e1\3\2\2\2\u01ed\u01e2\3\2\2\2\u01ed\u01e3\3\2\2\2")
>
> +
> buf.write("\u01ed\u01e4\3\2\2\2\u01ed\u01e5\3\2\2\2\u01ed\u01e6\3")
>
> +
> buf.write("\2\2\2\u01ed\u01e7\3\2\2\2\u01ed\u01e8\3\2\2\2\u01ed\u01e9"
> )
>
> +
> buf.write("\3\2\2\2\u01ed\u01ea\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed")
>
> + buf.write("\u01ec\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef\u01ed\3\2\2\2")
>
> + buf.write("\u01ef\u01f0\3\2\2\2\u01f0\21\3\2\2\2\u01f1\u01ef\3\2")
>
> + buf.write("\2\2\u01f2\u01f3\7S\2\2\u01f3\u01f7\7\u00fb\2\2\u01f4")
>
> + buf.write("\u01f5\7\32\2\2\u01f5\u01f6\7\u00fa\2\2\u01f6\u01f8\7")
>
> + buf.write("\33\2\2\u01f7\u01f4\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8")
>
> + buf.write("\u01f9\3\2\2\2\u01f9\u01fa\7
> \2\2\u01fa\23\3\2\2\2\u01fb")
>
> + buf.write("\u01fc\7T\2\2\u01fc\u0200\7\u00fb\2\2\u01fd\u01fe\7\32")
>
> + buf.write("\2\2\u01fe\u01ff\7\u00fa\2\2\u01ff\u0201\7\33\2\2\u0200")
>
> +
> buf.write("\u01fd\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0202\3\2\2\2")
>
> + buf.write("\u0202\u0203\7 \2\2\u0203\25\3\2\2\2\u0204\u0205\7U\2")
>
> +
> buf.write("\2\u0205\u0209\7\u00fb\2\2\u0206\u0207\7\32\2\2\u0207")
>
> +
> buf.write("\u0208\7\u00fa\2\2\u0208\u020a\7\33\2\2\u0209\u0206\3")
>
> +
> buf.write("\2\2\2\u0209\u020a\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020c"
> )
>
> + buf.write("\7
> \2\2\u020c\27\3\2\2\2\u020d\u020e\7V\2\2\u020e\u0212")
>
> + buf.write("\7\u00fb\2\2\u020f\u0210\7\32\2\2\u0210\u0211\7\u00fa")
>
> +
> buf.write("\2\2\u0211\u0213\7\33\2\2\u0212\u020f\3\2\2\2\u0212\u0213")
>
> + buf.write("\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0215\7 \2\2\u0215")
>
> +
> buf.write("\31\3\2\2\2\u0216\u0217\7R\2\2\u0217\u021b\7\u00fb\2\2")
>
> +
> buf.write("\u0218\u0219\7\32\2\2\u0219\u021a\7\u00fa\2\2\u021a\u021c")
>
> +
> buf.write("\7\33\2\2\u021b\u0218\3\2\2\2\u021b\u021c\3\2\2\2\u021c")
>
> + buf.write("\u021d\3\2\2\2\u021d\u021e\7
> \2\2\u021e\33\3\2\2\2\u021f")
>
> +
> buf.write("\u0220\7W\2\2\u0220\u0224\7\u00fb\2\2\u0221\u0222\7\32")
>
> +
> buf.write("\2\2\u0222\u0223\7\u00fa\2\2\u0223\u0225\7\33\2\2\u0224")
>
> +
> buf.write("\u0221\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0226\3\2\2\2")
>
> + buf.write("\u0226\u0227\7 \2\2\u0227\35\3\2\2\2\u0228\u0229\7X\2")
>
> +
> buf.write("\2\u0229\u022d\7\u00fb\2\2\u022a\u022b\7\32\2\2\u022b")
>
> + buf.write("\u022c\7\u00fa\2\2\u022c\u022e\7\33\2\2\u022d\u022a\3")
>
> +
> buf.write("\2\2\2\u022d\u022e\3\2\2\2\u022e\u022f\3\2\2\2\u022f\u0230")
>
> + buf.write("\7
> \2\2\u0230\37\3\2\2\2\u0231\u0232\7Y\2\2\u0232\u0236")
>
> + buf.write("\7\u00fb\2\2\u0233\u0234\7\32\2\2\u0234\u0235\7\u00fa")
>
> +
> buf.write("\2\2\u0235\u0237\7\33\2\2\u0236\u0233\3\2\2\2\u0236\u0237")
>
> + buf.write("\3\2\2\2\u0237\u0238\3\2\2\2\u0238\u0239\7 \2\2\u0239")
>
> +
> buf.write("!\3\2\2\2\u023a\u023b\7Z\2\2\u023b\u023f\7\u00fb\2\2\u023c")
>
> +
> buf.write("\u023d\7\32\2\2\u023d\u023e\7\u00fa\2\2\u023e\u0240\7")
>
> + buf.write("\33\2\2\u023f\u023c\3\2\2\2\u023f\u0240\3\2\2\2\u0240")
>
> + buf.write("\u0241\3\2\2\2\u0241\u0242\7
> \2\2\u0242#\3\2\2\2\u0243")
>
> +
> buf.write("\u0244\7\u00fb\2\2\u0244\u0248\7\u00fb\2\2\u0245\u0246")
>
> +
> buf.write("\7\32\2\2\u0246\u0247\7\u00fa\2\2\u0247\u0249\7\33\2\2")
>
> +
> buf.write("\u0248\u0245\3\2\2\2\u0248\u0249\3\2\2\2\u0249\u024a\3")
>
> + buf.write("\2\2\2\u024a\u024b\7
> \2\2\u024b%\3\2\2\2\u024c\u024e\7")
>
> +
> buf.write("S\2\2\u024d\u024f\7\u00fb\2\2\u024e\u024d\3\2\2\2\u024e")
>
> + buf.write("\u024f\3\2\2\2\u024f\u0250\3\2\2\2\u0250\u0251\7\36\2")
>
> + buf.write("\2\u0251\u0252\7\u00fa\2\2\u0252\u0253\7 \2\2\u0253\'")
>
> +
> buf.write("\3\2\2\2\u0254\u0256\7T\2\2\u0255\u0257\7\u00fb\2\2\u0256")
>
> +
> buf.write("\u0255\3\2\2\2\u0256\u0257\3\2\2\2\u0257\u0258\3\2\2\2")
>
> +
> buf.write("\u0258\u0259\7\36\2\2\u0259\u025a\7\u00fa\2\2\u025a\u025b")
>
> + buf.write("\7 \2\2\u025b)\3\2\2\2\u025c\u025e\7U\2\2\u025d\u025f")
>
> +
> buf.write("\7\u00fb\2\2\u025e\u025d\3\2\2\2\u025e\u025f\3\2\2\2\u025f")
>
> +
> buf.write("\u0260\3\2\2\2\u0260\u0261\7\36\2\2\u0261\u0262\7\u00fa")
>
> + buf.write("\2\2\u0262\u0263\7 \2\2\u0263+\3\2\2\2\u0264\u0266\7V")
>
> +
> buf.write("\2\2\u0265\u0267\7\u00fb\2\2\u0266\u0265\3\2\2\2\u0266")
>
> + buf.write("\u0267\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u0269\7\36\2")
>
> + buf.write("\2\u0269\u026a\7\u00fa\2\2\u026a\u026b\7 \2\2\u026b-
> \3")
>
> +
> buf.write("\2\2\2\u026c\u026d\7+\2\2\u026d\u026e\7[\2\2\u026e\u026f")
>
> +
> buf.write("\7\b\2\2\u026f\u0270\5L\'\2\u0270\u0271\7!\2\2\u0271\u0272")
>
> +
> buf.write("\7.\2\2\u0272\u0273\7\b\2\2\u0273\u0274\7\u00ec\2\2\u0274")
>
> +
> buf.write("\u0275\7\30\2\2\u0275\u0276\7\u00fa\2\2\u0276\u0277\7")
>
> +
> buf.write("\31\2\2\u0277\u0278\7!\2\2\u0278\u0279\7=\2\2\u0279\u027a")
>
> + buf.write("\7\b\2\2\u027a\u027b\7\u00ec\2\2\u027b\u027c\7\30\2\2")
>
> +
> buf.write("\u027c\u027d\7\u00fa\2\2\u027d\u027e\7\31\2\2\u027e\u0284")
>
> +
> buf.write("\7!\2\2\u027f\u0280\7\u0083\2\2\u0280\u0281\7\b\2\2\u0281")
>
> + buf.write("\u0282\5\60\31\2\u0282\u0283\7!\2\2\u0283\u0285\3\2\2")
>
> +
> buf.write("\2\u0284\u027f\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u028b")
>
> +
> buf.write("\3\2\2\2\u0286\u0287\7\u0081\2\2\u0287\u0288\7\b\2\2\u0288"
> )
>
> + buf.write("\u0289\5\62\32\2\u0289\u028a\7!\2\2\u028a\u028c\3\2\2")
>
> +
> buf.write("\2\u028b\u0286\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u0292")
>
> +
> buf.write("\3\2\2\2\u028d\u028e\7\u0082\2\2\u028e\u028f\7\b\2\2\u028f")
>
> + buf.write("\u0290\5\66\34\2\u0290\u0291\7!\2\2\u0291\u0293\3\2\2")
>
> +
> buf.write("\2\u0292\u028d\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0294")
>
> + buf.write("\3\2\2\2\u0294\u0295\58\35\2\u0295\u0296\7-\2\2\u0296")
>
> + buf.write("\u0297\7 \2\2\u0297/\3\2\2\2\u0298\u029b\5L\'\2\u0299")
>
> +
> buf.write("\u029a\7(\2\2\u029a\u029c\5L\'\2\u029b\u0299\3\2\2\2\u029b")
>
> + buf.write("\u029c\3\2\2\2\u029c\u029f\3\2\2\2\u029d\u029e\7(\2\2")
>
> + buf.write("\u029e\u02a0\5L\'\2\u029f\u029d\3\2\2\2\u029f\u02a0\3")
>
> +
> buf.write("\2\2\2\u02a0\u02a3\3\2\2\2\u02a1\u02a2\7(\2\2\u02a2\u02a4")
>
> + buf.write("\5L\'\2\u02a3\u02a1\3\2\2\2\u02a3\u02a4\3\2\2\2\u02a4")
>
> +
> buf.write("\61\3\2\2\2\u02a5\u02aa\5\64\33\2\u02a6\u02a7\7(\2\2\u02a7")
>
> +
> buf.write("\u02a9\5\64\33\2\u02a8\u02a6\3\2\2\2\u02a9\u02ac\3\2\2")
>
> +
> buf.write("\2\u02aa\u02a8\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab\63\3")
>
> +
> buf.write("\2\2\2\u02ac\u02aa\3\2\2\2\u02ad\u02ae\t\3\2\2\u02ae\65")
>
> +
> buf.write("\3\2\2\2\u02af\u02b0\t\4\2\2\u02b0\67\3\2\2\2\u02b1\u02b3")
>
> +
> buf.write("\5:\36\2\u02b2\u02b1\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4")
>
> +
> buf.write("\u02b2\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b59\3\2\2\2\u02b6")
>
> +
> buf.write("\u02b4\3\2\2\2\u02b7\u02c2\5d\63\2\u02b8\u02c2\5h\65\2")
>
> + buf.write("\u02b9\u02c2\5j\66\2\u02ba\u02c2\5>
> \2\u02bb\u02c2\5@")
>
> +
> buf.write("!\2\u02bc\u02c2\5D#\2\u02bd\u02c2\5<\37\2\u02be\u02c2")
>
> +
> buf.write("\5F$\2\u02bf\u02c2\5H%\2\u02c0\u02c2\5\u011c\u008f\2\u02c1"
> )
>
> +
> buf.write("\u02b7\3\2\2\2\u02c1\u02b8\3\2\2\2\u02c1\u02b9\3\2\2\2")
>
> +
> buf.write("\u02c1\u02ba\3\2\2\2\u02c1\u02bb\3\2\2\2\u02c1\u02bc\3")
>
> +
> buf.write("\2\2\2\u02c1\u02bd\3\2\2\2\u02c1\u02be\3\2\2\2\u02c1\u02bf")
>
> +
> buf.write("\3\2\2\2\u02c1\u02c0\3\2\2\2\u02c2;\3\2\2\2\u02c3\u02c4")
>
> + buf.write("\7\u009b\2\2\u02c4\u02c5\7\u00fb\2\2\u02c5\u02c6\7!\2")
>
> +
> buf.write("\2\u02c6\u02c7\7\62\2\2\u02c7\u02c8\7\b\2\2\u02c8\u02c9")
>
> + buf.write("\7\u00ec\2\2\u02c9\u02ca\7\30\2\2\u02ca\u02cb\7\u00fa")
>
> +
> buf.write("\2\2\u02cb\u02d0\7\31\2\2\u02cc\u02cd\7!\2\2\u02cd\u02ce")
>
> + buf.write("\7\u009c\2\2\u02ce\u02cf\7\b\2\2\u02cf\u02d1\7\u00fa\2")
>
> +
> buf.write("\2\u02d0\u02cc\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2")
>
> + buf.write("\3\2\2\2\u02d2\u02d3\7
> \2\2\u02d3=\3\2\2\2\u02d4\u02e5")
>
> +
> buf.write("\7\u009d\2\2\u02d5\u02d6\7\u00fb\2\2\u02d6\u02e6\7!\2")
>
> +
> buf.write("\2\u02d7\u02d8\7V\2\2\u02d8\u02e6\7!\2\2\u02d9\u02da\7")
>
> +
> buf.write("U\2\2\u02da\u02e6\7!\2\2\u02db\u02dc\7T\2\2\u02dc\u02e6")
>
> +
> buf.write("\7!\2\2\u02dd\u02de\7S\2\2\u02de\u02e6\7!\2\2\u02df\u02e0")
>
> +
> buf.write("\7X\2\2\u02e0\u02e6\7!\2\2\u02e1\u02e2\7Y\2\2\u02e2\u02e6")
>
> +
> buf.write("\7!\2\2\u02e3\u02e4\7Z\2\2\u02e4\u02e6\7!\2\2\u02e5\u02d5")
>
> +
> buf.write("\3\2\2\2\u02e5\u02d7\3\2\2\2\u02e5\u02d9\3\2\2\2\u02e5")
>
> +
> buf.write("\u02db\3\2\2\2\u02e5\u02dd\3\2\2\2\u02e5\u02df\3\2\2\2")
>
> +
> buf.write("\u02e5\u02e1\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e6\u02eb\3")
>
> +
> buf.write("\2\2\2\u02e7\u02e8\7\u008f\2\2\u02e8\u02e9\7\b\2\2\u02e9")
>
> + buf.write("\u02ea\7\u00fa\2\2\u02ea\u02ec\7!\2\2\u02eb\u02e7\3\2")
>
> +
> buf.write("\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed\u02ee")
>
> + buf.write("\7\u008e\2\2\u02ee\u02ef\7\b\2\2\u02ef\u02f0\7\u00fb\2")
>
> + buf.write("\2\u02f0\u02f1\7!\2\2\u02f1\u02f2\7[\2\2\u02f2\u02f3\7")
>
> + buf.write("\b\2\2\u02f3\u02f4\5L\'\2\u02f4\u02f5\7 \2\2\u02f5?\3")
>
> + buf.write("\2\2\2\u02f6\u0307\7\u009e\2\2\u02f7\u02f8\7\u00fb\2\2")
>
> + buf.write("\u02f8\u0308\7!\2\2\u02f9\u02fa\7V\2\2\u02fa\u0308\7!")
>
> + buf.write("\2\2\u02fb\u02fc\7U\2\2\u02fc\u0308\7!\2\2\u02fd\u02fe")
>
> +
> buf.write("\7T\2\2\u02fe\u0308\7!\2\2\u02ff\u0300\7S\2\2\u0300\u0308")
>
> +
> buf.write("\7!\2\2\u0301\u0302\7X\2\2\u0302\u0308\7!\2\2\u0303\u0304")
>
> +
> buf.write("\7Y\2\2\u0304\u0308\7!\2\2\u0305\u0306\7Z\2\2\u0306\u0308")
>
> + buf.write("\7!\2\2\u0307\u02f7\3\2\2\2\u0307\u02f9\3\2\2\2\u0307")
>
> + buf.write("\u02fb\3\2\2\2\u0307\u02fd\3\2\2\2\u0307\u02ff\3\2\2\2")
>
> +
> buf.write("\u0307\u0301\3\2\2\2\u0307\u0303\3\2\2\2\u0307\u0305\3")
>
> +
> buf.write("\2\2\2\u0308\u030d\3\2\2\2\u0309\u030a\7\u008f\2\2\u030a")
>
> + buf.write("\u030b\7\b\2\2\u030b\u030c\7\u00fa\2\2\u030c\u030e\7!")
>
> +
> buf.write("\2\2\u030d\u0309\3\2\2\2\u030d\u030e\3\2\2\2\u030e\u030f")
>
> +
> buf.write("\3\2\2\2\u030f\u0310\7\u009c\2\2\u0310\u0311\7\b\2\2\u0311")
>
> +
> buf.write("\u0316\5B\"\2\u0312\u0313\7(\2\2\u0313\u0315\5B\"\2\u0314")
>
> +
> buf.write("\u0312\3\2\2\2\u0315\u0318\3\2\2\2\u0316\u0314\3\2\2\2")
>
> +
> buf.write("\u0316\u0317\3\2\2\2\u0317\u0319\3\2\2\2\u0318\u0316\3")
>
> +
> buf.write("\2\2\2\u0319\u0329\7!\2\2\u031a\u031b\7\u008e\2\2\u031b")
>
> + buf.write("\u031c\7\b\2\2\u031c\u031d\7\u00fb\2\2\u031d\u032a\7!")
>
> +
> buf.write("\2\2\u031e\u031f\7\u008e\2\2\u031f\u0320\7\b\2\2\u0320")
>
> +
> buf.write("\u0321\7\u00ec\2\2\u0321\u0322\7\30\2\2\u0322\u0323\7")
>
> +
> buf.write("\u00fa\2\2\u0323\u0324\7\31\2\2\u0324\u0325\7!\2\2\u0325")
>
> +
> buf.write("\u0326\7\u009f\2\2\u0326\u0327\7\b\2\2\u0327\u0328\7\u00fa")
>
> +
> buf.write("\2\2\u0328\u032a\7!\2\2\u0329\u031a\3\2\2\2\u0329\u031e")
>
> + buf.write("\3\2\2\2\u032a\u032b\3\2\2\2\u032b\u032c\7[\2\2\u032c")
>
> + buf.write("\u032d\7\b\2\2\u032d\u032e\5L\'\2\u032e\u032f\7
> \2\2\u032f")
>
> +
> buf.write("A\3\2\2\2\u0330\u0331\7\u00fa\2\2\u0331C\3\2\2\2\u0332")
>
> +
> buf.write("\u0333\7\u00a0\2\2\u0333\u0334\7\u00fb\2\2\u0334\u0339")
>
> +
> buf.write("\7!\2\2\u0335\u0336\7\u008f\2\2\u0336\u0337\7\b\2\2\u0337")
>
> + buf.write("\u0338\7\u00fa\2\2\u0338\u033a\7!\2\2\u0339\u0335\3\2")
>
> +
> buf.write("\2\2\u0339\u033a\3\2\2\2\u033a\u0342\3\2\2\2\u033b\u033c")
>
> +
> buf.write("\7\u008e\2\2\u033c\u033d\7\b\2\2\u033d\u033e\7\u00ec\2")
>
> + buf.write("\2\u033e\u033f\7\30\2\2\u033f\u0340\7\u00fa\2\2\u0340")
>
> +
> buf.write("\u0341\7\31\2\2\u0341\u0343\7!\2\2\u0342\u033b\3\2\2\2")
>
> +
> buf.write("\u0343\u0344\3\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3")
>
> +
> buf.write("\2\2\2\u0345\u0346\3\2\2\2\u0346\u0347\7[\2\2\u0347\u0348")
>
> + buf.write("\7\b\2\2\u0348\u0349\5L\'\2\u0349\u034a\7 \2\2\u034aE")
>
> + buf.write("\3\2\2\2\u034b\u034c\7l\2\2\u034c\u034d\5\u0124\u0093")
>
> + buf.write("\2\u034d\u034e\7 \2\2\u034e\u034f\58\35\2\u034f\u0350")
>
> + buf.write("\7s\2\2\u0350\u0351\7 \2\2\u0351G\3\2\2\2\u0352\u0353")
>
> + buf.write("\7k\2\2\u0353\u0354\5\u0124\u0093\2\u0354\u0355\7
> \2\2")
>
> +
> buf.write("\u0355\u0356\58\35\2\u0356\u0357\7s\2\2\u0357\u0358\7")
>
> + buf.write("
> \2\2\u0358I\3\2\2\2\u0359\u035a\7\u00fa\2\2\u035a\u035b")
>
> +
> buf.write("\7!\2\2\u035b\u035c\7\u00fa\2\2\u035c\u035d\7!\2\2\u035d")
>
> +
> buf.write("\u035e\7\u00fa\2\2\u035e\u035f\7!\2\2\u035f\u0360\7\u00fa")
>
> + buf.write("\2\2\u0360\u0361\7!\2\2\u0361\u0362\7\u00fa\2\2\u0362")
>
> +
> buf.write("\u0363\7!\2\2\u0363\u0364\7\u00fa\2\2\u0364\u0365\7!\2")
>
> +
> buf.write("\2\u0365\u0366\7\u00fa\2\2\u0366\u0367\7!\2\2\u0367\u0368")
>
> +
> buf.write("\7\u00fa\2\2\u0368K\3\2\2\2\u0369\u036a\7\26\2\2\u036a")
>
> +
> buf.write("\u036b\7\u00fa\2\2\u036b\u036c\7!\2\2\u036c\u036d\7\u00fa")
>
> + buf.write("\2\2\u036d\u036e\7!\2\2\u036e\u036f\7\u00fa\2\2\u036f")
>
> +
> buf.write("\u0375\7!\2\2\u0370\u0371\7\26\2\2\u0371\u0372\5J&\2\u0372"
> )
>
> +
> buf.write("\u0373\7\27\2\2\u0373\u0376\3\2\2\2\u0374\u0376\5J&\2")
>
> +
> buf.write("\u0375\u0370\3\2\2\2\u0375\u0374\3\2\2\2\u0376\u0377\3")
>
> +
> buf.write("\2\2\2\u0377\u0378\7\27\2\2\u0378M\3\2\2\2\u0379\u037a")
>
> + buf.write("\7\u00ec\2\2\u037a\u037b\7\30\2\2\u037b\u037c\7\u00fa")
>
> +
> buf.write("\2\2\u037c\u037d\7\31\2\2\u037dO\3\2\2\2\u037e\u037f\5")
>
> +
> buf.write("R*\2\u037f\u0380\5T+\2\u0380Q\3\2\2\2\u0381\u0382\7\u008e")
>
> +
> buf.write("\2\2\u0382\u0383\7\b\2\2\u0383\u0384\7\u00fb\2\2\u0384")
>
> + buf.write("\u0386\7!\2\2\u0385\u0381\3\2\2\2\u0385\u0386\3\2\2\2")
>
> +
> buf.write("\u0386\u038c\3\2\2\2\u0387\u0388\7\u008f\2\2\u0388\u0389")
>
> + buf.write("\7\b\2\2\u0389\u038a\5X-
> \2\u038a\u038b\7!\2\2\u038b\u038d")
>
> +
> buf.write("\3\2\2\2\u038c\u0387\3\2\2\2\u038c\u038d\3\2\2\2\u038d")
>
> +
> buf.write("\u0392\3\2\2\2\u038e\u038f\7\u0091\2\2\u038f\u0390\7\b")
>
> + buf.write("\2\2\u0390\u0391\7\u00fa\2\2\u0391\u0393\7!\2\2\u0392")
>
> +
> buf.write("\u038e\3\2\2\2\u0392\u0393\3\2\2\2\u0393S\3\2\2\2\u0394")
>
> +
> buf.write("\u0395\7\62\2\2\u0395\u0396\7\b\2\2\u0396\u0397\7\u00ec")
>
> +
> buf.write("\2\2\u0397\u0398\7\30\2\2\u0398\u0399\7\u00fa\2\2\u0399")
>
> + buf.write("\u039a\7\31\2\2\u039a\u039b\7!\2\2\u039b\u039c\7=\2\2")
>
> +
> buf.write("\u039c\u039d\7\b\2\2\u039d\u039e\7\u00ec\2\2\u039e\u039f")
>
> +
> buf.write("\7\30\2\2\u039f\u03a0\7\u00fa\2\2\u03a0\u03a1\7\31\2\2")
>
> +
> buf.write("\u03a1U\3\2\2\2\u03a2\u03ab\7~\2\2\u03a3\u03ab\7y\2\2")
>
> +
> buf.write("\u03a4\u03ab\7{\2\2\u03a5\u03ab\7\u0080\2\2\u03a6\u03ab")
>
> +
> buf.write("\7|\2\2\u03a7\u03ab\7\177\2\2\u03a8\u03ab\7z\2\2\u03a9")
>
> + buf.write("\u03ab\7}\2\2\u03aa\u03a2\3\2\2\2\u03aa\u03a3\3\2\2\2")
>
> +
> buf.write("\u03aa\u03a4\3\2\2\2\u03aa\u03a5\3\2\2\2\u03aa\u03a6\3")
>
> +
> buf.write("\2\2\2\u03aa\u03a7\3\2\2\2\u03aa\u03a8\3\2\2\2\u03aa\u03a9"
> )
>
> +
> buf.write("\3\2\2\2\u03abW\3\2\2\2\u03ac\u03ad\7\u00fb\2\2\u03ad")
>
> + buf.write("\u03ae\7\32\2\2\u03ae\u03af\7\u00fa\2\2\u03af\u03b9\7")
>
> +
> buf.write("\33\2\2\u03b0\u03b5\7\u00fb\2\2\u03b1\u03b2\7\34\2\2\u03b2"
> )
>
> +
> buf.write("\u03b4\5\u015e\u00b0\2\u03b3\u03b1\3\2\2\2\u03b4\u03b7")
>
> +
> buf.write("\3\2\2\2\u03b5\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6")
>
> +
> buf.write("\u03b9\3\2\2\2\u03b7\u03b5\3\2\2\2\u03b8\u03ac\3\2\2\2")
>
> +
> buf.write("\u03b8\u03b0\3\2\2\2\u03b9Y\3\2\2\2\u03ba\u03bc\7\35\2")
>
> +
> buf.write("\2\u03bb\u03ba\3\2\2\2\u03bb\u03bc\3\2\2\2\u03bc\u03bd")
>
> +
> buf.write("\3\2\2\2\u03bd\u03e7\7\u00fa\2\2\u03be\u03e7\7\u00d3\2")
>
> +
> buf.write("\2\u03bf\u03e7\7\u00d4\2\2\u03c0\u03e7\7\u00d5\2\2\u03c1")
>
> +
> buf.write("\u03e7\7\u00d6\2\2\u03c2\u03e7\7\u00d7\2\2\u03c3\u03c4")
>
> + buf.write("\7\u00fa\2\2\u03c4\u03c5\7\36\2\2\u03c5\u03c6\7\u00fa")
>
> +
> buf.write("\2\2\u03c6\u03c7\7\36\2\2\u03c7\u03e7\7\u00fa\2\2\u03c8")
>
> + buf.write("\u03c9\7\u00fa\2\2\u03c9\u03ca\7\37\2\2\u03ca\u03cb\7")
>
> + buf.write("\u00fa\2\2\u03cb\u03cc\7\37\2\2\u03cc\u03e7\7\u00fa\2")
>
> + buf.write("\2\u03cd\u03ce\7\u00fa\2\2\u03ce\u03cf\7
> \2\2\u03cf\u03d0")
>
> + buf.write("\7\u00fa\2\2\u03d0\u03d1\7
> \2\2\u03d1\u03d2\5L\'\2\u03d2")
>
> + buf.write("\u03d3\7
> \2\2\u03d3\u03d4\7\u00ec\2\2\u03d4\u03d5\7\30")
>
> +
> buf.write("\2\2\u03d5\u03d6\7\u00fa\2\2\u03d6\u03d7\7\31\2\2\u03d7")
>
> +
> buf.write("\u03e7\3\2\2\2\u03d8\u03d9\7\u00ec\2\2\u03d9\u03da\7\30")
>
> +
> buf.write("\2\2\u03da\u03db\7\u00fa\2\2\u03db\u03e7\7\31\2\2\u03dc")
>
> +
> buf.write("\u03dd\7\26\2\2\u03dd\u03e2\7\u00fa\2\2\u03de\u03df\7")
>
> +
> buf.write("!\2\2\u03df\u03e1\7\u00fa\2\2\u03e0\u03de\3\2\2\2\u03e1")
>
> +
> buf.write("\u03e4\3\2\2\2\u03e2\u03e0\3\2\2\2\u03e2\u03e3\3\2\2\2")
>
> +
> buf.write("\u03e3\u03e5\3\2\2\2\u03e4\u03e2\3\2\2\2\u03e5\u03e7\7")
>
> +
> buf.write("\27\2\2\u03e6\u03bb\3\2\2\2\u03e6\u03be\3\2\2\2\u03e6")
>
> + buf.write("\u03bf\3\2\2\2\u03e6\u03c0\3\2\2\2\u03e6\u03c1\3\2\2\2")
>
> +
> buf.write("\u03e6\u03c2\3\2\2\2\u03e6\u03c3\3\2\2\2\u03e6\u03c8\3")
>
> +
> buf.write("\2\2\2\u03e6\u03cd\3\2\2\2\u03e6\u03d8\3\2\2\2\u03e6\u03dc")
>
> + buf.write("\3\2\2\2\u03e7[\3\2\2\2\u03e8\u03e9\7\u0092\2\2\u03e9")
>
> + buf.write("\u03ea\7\b\2\2\u03ea\u03eb\7\t\2\2\u03eb\u03ec\7\30\2")
>
> +
> buf.write("\2\u03ec\u03ed\7\u00fa\2\2\u03ed\u03ee\7\31\2\2\u03ee")
>
> + buf.write("]\3\2\2\2\u03ef\u03f0\7\u0093\2\2\u03f0_\3\2\2\2\u03f1")
>
> + buf.write("\u03f4\5\\/\2\u03f2\u03f4\5^\60\2\u03f3\u03f1\3\2\2\2")
>
> + buf.write("\u03f3\u03f2\3\2\2\2\u03f4a\3\2\2\2\u03f5\u03fa\5`\61")
>
> + buf.write("\2\u03f6\u03f7\7!\2\2\u03f7\u03f9\5`\61\2\u03f8\u03f6")
>
> + buf.write("\3\2\2\2\u03f9\u03fc\3\2\2\2\u03fa\u03f8\3\2\2\2\u03fa")
>
> + buf.write("\u03fb\3\2\2\2\u03fbc\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fd")
>
> + buf.write("\u03fe\7\67\2\2\u03fe\u03ff\7/\2\2\u03ff\u0400\7\b\2\2")
>
> +
> buf.write("\u0400\u0401\7\u00fa\2\2\u0401\u0402\7!\2\2\u0402\u0403")
>
> +
> buf.write("\7.\2\2\u0403\u0404\7\b\2\2\u0404\u0405\7\u00ec\2\2\u0405")
>
> +
> buf.write("\u0406\7\30\2\2\u0406\u0407\7\u00fa\2\2\u0407\u0408\7")
>
> + buf.write("\31\2\2\u0408\u040c\7
> \2\2\u0409\u040b\5f\64\2\u040a\u0409")
>
> +
> buf.write("\3\2\2\2\u040b\u040e\3\2\2\2\u040c\u040a\3\2\2\2\u040c")
>
> +
> buf.write("\u040d\3\2\2\2\u040d\u040f\3\2\2\2\u040e\u040c\3\2\2\2")
>
> + buf.write("\u040f\u0410\7\66\2\2\u0410\u0411\7 \2\2\u0411e\3\2\2")
>
> +
> buf.write("\2\u0412\u0422\5j\66\2\u0413\u0422\5l\67\2\u0414\u0422")
>
> +
> buf.write("\5n8\2\u0415\u0422\5\u00a4S\2\u0416\u0422\5p9\2\u0417")
>
> +
> buf.write("\u0422\5\u0088E\2\u0418\u0422\5\u00f8}\2\u0419\u0422\5")
>
> +
> buf.write("\u0118\u008d\2\u041a\u0422\5\u011a\u008e\2\u041b\u0422")
>
> +
> buf.write("\5\u0110\u0089\2\u041c\u0422\5\u011c\u008f\2\u041d\u0422")
>
> +
> buf.write("\5\u0120\u0091\2\u041e\u041f\5\u0096L\2\u041f\u0420\7")
>
> + buf.write("
> \2\2\u0420\u0422\3\2\2\2\u0421\u0412\3\2\2\2\u0421\u0413")
>
> +
> buf.write("\3\2\2\2\u0421\u0414\3\2\2\2\u0421\u0415\3\2\2\2\u0421")
>
> +
> buf.write("\u0416\3\2\2\2\u0421\u0417\3\2\2\2\u0421\u0418\3\2\2\2")
>
> +
> buf.write("\u0421\u0419\3\2\2\2\u0421\u041a\3\2\2\2\u0421\u041b\3")
>
> +
> buf.write("\2\2\2\u0421\u041c\3\2\2\2\u0421\u041d\3\2\2\2\u0421\u041e")
>
> +
> buf.write("\3\2\2\2\u0422g\3\2\2\2\u0423\u0424\78\2\2\u0424\u0425")
>
> +
> buf.write("\7/\2\2\u0425\u0426\7\b\2\2\u0426\u0427\7\u00fa\2\2\u0427")
>
> +
> buf.write("\u0436\7!\2\2\u0428\u0429\79\2\2\u0429\u042a\7\b\2\2\u042a"
> )
>
> +
> buf.write("\u042b\7\u00ec\2\2\u042b\u042c\7\30\2\2\u042c\u042d\7")
>
> + buf.write("\u00fa\2\2\u042d\u042e\7\31\2\2\u042e\u042f\7
> \2\2\u042f")
>
> +
> buf.write("\u0430\7:\2\2\u0430\u0431\7\b\2\2\u0431\u0432\5L\'\2\u0432")
>
> + buf.write("\u0433\7 \2\2\u0433\u0435\3\2\2\2\u0434\u0428\3\2\2\2")
>
> +
> buf.write("\u0435\u0438\3\2\2\2\u0436\u0434\3\2\2\2\u0436\u0437\3")
>
> +
> buf.write("\2\2\2\u0437\u043c\3\2\2\2\u0438\u0436\3\2\2\2\u0439\u043b")
>
> +
> buf.write("\5f\64\2\u043a\u0439\3\2\2\2\u043b\u043e\3\2\2\2\u043c")
>
> +
> buf.write("\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d\u043f\3\2\2\2")
>
> + buf.write("\u043e\u043c\3\2\2\2\u043f\u0440\7\66\2\2\u0440\u0441")
>
> + buf.write("\7 \2\2\u0441i\3\2\2\2\u0442\u0443\5\\/\2\u0443\u0444")
>
> + buf.write("\7
> \2\2\u0444k\3\2\2\2\u0445\u0446\5^\60\2\u0446\u0447")
>
> + buf.write("\7
> \2\2\u0447m\3\2\2\2\u0448\u0449\7\u0094\2\2\u0449\u044a")
>
> +
> buf.write("\7\u00fb\2\2\u044a\u044b\7!\2\2\u044b\u044c\5\u0124\u0093")
>
> + buf.write("\2\u044c\u044d\7\u0095\2\2\u044d\u044e\7
> \2\2\u044eo\3")
>
> +
> buf.write("\2\2\2\u044f\u0453\5r:\2\u0450\u0453\5z>\2\u0451\u0453")
>
> +
> buf.write("\5~@\2\u0452\u044f\3\2\2\2\u0452\u0450\3\2\2\2\u0452\u0451
> ")
>
> +
> buf.write("\3\2\2\2\u0453q\3\2\2\2\u0454\u0455\7;\2\2\u0455\u0456")
>
> +
> buf.write("\7>\2\2\u0456\u0457\7\b\2\2\u0457\u0458\7\u00ec\2\2\u0458")
>
> + buf.write("\u0459\7\30\2\2\u0459\u045a\7\u00fa\2\2\u045a\u045f\7")
>
> +
> buf.write("\31\2\2\u045b\u045c\7!\2\2\u045c\u045d\7@\2\2\u045d\u045e")
>
> +
> buf.write("\7\b\2\2\u045e\u0460\5v<\2\u045f\u045b\3\2\2\2\u045f\u0460")
>
> + buf.write("\3\2\2\2\u0460\u0475\3\2\2\2\u0461\u0462\7!\2\2\u0462")
>
> +
> buf.write("\u0464\5b\62\2\u0463\u0461\3\2\2\2\u0463\u0464\3\2\2\2")
>
> + buf.write("\u0464\u0465\3\2\2\2\u0465\u0476\7 \2\2\u0466\u0467\7")
>
> +
> buf.write("!\2\2\u0467\u0469\5b\62\2\u0468\u0466\3\2\2\2\u0468\u0469")
>
> + buf.write("\3\2\2\2\u0469\u0471\3\2\2\2\u046a\u046e\7!\2\2\u046b")
>
> +
> buf.write("\u046d\5t;\2\u046c\u046b\3\2\2\2\u046d\u0470\3\2\2\2\u046e")
>
> + buf.write("\u046c\3\2\2\2\u046e\u046f\3\2\2\2\u046f\u0472\3\2\2\2")
>
> +
> buf.write("\u0470\u046e\3\2\2\2\u0471\u046a\3\2\2\2\u0471\u0472\3")
>
> +
> buf.write("\2\2\2\u0472\u0473\3\2\2\2\u0473\u0474\7<\2\2\u0474\u0476")
>
> + buf.write("\7 \2\2\u0475\u0463\3\2\2\2\u0475\u0468\3\2\2\2\u0476")
>
> +
> buf.write("s\3\2\2\2\u0477\u047a\5p9\2\u0478\u047a\5\u0088E\2\u0479")
>
> +
> buf.write("\u0477\3\2\2\2\u0479\u0478\3\2\2\2\u047au\3\2\2\2\u047b")
>
> +
> buf.write("\u0480\5x=\2\u047c\u047d\7(\2\2\u047d\u047f\5x=\2\u047e")
>
> +
> buf.write("\u047c\3\2\2\2\u047f\u0482\3\2\2\2\u0480\u047e\3\2\2\2")
>
> +
> buf.write("\u0480\u0481\3\2\2\2\u0481w\3\2\2\2\u0482\u0480\3\2\2")
>
> +
> buf.write("\2\u0483\u0484\t\5\2\2\u0484y\3\2\2\2\u0485\u0486\7>\2")
>
> +
> buf.write("\2\u0486\u0487\7=\2\2\u0487\u0488\7\b\2\2\u0488\u0489")
>
> + buf.write("\7\u00ec\2\2\u0489\u048a\7\30\2\2\u048a\u048b\7\u00fa")
>
> +
> buf.write("\2\2\u048b\u048c\7\31\2\2\u048c\u048d\7!\2\2\u048d\u048e")
>
> +
> buf.write("\7>\2\2\u048e\u048f\7\b\2\2\u048f\u0490\7\u00ec\2\2\u0490")
>
> +
> buf.write("\u0491\7\30\2\2\u0491\u0492\7\u00fa\2\2\u0492\u049a\7")
>
> +
> buf.write("\31\2\2\u0493\u0494\7!\2\2\u0494\u0495\7>\2\2\u0495\u0496")
>
> + buf.write("\7\b\2\2\u0496\u0497\7\u00ec\2\2\u0497\u0498\7\30\2\2")
>
> +
> buf.write("\u0498\u0499\7\u00fa\2\2\u0499\u049b\7\31\2\2\u049a\u0493")
>
> +
> buf.write("\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u04ac\3\2\2\2\u049c")
>
> +
> buf.write("\u049d\7!\2\2\u049d\u049e\7@\2\2\u049e\u049f\7\b\2\2\u049f"
> )
>
> +
> buf.write("\u04a4\5|?\2\u04a0\u04a1\7(\2\2\u04a1\u04a3\5|?\2\u04a2")
>
> +
> buf.write("\u04a0\3\2\2\2\u04a3\u04a6\3\2\2\2\u04a4\u04a2\3\2\2\2")
>
> +
> buf.write("\u04a4\u04a5\3\2\2\2\u04a5\u04a7\3\2\2\2\u04a6\u04a4\3")
>
> +
> buf.write("\2\2\2\u04a7\u04a8\7!\2\2\u04a8\u04a9\7t\2\2\u04a9\u04aa")
>
> +
> buf.write("\7\b\2\2\u04aa\u04ab\7\u00fa\2\2\u04ab\u04ad\3\2\2\2\u04ac")
>
> +
> buf.write("\u049c\3\2\2\2\u04ac\u04ad\3\2\2\2\u04ad\u04b0\3\2\2\2")
>
> + buf.write("\u04ae\u04af\7!\2\2\u04af\u04b1\5b\62\2\u04b0\u04ae\3")
>
> +
> buf.write("\2\2\2\u04b0\u04b1\3\2\2\2\u04b1\u04b2\3\2\2\2\u04b2\u04b3"
> )
>
> + buf.write("\7
> \2\2\u04b3{\3\2\2\2\u04b4\u04b7\7\u00fa\2\2\u04b5\u04b7")
>
> + buf.write("\5V,\2\u04b6\u04b4\3\2\2\2\u04b6\u04b5\3\2\2\2\u04b7}")
>
> +
> buf.write("\3\2\2\2\u04b8\u04bb\5\u0080A\2\u04b9\u04bb\5\u0086D\2")
>
> +
> buf.write("\u04ba\u04b8\3\2\2\2\u04ba\u04b9\3\2\2\2\u04bb\177\3\2")
>
> +
> buf.write("\2\2\u04bc\u04ec\7n\2\2\u04bd\u04be\7*\2\2\u04be\u04bf")
>
> + buf.write("\7\b\2\2\u04bf\u04c0\7\u00ec\2\2\u04c0\u04c1\7\30\2\2")
>
> +
> buf.write("\u04c1\u04c2\7\u00fa\2\2\u04c2\u04c3\7\31\2\2\u04c3\u04c4")
>
> +
> buf.write("\7!\2\2\u04c4\u04c5\7o\2\2\u04c5\u04c6\7\b\2\2\u04c6\u04c7")
>
> +
> buf.write("\5L\'\2\u04c7\u04c8\7!\2\2\u04c8\u04c9\7/\2\2\u04c9\u04ca")
>
> +
> buf.write("\7\b\2\2\u04ca\u04cb\7\u00fa\2\2\u04cb\u04cc\7!\2\2\u04cc")
>
> +
> buf.write("\u04cd\7\u0090\2\2\u04cd\u04ce\7\b\2\2\u04ce\u04cf\7\u00fa")
>
> +
> buf.write("\2\2\u04cf\u04d0\7!\2\2\u04d0\u04ed\3\2\2\2\u04d1\u04d2")
>
> +
> buf.write("\7o\2\2\u04d2\u04d3\7\b\2\2\u04d3\u04d4\5L\'\2\u04d4\u04d5"
> )
>
> +
> buf.write("\7!\2\2\u04d5\u04d6\7/\2\2\u04d6\u04d7\7\b\2\2\u04d7\u04d8"
> )
>
> +
> buf.write("\7\u00fa\2\2\u04d8\u04d9\7!\2\2\u04d9\u04da\7\u0090\2")
>
> +
> buf.write("\2\u04da\u04db\7\b\2\2\u04db\u04dc\7\u00fa\2\2\u04dc\u04dd
> ")
>
> +
> buf.write("\7!\2\2\u04dd\u04ed\3\2\2\2\u04de\u04df\7/\2\2\u04df\u04e0")
>
> +
> buf.write("\7\b\2\2\u04e0\u04e1\7\u00fa\2\2\u04e1\u04e2\7!\2\2\u04e2")
>
> +
> buf.write("\u04e3\7\u0090\2\2\u04e3\u04e8\7\b\2\2\u04e4\u04e5\7\u00fb"
> )
>
> + buf.write("\2\2\u04e5\u04e9\7!\2\2\u04e6\u04e7\7\u00fa\2\2\u04e7")
>
> + buf.write("\u04e9\7!\2\2\u04e8\u04e4\3\2\2\2\u04e8\u04e6\3\2\2\2")
>
> +
> buf.write("\u04e9\u04ed\3\2\2\2\u04ea\u04eb\7\u00fa\2\2\u04eb\u04ed")
>
> + buf.write("\7!\2\2\u04ec\u04bd\3\2\2\2\u04ec\u04d1\3\2\2\2\u04ec")
>
> +
> buf.write("\u04de\3\2\2\2\u04ec\u04ea\3\2\2\2\u04ec\u04ed\3\2\2\2")
>
> + buf.write("\u04ed\u04ee\3\2\2\2\u04ee\u04f3\5P)\2\u04ef\u04f0\7!")
>
> +
> buf.write("\2\2\u04f0\u04f1\7@\2\2\u04f1\u04f2\7\b\2\2\u04f2\u04f4")
>
> +
> buf.write("\5\u0082B\2\u04f3\u04ef\3\2\2\2\u04f3\u04f4\3\2\2\2\u04f4")
>
> +
> buf.write("\u04f9\3\2\2\2\u04f5\u04f6\7!\2\2\u04f6\u04f7\7t\2\2\u04f7")
>
> + buf.write("\u04f8\7\b\2\2\u04f8\u04fa\7\u00fa\2\2\u04f9\u04f5\3\2")
>
> +
> buf.write("\2\2\u04f9\u04fa\3\2\2\2\u04fa\u04fd\3\2\2\2\u04fb\u04fc")
>
> +
> buf.write("\7!\2\2\u04fc\u04fe\5\u00b4[\2\u04fd\u04fb\3\2\2\2\u04fd")
>
> + buf.write("\u04fe\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u0500\7 \2\2")
>
> +
> buf.write("\u0500\u0081\3\2\2\2\u0501\u0506\5\u0084C\2\u0502\u0503")
>
> +
> buf.write("\7(\2\2\u0503\u0505\5\u0084C\2\u0504\u0502\3\2\2\2\u0505")
>
> +
> buf.write("\u0508\3\2\2\2\u0506\u0504\3\2\2\2\u0506\u0507\3\2\2\2")
>
> +
> buf.write("\u0507\u0083\3\2\2\2\u0508\u0506\3\2\2\2\u0509\u050c\7")
>
> +
> buf.write("\u00fa\2\2\u050a\u050c\5V,\2\u050b\u0509\3\2\2\2\u050b")
>
> +
> buf.write("\u050a\3\2\2\2\u050c\u0085\3\2\2\2\u050d\u050e\7\u0099")
>
> +
> buf.write("\2\2\u050e\u050f\7\u009b\2\2\u050f\u0510\7\b\2\2\u0510")
>
> +
> buf.write("\u0511\7\u00fb\2\2\u0511\u0512\7!\2\2\u0512\u0513\5T+")
>
> +
> buf.write("\2\u0513\u0517\7!\2\2\u0514\u0515\5b\62\2\u0515\u0516")
>
> + buf.write("\7!\2\2\u0516\u0518\3\2\2\2\u0517\u0514\3\2\2\2\u0517")
>
> +
> buf.write("\u0518\3\2\2\2\u0518\u0519\3\2\2\2\u0519\u051a\7\u009a")
>
> + buf.write("\2\2\u051a\u051b\7
> \2\2\u051b\u0087\3\2\2\2\u051c\u0523")
>
> +
> buf.write("\5\u00b8]\2\u051d\u0523\5\u00e8u\2\u051e\u0523\5\u00c6")
>
> +
> buf.write("d\2\u051f\u0523\5\u00d4k\2\u0520\u0523\5\u00e2r\2\u0521")
>
> + buf.write("\u0523\5\u00f0y\2\u0522\u051c\3\2\2\2\u0522\u051d\3\2")
>
> +
> buf.write("\2\2\u0522\u051e\3\2\2\2\u0522\u051f\3\2\2\2\u0522\u0520")
>
> +
> buf.write("\3\2\2\2\u0522\u0521\3\2\2\2\u0523\u0089\3\2\2\2\u0524")
>
> + buf.write("\u0525\5`\61\2\u0525\u0526\7!\2\2\u0526\u0530\3\2\2\2")
>
> +
> buf.write("\u0527\u0530\5\u008cG\2\u0528\u0530\5\u008eH\2\u0529\u053
> 0")
>
> +
> buf.write("\5\u0090I\2\u052a\u0530\5\u0092J\2\u052b\u0530\5\u0094")
>
> +
> buf.write("K\2\u052c\u0530\5\u011c\u008f\2\u052d\u0530\5\u0096L\2")
>
> +
> buf.write("\u052e\u0530\5\u0098M\2\u052f\u0524\3\2\2\2\u052f\u0527")
>
> + buf.write("\3\2\2\2\u052f\u0528\3\2\2\2\u052f\u0529\3\2\2\2\u052f")
>
> + buf.write("\u052a\3\2\2\2\u052f\u052b\3\2\2\2\u052f\u052c\3\2\2\2")
>
> +
> buf.write("\u052f\u052d\3\2\2\2\u052f\u052e\3\2\2\2\u0530\u008b\3")
>
> +
> buf.write("\2\2\2\u0531\u0532\7p\2\2\u0532\u0533\7\62\2\2\u0533\u0534"
> )
>
> + buf.write("\7\b\2\2\u0534\u0535\7\u00ec\2\2\u0535\u0536\7\30\2\2")
>
> +
> buf.write("\u0536\u0537\7\u00fa\2\2\u0537\u0538\7\31\2\2\u0538\u0545")
>
> +
> buf.write("\7!\2\2\u0539\u053a\7@\2\2\u053a\u053b\7\b\2\2\u053b\u0540
> ")
>
> +
> buf.write("\5\u009eP\2\u053c\u053d\7(\2\2\u053d\u053f\5\u009eP\2")
>
> +
> buf.write("\u053e\u053c\3\2\2\2\u053f\u0542\3\2\2\2\u0540\u053e\3")
>
> +
> buf.write("\2\2\2\u0540\u0541\3\2\2\2\u0541\u0543\3\2\2\2\u0542\u0540"
> )
>
> + buf.write("\3\2\2\2\u0543\u0544\7!\2\2\u0544\u0546\3\2\2\2\u0545")
>
> +
> buf.write("\u0539\3\2\2\2\u0545\u0546\3\2\2\2\u0546\u0547\3\2\2\2")
>
> +
> buf.write("\u0547\u0548\5\u0124\u0093\2\u0548\u054a\7s\2\2\u0549")
>
> + buf.write("\u054b\7 \2\2\u054a\u0549\3\2\2\2\u054a\u054b\3\2\2\2")
>
> +
> buf.write("\u054b\u008d\3\2\2\2\u054c\u054d\7r\2\2\u054d\u054e\7")
>
> +
> buf.write("\62\2\2\u054e\u054f\7\b\2\2\u054f\u0550\7\u00ec\2\2\u0550")
>
> +
> buf.write("\u0551\7\30\2\2\u0551\u0552\7\u00fa\2\2\u0552\u0553\7")
>
> +
> buf.write("\31\2\2\u0553\u0560\7!\2\2\u0554\u0555\7@\2\2\u0555\u0556"
> )
>
> +
> buf.write("\7\b\2\2\u0556\u055b\5\u009eP\2\u0557\u0558\7(\2\2\u0558")
>
> +
> buf.write("\u055a\5\u009eP\2\u0559\u0557\3\2\2\2\u055a\u055d\3\2")
>
> +
> buf.write("\2\2\u055b\u0559\3\2\2\2\u055b\u055c\3\2\2\2\u055c\u055e")
>
> + buf.write("\3\2\2\2\u055d\u055b\3\2\2\2\u055e\u055f\7!\2\2\u055f")
>
> +
> buf.write("\u0561\3\2\2\2\u0560\u0554\3\2\2\2\u0560\u0561\3\2\2\2")
>
> +
> buf.write("\u0561\u0562\3\2\2\2\u0562\u0563\5\u0124\u0093\2\u0563")
>
> + buf.write("\u0565\7s\2\2\u0564\u0566\7
> \2\2\u0565\u0564\3\2\2\2\u0565")
>
> + buf.write("\u0566\3\2\2\2\u0566\u008f\3\2\2\2\u0567\u0568\7l\2\2")
>
> + buf.write("\u0568\u0569\5\u0124\u0093\2\u0569\u056a\7
> \2\2\u056a")
>
> + buf.write("\u056b\5\u00b4[\2\u056b\u056d\7s\2\2\u056c\u056e\7 \2")
>
> +
> buf.write("\2\u056d\u056c\3\2\2\2\u056d\u056e\3\2\2\2\u056e\u0091")
>
> +
> buf.write("\3\2\2\2\u056f\u0570\7\u00a4\2\2\u0570\u0571\7\u00a5\2")
>
> +
> buf.write("\2\u0571\u0572\7\b\2\2\u0572\u0573\7\u00fa\2\2\u0573\u0093"
> )
>
> +
> buf.write("\3\2\2\2\u0574\u0575\7\u00a6\2\2\u0575\u0576\7\b\2\2\u0576"
> )
>
> +
> buf.write("\u0577\7\u00ec\2\2\u0577\u0578\7\30\2\2\u0578\u0579\7")
>
> +
> buf.write("\u00fa\2\2\u0579\u057a\7\31\2\2\u057a\u057b\7!\2\2\u057b")
>
> +
> buf.write("\u0095\3\2\2\2\u057c\u057d\7\u00eb\2\2\u057d\u057e\7\b")
>
> + buf.write("\2\2\u057e\u057f\5L\'\2\u057f\u0580\7!\2\2\u0580\u0097")
>
> +
> buf.write("\3\2\2\2\u0581\u0582\7q\2\2\u0582\u0583\7\62\2\2\u0583")
>
> +
> buf.write("\u0584\7\b\2\2\u0584\u0585\7\u00ec\2\2\u0585\u0586\7\30")
>
> +
> buf.write("\2\2\u0586\u0587\7\u00fa\2\2\u0587\u0588\7\31\2\2\u0588")
>
> +
> buf.write("\u058d\7!\2\2\u0589\u058a\7M\2\2\u058a\u058b\7\b\2\2\u058b
> ")
>
> + buf.write("\u058c\7\u00fa\2\2\u058c\u058e\7!\2\2\u058d\u0589\3\2")
>
> +
> buf.write("\2\2\u058d\u058e\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0590")
>
> + buf.write("\5\u0124\u0093\2\u0590\u0592\7s\2\2\u0591\u0593\7
> \2\2")
>
> +
> buf.write("\u0592\u0591\3\2\2\2\u0592\u0593\3\2\2\2\u0593\u0099\3")
>
> +
> buf.write("\2\2\2\u0594\u0596\5\u008aF\2\u0595\u0594\3\2\2\2\u0596")
>
> +
> buf.write("\u0599\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0598\3\2\2\2")
>
> +
> buf.write("\u0598\u009b\3\2\2\2\u0599\u0597\3\2\2\2\u059a\u05a2\5")
>
> +
> buf.write("\u00a0Q\2\u059b\u05a2\5\u00a2R\2\u059c\u05a2\5\u00a6T")
>
> +
> buf.write("\2\u059d\u05a2\5\u00a4S\2\u059e\u05a2\5\u00a8U\2\u059f")
>
> +
> buf.write("\u05a2\5\u00b0Y\2\u05a0\u05a2\5\u00b2Z\2\u05a1\u059a\3")
>
> +
> buf.write("\2\2\2\u05a1\u059b\3\2\2\2\u05a1\u059c\3\2\2\2\u05a1\u059d"
> )
>
> +
> buf.write("\3\2\2\2\u05a1\u059e\3\2\2\2\u05a1\u059f\3\2\2\2\u05a1")
>
> +
> buf.write("\u05a0\3\2\2\2\u05a2\u009d\3\2\2\2\u05a3\u05ac\7\u00fa")
>
> +
> buf.write("\2\2\u05a4\u05ac\7y\2\2\u05a5\u05ac\7v\2\2\u05a6\u05ac")
>
> +
> buf.write("\7u\2\2\u05a7\u05ac\7{\2\2\u05a8\u05ac\7|\2\2\u05a9\u05ac")
>
> +
> buf.write("\7z\2\2\u05aa\u05ac\7}\2\2\u05ab\u05a3\3\2\2\2\u05ab\u05a4")
>
> +
> buf.write("\3\2\2\2\u05ab\u05a5\3\2\2\2\u05ab\u05a6\3\2\2\2\u05ab")
>
> +
> buf.write("\u05a7\3\2\2\2\u05ab\u05a8\3\2\2\2\u05ab\u05a9\3\2\2\2")
>
> +
> buf.write("\u05ab\u05aa\3\2\2\2\u05ac\u009f\3\2\2\2\u05ad\u05ae\7")
>
> + buf.write("k\2\2\u05ae\u05af\5\u0124\u0093\2\u05af\u05bc\7
> \2\2\u05b0")
>
> +
> buf.write("\u05b1\7@\2\2\u05b1\u05b2\7\b\2\2\u05b2\u05b7\5\u009e")
>
> +
> buf.write("P\2\u05b3\u05b4\7(\2\2\u05b4\u05b6\5\u009eP\2\u05b5\u05b3"
> )
>
> +
> buf.write("\3\2\2\2\u05b6\u05b9\3\2\2\2\u05b7\u05b5\3\2\2\2\u05b7")
>
> +
> buf.write("\u05b8\3\2\2\2\u05b8\u05ba\3\2\2\2\u05b9\u05b7\3\2\2\2")
>
> +
> buf.write("\u05ba\u05bb\7!\2\2\u05bb\u05bd\3\2\2\2\u05bc\u05b0\3")
>
> +
> buf.write("\2\2\2\u05bc\u05bd\3\2\2\2\u05bd\u05be\3\2\2\2\u05be\u05bf"
> )
>
> + buf.write("\5\u00b4[\2\u05bf\u05c1\7s\2\2\u05c0\u05c2\7
> \2\2\u05c1")
>
> + buf.write("\u05c0\3\2\2\2\u05c1\u05c2\3\2\2\2\u05c2\u00a1\3\2\2\2")
>
> +
> buf.write("\u05c3\u05c4\7K\2\2\u05c4\u05c5\5\u0124\u0093\2\u05c5")
>
> + buf.write("\u05d2\7
> \2\2\u05c6\u05c7\7@\2\2\u05c7\u05c8\7\b\2\2\u05c8")
>
> +
> buf.write("\u05cd\5\u009eP\2\u05c9\u05ca\7(\2\2\u05ca\u05cc\5\u009e")
>
> +
> buf.write("P\2\u05cb\u05c9\3\2\2\2\u05cc\u05cf\3\2\2\2\u05cd\u05cb")
>
> + buf.write("\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf")
>
> + buf.write("\u05cd\3\2\2\2\u05d0\u05d1\7!\2\2\u05d1\u05d3\3\2\2\2")
>
> +
> buf.write("\u05d2\u05c6\3\2\2\2\u05d2\u05d3\3\2\2\2\u05d3\u05d4\3")
>
> +
> buf.write("\2\2\2\u05d4\u05d5\5\u00b4[\2\u05d5\u05d7\7s\2\2\u05d6")
>
> + buf.write("\u05d8\7 \2\2\u05d7\u05d6\3\2\2\2\u05d7\u05d8\3\2\2\2")
>
> +
> buf.write("\u05d8\u00a3\3\2\2\2\u05d9\u05e1\7c\2\2\u05da\u05db\5")
>
> +
> buf.write("\u00a6T\2\u05db\u05dc\7!\2\2\u05dc\u05e2\3\2\2\2\u05dd")
>
> +
> buf.write("\u05de\7\b\2\2\u05de\u05df\5Z.\2\u05df\u05e0\7!\2\2\u05e0")
>
> +
> buf.write("\u05e2\3\2\2\2\u05e1\u05da\3\2\2\2\u05e1\u05dd\3\2\2\2")
>
> +
> buf.write("\u05e2\u05e7\3\2\2\2\u05e3\u05e4\7\u009b\2\2\u05e4\u05e5")
>
> +
> buf.write("\7\b\2\2\u05e5\u05e6\7\u00fb\2\2\u05e6\u05e8\7!\2\2\u05e7")
>
> +
> buf.write("\u05e3\3\2\2\2\u05e7\u05e8\3\2\2\2\u05e8\u00a5\3\2\2\2")
>
> +
> buf.write("\u05e9\u05ea\7\u0096\2\2\u05ea\u05eb\7\b\2\2\u05eb\u05ec")
>
> +
> buf.write("\5\u0124\u0093\2\u05ec\u00a7\3\2\2\2\u05ed\u05ee\5\u00aa")
>
> +
> buf.write("V\2\u05ee\u00a9\3\2\2\2\u05ef\u05f0\7?\2\2\u05f0\u05f1")
>
> +
> buf.write("\7>\2\2\u05f1\u05f2\7\b\2\2\u05f2\u05f3\7\u00ec\2\2\u05f3")
>
> + buf.write("\u05f4\7\30\2\2\u05f4\u05f5\7\u00fa\2\2\u05f5\u05f6\7")
>
> +
> buf.write("\31\2\2\u05f6\u05f7\7!\2\2\u05f7\u05f8\7\u0096\2\2\u05f8")
>
> +
> buf.write("\u05f9\7\b\2\2\u05f9\u05fa\5Z.\2\u05fa\u05fb\7!\2\2\u05fb")
>
> + buf.write("\u05fc\7@\2\2\u05fc\u05fd\7\b\2\2\u05fd\u0602\5\u00ac")
>
> + buf.write("W\2\u05fe\u05ff\7!\2\2\u05ff\u0600\7t\2\2\u0600\u0601")
>
> +
> buf.write("\7\b\2\2\u0601\u0603\7\u00fa\2\2\u0602\u05fe\3\2\2\2\u0602")
>
> + buf.write("\u0603\3\2\2\2\u0603\u0608\3\2\2\2\u0604\u0605\7!\2\2")
>
> + buf.write("\u0605\u0607\5\\/\2\u0606\u0604\3\2\2\2\u0607\u060a\3")
>
> +
> buf.write("\2\2\2\u0608\u0606\3\2\2\2\u0608\u0609\3\2\2\2\u0609\u060b"
> )
>
> + buf.write("\3\2\2\2\u060a\u0608\3\2\2\2\u060b\u060c\7 \2\2\u060c")
>
> +
> buf.write("\u00ab\3\2\2\2\u060d\u0612\5\u00aeX\2\u060e\u060f\7(\2")
>
> +
> buf.write("\2\u060f\u0611\5\u00aeX\2\u0610\u060e\3\2\2\2\u0611\u0614")
>
> +
> buf.write("\3\2\2\2\u0612\u0610\3\2\2\2\u0612\u0613\3\2\2\2\u0613")
>
> +
> buf.write("\u00ad\3\2\2\2\u0614\u0612\3\2\2\2\u0615\u0621\7\u00fa")
>
> +
> buf.write("\2\2\u0616\u0621\7\u00ed\2\2\u0617\u0621\7\u00ee\2\2\u0618
> ")
>
> +
> buf.write("\u0621\7y\2\2\u0619\u0621\7{\2\2\u061a\u0621\7\u0080\2")
>
> +
> buf.write("\2\u061b\u0621\7|\2\2\u061c\u0621\7v\2\2\u061d\u0621\7")
>
> +
> buf.write("u\2\2\u061e\u0621\7z\2\2\u061f\u0621\7}\2\2\u0620\u0615")
>
> +
> buf.write("\3\2\2\2\u0620\u0616\3\2\2\2\u0620\u0617\3\2\2\2\u0620")
>
> +
> buf.write("\u0618\3\2\2\2\u0620\u0619\3\2\2\2\u0620\u061a\3\2\2\2")
>
> +
> buf.write("\u0620\u061b\3\2\2\2\u0620\u061c\3\2\2\2\u0620\u061d\3")
>
> +
> buf.write("\2\2\2\u0620\u061e\3\2\2\2\u0620\u061f\3\2\2\2\u0621\u00af")
>
> +
> buf.write("\3\2\2\2\u0622\u0623\7\u0097\2\2\u0623\u0624\5\u0124\u0093
> ")
>
> + buf.write("\2\u0624\u0625\7
> \2\2\u0625\u00b1\3\2\2\2\u0626\u0627")
>
> +
> buf.write("\7\u0098\2\2\u0627\u0628\5\u0124\u0093\2\u0628\u0629\7")
>
> + buf.write("
> \2\2\u0629\u00b3\3\2\2\2\u062a\u062c\5\u00b6\\\2\u062b")
>
> +
> buf.write("\u062a\3\2\2\2\u062c\u062f\3\2\2\2\u062d\u062b\3\2\2\2")
>
> +
> buf.write("\u062d\u062e\3\2\2\2\u062e\u00b5\3\2\2\2\u062f\u062d\3")
>
> +
> buf.write("\2\2\2\u0630\u0633\5\u008aF\2\u0631\u0633\5\u009cO\2\u0632
> ")
>
> +
> buf.write("\u0630\3\2\2\2\u0632\u0631\3\2\2\2\u0633\u00b7\3\2\2\2")
>
> +
> buf.write("\u0634\u0637\5\u00ba^\2\u0635\u0637\5\u00c0a\2\u0636\u063
> 4")
>
> +
> buf.write("\3\2\2\2\u0636\u0635\3\2\2\2\u0637\u00b9\3\2\2\2\u0638")
>
> +
> buf.write("\u0639\7\\\2\2\u0639\u063a\5R*\2\u063a\u063b\5T+\2\u063b")
>
> +
> buf.write("\u0641\7!\2\2\u063c\u063d\7@\2\2\u063d\u063e\7\b\2\2\u063e
> ")
>
> +
> buf.write("\u063f\5\u00bc_\2\u063f\u0640\7!\2\2\u0640\u0642\3\2\2")
>
> +
> buf.write("\2\u0641\u063c\3\2\2\2\u0641\u0642\3\2\2\2\u0642\u0647")
>
> + buf.write("\3\2\2\2\u0643\u0644\7t\2\2\u0644\u0645\7\b\2\2\u0645")
>
> + buf.write("\u0646\7\u00fa\2\2\u0646\u0648\7!\2\2\u0647\u0643\3\2")
>
> +
> buf.write("\2\2\u0647\u0648\3\2\2\2\u0648\u0649\3\2\2\2\u0649\u064a")
>
> + buf.write("\5\u00b4[\2\u064a\u064b\7]\2\2\u064b\u064c\7
> \2\2\u064c")
>
> +
> buf.write("\u00bb\3\2\2\2\u064d\u0652\5\u00be`\2\u064e\u064f\7(\2")
>
> +
> buf.write("\2\u064f\u0651\5\u00be`\2\u0650\u064e\3\2\2\2\u0651\u0654")
>
> +
> buf.write("\3\2\2\2\u0652\u0650\3\2\2\2\u0652\u0653\3\2\2\2\u0653")
>
> +
> buf.write("\u00bd\3\2\2\2\u0654\u0652\3\2\2\2\u0655\u065c\7\u00fa")
>
> +
> buf.write("\2\2\u0656\u065c\7u\2\2\u0657\u065c\7v\2\2\u0658\u065c")
>
> +
> buf.write("\7w\2\2\u0659\u065c\7x\2\2\u065a\u065c\5V,\2\u065b\u0655")
>
> +
> buf.write("\3\2\2\2\u065b\u0656\3\2\2\2\u065b\u0657\3\2\2\2\u065b")
>
> +
> buf.write("\u0658\3\2\2\2\u065b\u0659\3\2\2\2\u065b\u065a\3\2\2\2")
>
> +
> buf.write("\u065c\u00bf\3\2\2\2\u065d\u065e\7\u00a1\2\2\u065e\u065f")
>
> +
> buf.write("\5P)\2\u065f\u0665\7!\2\2\u0660\u0661\7@\2\2\u0661\u0662")
>
> +
> buf.write("\7\b\2\2\u0662\u0663\5\u00c2b\2\u0663\u0664\7!\2\2\u0664")
>
> +
> buf.write("\u0666\3\2\2\2\u0665\u0660\3\2\2\2\u0665\u0666\3\2\2\2")
>
> +
> buf.write("\u0666\u0667\3\2\2\2\u0667\u0668\7\u00a2\2\2\u0668\u0669")
>
> + buf.write("\7\b\2\2\u0669\u066a\7\u00ec\2\2\u066a\u066b\7\30\2\2")
>
> +
> buf.write("\u066b\u066c\7\u00fa\2\2\u066c\u066d\7\31\2\2\u066d\u066e")
>
> +
> buf.write("\7!\2\2\u066e\u066f\5\u009aN\2\u066f\u0670\7\u00a3\2\2")
>
> + buf.write("\u0670\u0671\7 \2\2\u0671\u00c1\3\2\2\2\u0672\u0677\5")
>
> +
> buf.write("\u00c4c\2\u0673\u0674\7(\2\2\u0674\u0676\5\u00c4c\2\u0675")
>
> +
> buf.write("\u0673\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2")
>
> +
> buf.write("\u0677\u0678\3\2\2\2\u0678\u00c3\3\2\2\2\u0679\u0677\3")
>
> +
> buf.write("\2\2\2\u067a\u067d\7\u00fa\2\2\u067b\u067d\5V,\2\u067c")
>
> +
> buf.write("\u067a\3\2\2\2\u067c\u067b\3\2\2\2\u067d\u00c5\3\2\2\2")
>
> +
> buf.write("\u067e\u0681\5\u00c8e\2\u067f\u0681\5\u00d0i\2\u0680\u067e"
> )
>
> +
> buf.write("\3\2\2\2\u0680\u067f\3\2\2\2\u0681\u00c7\3\2\2\2\u0682")
>
> +
> buf.write("\u0683\7^\2\2\u0683\u0684\5R*\2\u0684\u0685\5T+\2\u0685")
>
> +
> buf.write("\u068b\7!\2\2\u0686\u0687\7@\2\2\u0687\u0688\7\b\2\2\u0688
> ")
>
> +
> buf.write("\u0689\5\u00ccg\2\u0689\u068a\7!\2\2\u068a\u068c\3\2\2")
>
> +
> buf.write("\2\u068b\u0686\3\2\2\2\u068b\u068c\3\2\2\2\u068c\u0691")
>
> + buf.write("\3\2\2\2\u068d\u068e\7t\2\2\u068e\u068f\7\b\2\2\u068f")
>
> + buf.write("\u0690\7\u00fa\2\2\u0690\u0692\7!\2\2\u0691\u068d\3\2")
>
> +
> buf.write("\2\2\u0691\u0692\3\2\2\2\u0692\u0693\3\2\2\2\u0693\u0694")
>
> + buf.write("\5\u00caf\2\u0694\u0695\5\u00b4[\2\u0695\u0696\7_\2\2")
>
> + buf.write("\u0696\u0697\7 \2\2\u0697\u00c9\3\2\2\2\u0698\u0699\7")
>
> +
> buf.write("`\2\2\u0699\u069b\7\b\2\2\u069a\u069c\7\35\2\2\u069b\u069a")
>
> +
> buf.write("\3\2\2\2\u069b\u069c\3\2\2\2\u069c\u069d\3\2\2\2\u069d")
>
> + buf.write("\u069e\7\u00fa\2\2\u069e\u069f\7!\2\2\u069f\u06a0\7a\2")
>
> +
> buf.write("\2\u06a0\u06a2\7\b\2\2\u06a1\u06a3\7\35\2\2\u06a2\u06a1")
>
> +
> buf.write("\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06a4\3\2\2\2\u06a4")
>
> +
> buf.write("\u06a5\7\u00fa\2\2\u06a5\u06aa\7!\2\2\u06a6\u06a7\7b\2")
>
> +
> buf.write("\2\u06a7\u06a8\7\b\2\2\u06a8\u06a9\7\u00fa\2\2\u06a9\u06ab"
> )
>
> + buf.write("\7!\2\2\u06aa\u06a6\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab")
>
> +
> buf.write("\u00cb\3\2\2\2\u06ac\u06b1\5\u00ceh\2\u06ad\u06ae\7(\2")
>
> +
> buf.write("\2\u06ae\u06b0\5\u00ceh\2\u06af\u06ad\3\2\2\2\u06b0\u06b3")
>
> +
> buf.write("\3\2\2\2\u06b1\u06af\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2")
>
> +
> buf.write("\u00cd\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b4\u06be\7\u00fa")
>
> +
> buf.write("\2\2\u06b5\u06be\7\u00ef\2\2\u06b6\u06be\7\u00f0\2\2\u06b7"
> )
>
> +
> buf.write("\u06be\7\u00f1\2\2\u06b8\u06be\7\u00f2\2\2\u06b9\u06be")
>
> +
> buf.write("\7\u00f3\2\2\u06ba\u06be\7\u00f4\2\2\u06bb\u06be\7\u00f5")
>
> +
> buf.write("\2\2\u06bc\u06be\5V,\2\u06bd\u06b4\3\2\2\2\u06bd\u06b5")
>
> +
> buf.write("\3\2\2\2\u06bd\u06b6\3\2\2\2\u06bd\u06b7\3\2\2\2\u06bd")
>
> +
> buf.write("\u06b8\3\2\2\2\u06bd\u06b9\3\2\2\2\u06bd\u06ba\3\2\2\2")
>
> +
> buf.write("\u06bd\u06bb\3\2\2\2\u06bd\u06bc\3\2\2\2\u06be\u00cf\3")
>
> +
> buf.write("\2\2\2\u06bf\u06c0\7\60\2\2\u06c0\u06c1\5R*\2\u06c1\u06c2")
>
> +
> buf.write("\5T+\2\u06c2\u06c8\7!\2\2\u06c3\u06c4\7@\2\2\u06c4\u06c5")
>
> +
> buf.write("\7\b\2\2\u06c5\u06c6\5\u00d2j\2\u06c6\u06c7\7!\2\2\u06c7")
>
> + buf.write("\u06c9\3\2\2\2\u06c8\u06c3\3\2\2\2\u06c8\u06c9\3\2\2\2")
>
> +
> buf.write("\u06c9\u06cb\3\2\2\2\u06ca\u06cc\5\u00caf\2\u06cb\u06ca")
>
> + buf.write("\3\2\2\2\u06cb\u06cc\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd")
>
> + buf.write("\u06ce\5\u00b4[\2\u06ce\u06cf\7\61\2\2\u06cf\u06d0\7 ")
>
> +
> buf.write("\2\2\u06d0\u00d1\3\2\2\2\u06d1\u06d6\5\u00ceh\2\u06d2")
>
> +
> buf.write("\u06d3\7(\2\2\u06d3\u06d5\5\u00ceh\2\u06d4\u06d2\3\2\2")
>
> +
> buf.write("\2\u06d5\u06d8\3\2\2\2\u06d6\u06d4\3\2\2\2\u06d6\u06d7")
>
> +
> buf.write("\3\2\2\2\u06d7\u00d3\3\2\2\2\u06d8\u06d6\3\2\2\2\u06d9")
>
> +
> buf.write("\u06dc\5\u00d6l\2\u06da\u06dc\5\u00dco\2\u06db\u06d9\3")
>
> +
> buf.write("\2\2\2\u06db\u06da\3\2\2\2\u06dc\u00d5\3\2\2\2\u06dd\u06de"
> )
>
> +
> buf.write("\7f\2\2\u06de\u06df\5P)\2\u06df\u06e5\7!\2\2\u06e0\u06e1")
>
> +
> buf.write("\7@\2\2\u06e1\u06e2\7\b\2\2\u06e2\u06e3\5\u00d8m\2\u06e3"
> )
>
> + buf.write("\u06e4\7!\2\2\u06e4\u06e6\3\2\2\2\u06e5\u06e0\3\2\2\2")
>
> +
> buf.write("\u06e5\u06e6\3\2\2\2\u06e6\u06eb\3\2\2\2\u06e7\u06e8\7")
>
> +
> buf.write("t\2\2\u06e8\u06e9\7\b\2\2\u06e9\u06ea\7\u00fa\2\2\u06ea")
>
> + buf.write("\u06ec\7!\2\2\u06eb\u06e7\3\2\2\2\u06eb\u06ec\3\2\2\2")
>
> +
> buf.write("\u06ec\u06ed\3\2\2\2\u06ed\u06ee\7h\2\2\u06ee\u06ef\7")
>
> + buf.write("\b\2\2\u06ef\u06f0\7\u00fa\2\2\u06f0\u06f1\7!\2\2\u06f1")
>
> + buf.write("\u06f2\7i\2\2\u06f2\u06f3\7\b\2\2\u06f3\u06f4\7\u00fa")
>
> +
> buf.write("\2\2\u06f4\u06f5\7!\2\2\u06f5\u06f6\5\u00b4[\2\u06f6\u06f7")
>
> + buf.write("\7g\2\2\u06f7\u06f8\7
> \2\2\u06f8\u00d7\3\2\2\2\u06f9\u06fe")
>
> + buf.write("\5\u00dan\2\u06fa\u06fb\7(\2\2\u06fb\u06fd\5\u00dan\2")
>
> + buf.write("\u06fc\u06fa\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3")
>
> +
> buf.write("\2\2\2\u06fe\u06ff\3\2\2\2\u06ff\u00d9\3\2\2\2\u0700\u06fe")
>
> + buf.write("\3\2\2\2\u0701\u0705\7\u00fa\2\2\u0702\u0705\7\13\2\2")
>
> +
> buf.write("\u0703\u0705\5V,\2\u0704\u0701\3\2\2\2\u0704\u0702\3\2")
>
> +
> buf.write("\2\2\u0704\u0703\3\2\2\2\u0705\u00db\3\2\2\2\u0706\u0707")
>
> +
> buf.write("\7d\2\2\u0707\u0708\5P)\2\u0708\u070e\7!\2\2\u0709\u070a")
>
> +
> buf.write("\7@\2\2\u070a\u070b\7\b\2\2\u070b\u070c\5\u00dep\2\u070c")
>
> + buf.write("\u070d\7!\2\2\u070d\u070f\3\2\2\2\u070e\u0709\3\2\2\2")
>
> +
> buf.write("\u070e\u070f\3\2\2\2\u070f\u0714\3\2\2\2\u0710\u0711\7")
>
> +
> buf.write("t\2\2\u0711\u0712\7\b\2\2\u0712\u0713\7\u00fa\2\2\u0713")
>
> + buf.write("\u0715\7!\2\2\u0714\u0710\3\2\2\2\u0714\u0715\3\2\2\2")
>
> +
> buf.write("\u0715\u0716\3\2\2\2\u0716\u0717\7h\2\2\u0717\u0718\7")
>
> +
> buf.write("\b\2\2\u0718\u0719\7\u00fa\2\2\u0719\u071a\7!\2\2\u071a")
>
> + buf.write("\u071b\7i\2\2\u071b\u071c\7\b\2\2\u071c\u071d\7\u00fa")
>
> + buf.write("\2\2\u071d\u0722\7!\2\2\u071e\u071f\7j\2\2\u071f\u0720")
>
> +
> buf.write("\7\b\2\2\u0720\u0721\7\u00fa\2\2\u0721\u0723\7!\2\2\u0722")
>
> +
> buf.write("\u071e\3\2\2\2\u0722\u0723\3\2\2\2\u0723\u0724\3\2\2\2")
>
> +
> buf.write("\u0724\u0725\5\u00b4[\2\u0725\u0726\7e\2\2\u0726\u0727")
>
> + buf.write("\7
> \2\2\u0727\u00dd\3\2\2\2\u0728\u072d\5\u00e0q\2\u0729")
>
> +
> buf.write("\u072a\7(\2\2\u072a\u072c\5\u00e0q\2\u072b\u0729\3\2\2")
>
> +
> buf.write("\2\u072c\u072f\3\2\2\2\u072d\u072b\3\2\2\2\u072d\u072e")
>
> +
> buf.write("\3\2\2\2\u072e\u00df\3\2\2\2\u072f\u072d\3\2\2\2\u0730")
>
> +
> buf.write("\u0733\7\u00fa\2\2\u0731\u0733\5V,\2\u0732\u0730\3\2\2")
>
> +
> buf.write("\2\u0732\u0731\3\2\2\2\u0733\u00e1\3\2\2\2\u0734\u0735")
>
> +
> buf.write("\7\63\2\2\u0735\u0736\5P)\2\u0736\u073b\7!\2\2\u0737\u0738")
>
> + buf.write("\7\64\2\2\u0738\u0739\7\b\2\2\u0739\u073a\7\u00fa\2\2")
>
> + buf.write("\u073a\u073c\7!\2\2\u073b\u0737\3\2\2\2\u073b\u073c\3")
>
> +
> buf.write("\2\2\2\u073c\u0742\3\2\2\2\u073d\u073e\7@\2\2\u073e\u073f")
>
> +
> buf.write("\7\b\2\2\u073f\u0740\5\u00e4s\2\u0740\u0741\7!\2\2\u0741")
>
> +
> buf.write("\u0743\3\2\2\2\u0742\u073d\3\2\2\2\u0742\u0743\3\2\2\2")
>
> +
> buf.write("\u0743\u0744\3\2\2\2\u0744\u0745\5\u00b4[\2\u0745\u0746")
>
> + buf.write("\7\65\2\2\u0746\u0747\7
> \2\2\u0747\u00e3\3\2\2\2\u0748")
>
> +
> buf.write("\u074d\5\u00e6t\2\u0749\u074a\7(\2\2\u074a\u074c\5\u00e6")
>
> +
> buf.write("t\2\u074b\u0749\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b")
>
> +
> buf.write("\3\2\2\2\u074d\u074e\3\2\2\2\u074e\u00e5\3\2\2\2\u074f")
>
> +
> buf.write("\u074d\3\2\2\2\u0750\u0755\7\u00fa\2\2\u0751\u0755\7\u00c0"
> )
>
> +
> buf.write("\2\2\u0752\u0755\7\u00c1\2\2\u0753\u0755\5V,\2\u0754\u0750"
> )
>
> +
> buf.write("\3\2\2\2\u0754\u0751\3\2\2\2\u0754\u0752\3\2\2\2\u0754")
>
> +
> buf.write("\u0753\3\2\2\2\u0755\u00e7\3\2\2\2\u0756\u07b1\7A\2\2")
>
> +
> buf.write("\u0757\u0758\5P)\2\u0758\u075e\7!\2\2\u0759\u075a\7@\2")
>
> +
> buf.write("\2\u075a\u075b\7\b\2\2\u075b\u075c\5\u00ecw\2\u075c\u075d"
> )
>
> + buf.write("\7!\2\2\u075d\u075f\3\2\2\2\u075e\u0759\3\2\2\2\u075e")
>
> +
> buf.write("\u075f\3\2\2\2\u075f\u0760\3\2\2\2\u0760\u0761\5\u00b4")
>
> +
> buf.write("[\2\u0761\u07b2\3\2\2\2\u0762\u0763\7C\2\2\u0763\u0764")
>
> +
> buf.write("\7\u008f\2\2\u0764\u0765\7\b\2\2\u0765\u0766\7\u00fb\2")
>
> +
> buf.write("\2\u0766\u0767\7\34\2\2\u0767\u0768\7\u00fb\2\2\u0768")
>
> +
> buf.write("\u0769\7!\2\2\u0769\u076a\7\62\2\2\u076a\u076b\7\b\2\2")
>
> +
> buf.write("\u076b\u076c\7\u00ec\2\2\u076c\u076d\7\30\2\2\u076d\u076e")
>
> +
> buf.write("\7\u00fa\2\2\u076e\u076f\7\31\2\2\u076f\u0770\7!\2\2\u0770")
>
> +
> buf.write("\u0771\7=\2\2\u0771\u0772\7\b\2\2\u0772\u0773\7\u00ec")
>
> +
> buf.write("\2\2\u0773\u0774\7\30\2\2\u0774\u0775\7\u00fa\2\2\u0775")
>
> +
> buf.write("\u0776\7\31\2\2\u0776\u0777\7!\2\2\u0777\u0778\5\u00ea")
>
> +
> buf.write("v\2\u0778\u0779\7D\2\2\u0779\u077a\7\u008f\2\2\u077a\u077b
> ")
>
> + buf.write("\7\b\2\2\u077b\u077c\7\u00fb\2\2\u077c\u077d\7\34\2\2")
>
> +
> buf.write("\u077d\u077e\7\u00fb\2\2\u077e\u077f\7!\2\2\u077f\u0780")
>
> + buf.write("\7\62\2\2\u0780\u0781\7\b\2\2\u0781\u0782\7\u00ec\2\2")
>
> +
> buf.write("\u0782\u0783\7\30\2\2\u0783\u0784\7\u00fa\2\2\u0784\u0785")
>
> + buf.write("\7\31\2\2\u0785\u0786\7!\2\2\u0786\u0787\7=\2\2\u0787")
>
> +
> buf.write("\u0788\7\b\2\2\u0788\u0789\7\u00ec\2\2\u0789\u078a\7\30")
>
> +
> buf.write("\2\2\u078a\u078b\7\u00fa\2\2\u078b\u078c\7\31\2\2\u078c")
>
> +
> buf.write("\u078d\7!\2\2\u078d\u078e\5\u00eav\2\u078e\u078f\7E\2")
>
> +
> buf.write("\2\u078f\u0790\7\u008f\2\2\u0790\u0791\7\b\2\2\u0791\u0792"
> )
>
> + buf.write("\7\u00fb\2\2\u0792\u0793\7\34\2\2\u0793\u0794\7\u00fb")
>
> +
> buf.write("\2\2\u0794\u0795\7!\2\2\u0795\u0796\7\62\2\2\u0796\u0797")
>
> + buf.write("\7\b\2\2\u0797\u0798\7\u00ec\2\2\u0798\u0799\7\30\2\2")
>
> +
> buf.write("\u0799\u079a\7\u00fa\2\2\u079a\u079b\7\31\2\2\u079b\u079c")
>
> +
> buf.write("\7!\2\2\u079c\u079d\7=\2\2\u079d\u079e\7\b\2\2\u079e\u079f")
>
> + buf.write("\7\u00ec\2\2\u079f\u07a0\7\30\2\2\u07a0\u07a1\7\u00fa")
>
> +
> buf.write("\2\2\u07a1\u07a2\7\31\2\2\u07a2\u07a3\7!\2\2\u07a3\u07a9")
>
> +
> buf.write("\5\u00eav\2\u07a4\u07a5\7@\2\2\u07a5\u07a6\7\b\2\2\u07a6")
>
> +
> buf.write("\u07a7\5\u00ecw\2\u07a7\u07a8\7!\2\2\u07a8\u07aa\3\2\2")
>
> +
> buf.write("\2\u07a9\u07a4\3\2\2\2\u07a9\u07aa\3\2\2\2\u07aa\u07ae")
>
> +
> buf.write("\3\2\2\2\u07ab\u07ad\5\u008cG\2\u07ac\u07ab\3\2\2\2\u07ad")
>
> +
> buf.write("\u07b0\3\2\2\2\u07ae\u07ac\3\2\2\2\u07ae\u07af\3\2\2\2")
>
> +
> buf.write("\u07af\u07b2\3\2\2\2\u07b0\u07ae\3\2\2\2\u07b1\u0757\3")
>
> +
> buf.write("\2\2\2\u07b1\u0762\3\2\2\2\u07b2\u07b3\3\2\2\2\u07b3\u07b4"
> )
>
> + buf.write("\7B\2\2\u07b4\u07b5\7
> \2\2\u07b5\u00e9\3\2\2\2\u07b6\u07b7")
>
> +
> buf.write("\7`\2\2\u07b7\u07b8\7\b\2\2\u07b8\u07b9\7\u00fa\2\2\u07b9")
>
> +
> buf.write("\u07ba\7!\2\2\u07ba\u07bb\7a\2\2\u07bb\u07bc\7\b\2\2\u07bc"
> )
>
> +
> buf.write("\u07bd\7\u00fa\2\2\u07bd\u07c2\7!\2\2\u07be\u07bf\7b\2")
>
> +
> buf.write("\2\u07bf\u07c0\7\b\2\2\u07c0\u07c1\7\u00fa\2\2\u07c1\u07c3")
>
> + buf.write("\7!\2\2\u07c2\u07be\3\2\2\2\u07c2\u07c3\3\2\2\2\u07c3")
>
> + buf.write("\u07c8\3\2\2\2\u07c4\u07c5\7c\2\2\u07c5\u07c6\7\b\2\2")
>
> +
> buf.write("\u07c6\u07c7\7\u00fa\2\2\u07c7\u07c9\7!\2\2\u07c8\u07c4")
>
> + buf.write("\3\2\2\2\u07c8\u07c9\3\2\2\2\u07c9\u00eb\3\2\2\2\u07ca")
>
> +
> buf.write("\u07cf\5\u00eex\2\u07cb\u07cc\7(\2\2\u07cc\u07ce\5\u00ee")
>
> +
> buf.write("x\2\u07cd\u07cb\3\2\2\2\u07ce\u07d1\3\2\2\2\u07cf\u07cd")
>
> +
> buf.write("\3\2\2\2\u07cf\u07d0\3\2\2\2\u07d0\u00ed\3\2\2\2\u07d1")
>
> + buf.write("\u07cf\3\2\2\2\u07d2\u07d3\t\6\2\2\u07d3\u00ef\3\2\2\2")
>
> +
> buf.write("\u07d4\u082f\7F\2\2\u07d5\u07d6\5P)\2\u07d6\u07dc\7!\2")
>
> +
> buf.write("\2\u07d7\u07d8\7@\2\2\u07d8\u07d9\7\b\2\2\u07d9\u07da")
>
> +
> buf.write("\5\u00f4{\2\u07da\u07db\7!\2\2\u07db\u07dd\3\2\2\2\u07dc")
>
> +
> buf.write("\u07d7\3\2\2\2\u07dc\u07dd\3\2\2\2\u07dd\u07de\3\2\2\2")
>
> +
> buf.write("\u07de\u07df\5\u00b4[\2\u07df\u0830\3\2\2\2\u07e0\u07e1")
>
> +
> buf.write("\7H\2\2\u07e1\u07e2\7\u008f\2\2\u07e2\u07e3\7\b\2\2\u07e3")
>
> +
> buf.write("\u07e4\7\u00fb\2\2\u07e4\u07e5\7\34\2\2\u07e5\u07e6\7")
>
> +
> buf.write("\u00fb\2\2\u07e6\u07e7\7!\2\2\u07e7\u07e8\7\62\2\2\u07e8")
>
> +
> buf.write("\u07e9\7\b\2\2\u07e9\u07ea\7\u00ec\2\2\u07ea\u07eb\7\30")
>
> +
> buf.write("\2\2\u07eb\u07ec\7\u00fa\2\2\u07ec\u07ed\7\31\2\2\u07ed")
>
> +
> buf.write("\u07ee\7!\2\2\u07ee\u07ef\7=\2\2\u07ef\u07f0\7\b\2\2\u07f0")
>
> + buf.write("\u07f1\7\u00ec\2\2\u07f1\u07f2\7\30\2\2\u07f2\u07f3\7")
>
> +
> buf.write("\u00fa\2\2\u07f3\u07f4\7\31\2\2\u07f4\u07f5\7!\2\2\u07f5")
>
> +
> buf.write("\u07f6\5\u00f2z\2\u07f6\u07f7\7I\2\2\u07f7\u07f8\7\u008f")
>
> + buf.write("\2\2\u07f8\u07f9\7\b\2\2\u07f9\u07fa\7\u00fb\2\2\u07fa")
>
> + buf.write("\u07fb\7\34\2\2\u07fb\u07fc\7\u00fb\2\2\u07fc\u07fd\7")
>
> +
> buf.write("!\2\2\u07fd\u07fe\7\62\2\2\u07fe\u07ff\7\b\2\2\u07ff\u0800")
>
> + buf.write("\7\u00ec\2\2\u0800\u0801\7\30\2\2\u0801\u0802\7\u00fa")
>
> +
> buf.write("\2\2\u0802\u0803\7\31\2\2\u0803\u0804\7!\2\2\u0804\u0805")
>
> +
> buf.write("\7=\2\2\u0805\u0806\7\b\2\2\u0806\u0807\7\u00ec\2\2\u0807")
>
> +
> buf.write("\u0808\7\30\2\2\u0808\u0809\7\u00fa\2\2\u0809\u080a\7")
>
> +
> buf.write("\31\2\2\u080a\u080b\7!\2\2\u080b\u080c\5\u00f2z\2\u080c")
>
> + buf.write("\u080d\7J\2\2\u080d\u080e\7\u008f\2\2\u080e\u080f\7\b")
>
> +
> buf.write("\2\2\u080f\u0810\7\u00fb\2\2\u0810\u0811\7\34\2\2\u0811")
>
> +
> buf.write("\u0812\7\u00fb\2\2\u0812\u0813\7!\2\2\u0813\u0814\7\62")
>
> +
> buf.write("\2\2\u0814\u0815\7\b\2\2\u0815\u0816\7\u00ec\2\2\u0816")
>
> +
> buf.write("\u0817\7\30\2\2\u0817\u0818\7\u00fa\2\2\u0818\u0819\7")
>
> +
> buf.write("\31\2\2\u0819\u081a\7!\2\2\u081a\u081b\7=\2\2\u081b\u081c")
>
> + buf.write("\7\b\2\2\u081c\u081d\7\u00ec\2\2\u081d\u081e\7\30\2\2")
>
> +
> buf.write("\u081e\u081f\7\u00fa\2\2\u081f\u0820\7\31\2\2\u0820\u0821")
>
> +
> buf.write("\7!\2\2\u0821\u0827\5\u00f2z\2\u0822\u0823\7@\2\2\u0823")
>
> +
> buf.write("\u0824\7\b\2\2\u0824\u0825\5\u00f4{\2\u0825\u0826\7!\2")
>
> +
> buf.write("\2\u0826\u0828\3\2\2\2\u0827\u0822\3\2\2\2\u0827\u0828")
>
> +
> buf.write("\3\2\2\2\u0828\u082c\3\2\2\2\u0829\u082b\5\u008cG\2\u082a")
>
> +
> buf.write("\u0829\3\2\2\2\u082b\u082e\3\2\2\2\u082c\u082a\3\2\2\2")
>
> +
> buf.write("\u082c\u082d\3\2\2\2\u082d\u0830\3\2\2\2\u082e\u082c\3")
>
> +
> buf.write("\2\2\2\u082f\u07d5\3\2\2\2\u082f\u07e0\3\2\2\2\u0830\u0831")
>
> + buf.write("\3\2\2\2\u0831\u0832\7G\2\2\u0832\u0833\7
> \2\2\u0833\u00f1")
>
> + buf.write("\3\2\2\2\u0834\u0835\7`\2\2\u0835\u0836\7\b\2\2\u0836")
>
> +
> buf.write("\u0837\7\u00fa\2\2\u0837\u0838\7!\2\2\u0838\u0839\7a\2")
>
> +
> buf.write("\2\u0839\u083a\7\b\2\2\u083a\u083b\7\u00fa\2\2\u083b\u0840"
> )
>
> +
> buf.write("\7!\2\2\u083c\u083d\7b\2\2\u083d\u083e\7\b\2\2\u083e\u083f")
>
> +
> buf.write("\7\u00fa\2\2\u083f\u0841\7!\2\2\u0840\u083c\3\2\2\2\u0840")
>
> + buf.write("\u0841\3\2\2\2\u0841\u0846\3\2\2\2\u0842\u0843\7c\2\2")
>
> +
> buf.write("\u0843\u0844\7\b\2\2\u0844\u0845\7\u00fa\2\2\u0845\u0847")
>
> + buf.write("\7!\2\2\u0846\u0842\3\2\2\2\u0846\u0847\3\2\2\2\u0847")
>
> +
> buf.write("\u00f3\3\2\2\2\u0848\u084d\5\u00f6|\2\u0849\u084a\7(\2")
>
> +
> buf.write("\2\u084a\u084c\5\u00f6|\2\u084b\u0849\3\2\2\2\u084c\u084f")
>
> +
> buf.write("\3\2\2\2\u084d\u084b\3\2\2\2\u084d\u084e\3\2\2\2\u084e")
>
> + buf.write("\u00f5\3\2\2\2\u084f\u084d\3\2\2\2\u0850\u0851\t\7\2\2")
>
> +
> buf.write("\u0851\u00f7\3\2\2\2\u0852\u0857\5\u0104\u0083\2\u0853")
>
> +
> buf.write("\u0857\5\u00fc\177\2\u0854\u0857\5\u00fe\u0080\2\u0855")
>
> +
> buf.write("\u0857\5\u010e\u0088\2\u0856\u0852\3\2\2\2\u0856\u0853")
>
> +
> buf.write("\3\2\2\2\u0856\u0854\3\2\2\2\u0856\u0855\3\2\2\2\u0857")
>
> +
> buf.write("\u00f9\3\2\2\2\u0858\u0859\5\u0104\u0083\2\u0859\u085a")
>
> +
> buf.write("\5\u010a\u0086\2\u085a\u085b\5\u010c\u0087\2\u085b\u085c")
>
> +
> buf.write("\5\u010e\u0088\2\u085c\u00fb\3\2\2\2\u085d\u085e\5\u010a")
>
> +
> buf.write("\u0086\2\u085e\u00fd\3\2\2\2\u085f\u0860\5\u010c\u0087")
>
> +
> buf.write("\2\u0860\u00ff\3\2\2\2\u0861\u0868\5p9\2\u0862\u0868\5")
>
> +
> buf.write("\u0088E\2\u0863\u0868\5\u00f8}\2\u0864\u0868\5\u0118\u008d
> ")
>
> +
> buf.write("\2\u0865\u0868\5\u011c\u008f\2\u0866\u0868\5\u0110\u0089")
>
> +
> buf.write("\2\u0867\u0861\3\2\2\2\u0867\u0862\3\2\2\2\u0867\u0863")
>
> +
> buf.write("\3\2\2\2\u0867\u0864\3\2\2\2\u0867\u0865\3\2\2\2\u0867")
>
> +
> buf.write("\u0866\3\2\2\2\u0868\u0101\3\2\2\2\u0869\u086e\5p9\2\u086a"
> )
>
> +
> buf.write("\u086e\5\u0088E\2\u086b\u086e\5\u0118\u008d\2\u086c\u086e"
> )
>
> +
> buf.write("\5\u0110\u0089\2\u086d\u0869\3\2\2\2\u086d\u086a\3\2\2")
>
> +
> buf.write("\2\u086d\u086b\3\2\2\2\u086d\u086c\3\2\2\2\u086e\u0103")
>
> + buf.write("\3\2\2\2\u086f\u0870\7l\2\2\u0870\u0871\5\u0124\u0093")
>
> + buf.write("\2\u0871\u0875\7
> \2\2\u0872\u0874\5\u0100\u0081\2\u0873")
>
> +
> buf.write("\u0872\3\2\2\2\u0874\u0877\3\2\2\2\u0875\u0873\3\2\2\2")
>
> +
> buf.write("\u0875\u0876\3\2\2\2\u0876\u0878\3\2\2\2\u0877\u0875\3")
>
> + buf.write("\2\2\2\u0878\u0879\7s\2\2\u0879\u087a\7
> \2\2\u087a\u0105")
>
> +
> buf.write("\3\2\2\2\u087b\u0888\7k\2\2\u087c\u087d\7@\2\2\u087d\u087e
> ")
>
> +
> buf.write("\7\b\2\2\u087e\u0883\5\u009eP\2\u087f\u0880\7(\2\2\u0880")
>
> +
> buf.write("\u0882\5\u009eP\2\u0881\u087f\3\2\2\2\u0882\u0885\3\2")
>
> +
> buf.write("\2\2\u0883\u0881\3\2\2\2\u0883\u0884\3\2\2\2\u0884\u0886")
>
> + buf.write("\3\2\2\2\u0885\u0883\3\2\2\2\u0886\u0887\7!\2\2\u0887")
>
> +
> buf.write("\u0889\3\2\2\2\u0888\u087c\3\2\2\2\u0888\u0889\3\2\2\2")
>
> +
> buf.write("\u0889\u088a\3\2\2\2\u088a\u088b\5\u0124\u0093\2\u088b")
>
> + buf.write("\u088c\7
> \2\2\u088c\u0107\3\2\2\2\u088d\u089a\7K\2\2\u088e")
>
> +
> buf.write("\u088f\7@\2\2\u088f\u0890\7\b\2\2\u0890\u0895\5\u009e")
>
> +
> buf.write("P\2\u0891\u0892\7(\2\2\u0892\u0894\5\u009eP\2\u0893\u0891")
>
> +
> buf.write("\3\2\2\2\u0894\u0897\3\2\2\2\u0895\u0893\3\2\2\2\u0895")
>
> +
> buf.write("\u0896\3\2\2\2\u0896\u0898\3\2\2\2\u0897\u0895\3\2\2\2")
>
> +
> buf.write("\u0898\u0899\7!\2\2\u0899\u089b\3\2\2\2\u089a\u088e\3")
>
> +
> buf.write("\2\2\2\u089a\u089b\3\2\2\2\u089b\u089c\3\2\2\2\u089c\u089d")
>
> + buf.write("\5\u0124\u0093\2\u089d\u089e\7
> \2\2\u089e\u0109\3\2\2")
>
> +
> buf.write("\2\u089f\u08ac\7k\2\2\u08a0\u08a1\7@\2\2\u08a1\u08a2\7")
>
> +
> buf.write("\b\2\2\u08a2\u08a7\5\u009eP\2\u08a3\u08a4\7(\2\2\u08a4")
>
> +
> buf.write("\u08a6\5\u009eP\2\u08a5\u08a3\3\2\2\2\u08a6\u08a9\3\2")
>
> +
> buf.write("\2\2\u08a7\u08a5\3\2\2\2\u08a7\u08a8\3\2\2\2\u08a8\u08aa")
>
> + buf.write("\3\2\2\2\u08a9\u08a7\3\2\2\2\u08aa\u08ab\7!\2\2\u08ab")
>
> +
> buf.write("\u08ad\3\2\2\2\u08ac\u08a0\3\2\2\2\u08ac\u08ad\3\2\2\2")
>
> +
> buf.write("\u08ad\u08ae\3\2\2\2\u08ae\u08af\5\u0124\u0093\2\u08af")
>
> + buf.write("\u08b3\7
> \2\2\u08b0\u08b2\5\u0100\u0081\2\u08b1\u08b0")
>
> +
> buf.write("\3\2\2\2\u08b2\u08b5\3\2\2\2\u08b3\u08b1\3\2\2\2\u08b3")
>
> +
> buf.write("\u08b4\3\2\2\2\u08b4\u08b6\3\2\2\2\u08b5\u08b3\3\2\2\2")
>
> + buf.write("\u08b6\u08b7\7s\2\2\u08b7\u08b8\7
> \2\2\u08b8\u010b\3\2")
>
> +
> buf.write("\2\2\u08b9\u08c6\7K\2\2\u08ba\u08bb\7@\2\2\u08bb\u08bc")
>
> +
> buf.write("\7\b\2\2\u08bc\u08c1\5\u009eP\2\u08bd\u08be\7(\2\2\u08be")
>
> + buf.write("\u08c0\5\u009eP\2\u08bf\u08bd\3\2\2\2\u08c0\u08c3\3\2")
>
> +
> buf.write("\2\2\u08c1\u08bf\3\2\2\2\u08c1\u08c2\3\2\2\2\u08c2\u08c4")
>
> + buf.write("\3\2\2\2\u08c3\u08c1\3\2\2\2\u08c4\u08c5\7!\2\2\u08c5")
>
> + buf.write("\u08c7\3\2\2\2\u08c6\u08ba\3\2\2\2\u08c6\u08c7\3\2\2\2")
>
> +
> buf.write("\u08c7\u08c8\3\2\2\2\u08c8\u08c9\5\u0124\u0093\2\u08c9")
>
> + buf.write("\u08cd\7 \2\2\u08ca\u08cc\5\u0100\u0081\2\u08cb\u08ca")
>
> + buf.write("\3\2\2\2\u08cc\u08cf\3\2\2\2\u08cd\u08cb\3\2\2\2\u08cd")
>
> + buf.write("\u08ce\3\2\2\2\u08ce\u08d0\3\2\2\2\u08cf\u08cd\3\2\2\2")
>
> + buf.write("\u08d0\u08d1\7s\2\2\u08d1\u08d2\7
> \2\2\u08d2\u010d\3\2")
>
> +
> buf.write("\2\2\u08d3\u08d4\7p\2\2\u08d4\u08d5\7\62\2\2\u08d5\u08d6")
>
> +
> buf.write("\7\b\2\2\u08d6\u08d7\7\u00ec\2\2\u08d7\u08d8\7\30\2\2")
>
> +
> buf.write("\u08d8\u08d9\7\u00fa\2\2\u08d9\u08da\7\31\2\2\u08da\u08e7")
>
> +
> buf.write("\7!\2\2\u08db\u08dc\7@\2\2\u08dc\u08dd\7\b\2\2\u08dd\u08e2
> ")
>
> + buf.write("\5\u009eP\2\u08de\u08df\7(\2\2\u08df\u08e1\5\u009eP\2")
>
> +
> buf.write("\u08e0\u08de\3\2\2\2\u08e1\u08e4\3\2\2\2\u08e2\u08e0\3")
>
> +
> buf.write("\2\2\2\u08e2\u08e3\3\2\2\2\u08e3\u08e5\3\2\2\2\u08e4\u08e2"
> )
>
> + buf.write("\3\2\2\2\u08e5\u08e6\7!\2\2\u08e6\u08e8\3\2\2\2\u08e7")
>
> +
> buf.write("\u08db\3\2\2\2\u08e7\u08e8\3\2\2\2\u08e8\u08e9\3\2\2\2")
>
> +
> buf.write("\u08e9\u08ea\5\u0124\u0093\2\u08ea\u08eb\7s\2\2\u08eb")
>
> + buf.write("\u08ec\7 \2\2\u08ec\u010f\3\2\2\2\u08ed\u08f1\5\u0112")
>
> +
> buf.write("\u008a\2\u08ee\u08f1\5\u0114\u008b\2\u08ef\u08f1\5\u0116")
>
> +
> buf.write("\u008c\2\u08f0\u08ed\3\2\2\2\u08f0\u08ee\3\2\2\2\u08f0")
>
> + buf.write("\u08ef\3\2\2\2\u08f1\u0111\3\2\2\2\u08f2\u08f3\7m\2\2")
>
> +
> buf.write("\u08f3\u08f4\7\u0096\2\2\u08f4\u08f5\7\b\2\2\u08f5\u08f6")
>
> +
> buf.write("\7\u00fa\2\2\u08f6\u08f7\7!\2\2\u08f7\u08f8\7t\2\2\u08f8")
>
> + buf.write("\u08f9\7\b\2\2\u08f9\u08fa\7\u00fa\2\2\u08fa\u08fb\7 ")
>
> +
> buf.write("\2\2\u08fb\u0113\3\2\2\2\u08fc\u08fd\7N\2\2\u08fd\u08fe")
>
> +
> buf.write("\7=\2\2\u08fe\u08ff\7\b\2\2\u08ff\u0900\7\u00ec\2\2\u0900")
>
> +
> buf.write("\u0901\7\30\2\2\u0901\u0902\7\u00fa\2\2\u0902\u0903\7")
>
> +
> buf.write("\31\2\2\u0903\u0904\7!\2\2\u0904\u0905\7>\2\2\u0905\u0906")
>
> + buf.write("\7\b\2\2\u0906\u0907\7\u00ec\2\2\u0907\u0908\7\30\2\2")
>
> +
> buf.write("\u0908\u0909\7\u00fa\2\2\u0909\u090a\7\31\2\2\u090a\u0911")
>
> +
> buf.write("\7!\2\2\u090b\u090c\7>\2\2\u090c\u090d\7\b\2\2\u090d\u090e")
>
> + buf.write("\7\u00ec\2\2\u090e\u090f\7\30\2\2\u090f\u0910\7\u00fa")
>
> +
> buf.write("\2\2\u0910\u0912\7\31\2\2\u0911\u090b\3\2\2\2\u0911\u0912")
>
> + buf.write("\3\2\2\2\u0912\u0913\3\2\2\2\u0913\u0914\7 \2\2\u0914")
>
> +
> buf.write("\u0115\3\2\2\2\u0915\u0916\t\b\2\2\u0916\u0917\7\u0087")
>
> +
> buf.write("\2\2\u0917\u0918\7!\2\2\u0918\u0919\7/\2\2\u0919\u091a")
>
> +
> buf.write("\7\b\2\2\u091a\u091b\7\u00fa\2\2\u091b\u091c\7!\2\2\u091c")
>
> +
> buf.write("\u091d\7\62\2\2\u091d\u091e\7\b\2\2\u091e\u091f\7\u00ec")
>
> +
> buf.write("\2\2\u091f\u0920\7\30\2\2\u0920\u0921\7\u00fa\2\2\u0921")
>
> + buf.write("\u0922\7\31\2\2\u0922\u0923\7!\2\2\u0923\u0924\7=\2\2")
>
> +
> buf.write("\u0924\u0925\7\b\2\2\u0925\u0926\7\u00ec\2\2\u0926\u0927")
>
> +
> buf.write("\7\30\2\2\u0927\u0928\7\u00fa\2\2\u0928\u0934\7\31\2\2")
>
> +
> buf.write("\u0929\u092a\7!\2\2\u092a\u092b\7@\2\2\u092b\u092c\7\b")
>
> +
> buf.write("\2\2\u092c\u0931\5\u009eP\2\u092d\u092e\7(\2\2\u092e\u0930"
> )
>
> +
> buf.write("\5\u009eP\2\u092f\u092d\3\2\2\2\u0930\u0933\3\2\2\2\u0931")
>
> +
> buf.write("\u092f\3\2\2\2\u0931\u0932\3\2\2\2\u0932\u0935\3\2\2\2")
>
> +
> buf.write("\u0933\u0931\3\2\2\2\u0934\u0929\3\2\2\2\u0934\u0935\3")
>
> +
> buf.write("\2\2\2\u0935\u093a\3\2\2\2\u0936\u0937\7!\2\2\u0937\u0938")
>
> +
> buf.write("\7t\2\2\u0938\u0939\7\b\2\2\u0939\u093b\7\u00fa\2\2\u093a")
>
> +
> buf.write("\u0936\3\2\2\2\u093a\u093b\3\2\2\2\u093b\u093c\3\2\2\2")
>
> + buf.write("\u093c\u093d\7 \2\2\u093d\u0117\3\2\2\2\u093e\u093f\7")
>
> + buf.write("L\2\2\u093f\u0940\7\u00fa\2\2\u0940\u0941\7 \2\2\u0941")
>
> +
> buf.write("\u0119\3\2\2\2\u0942\u0944\7\u0088\2\2\u0943\u0945\7!")
>
> +
> buf.write("\2\2\u0944\u0943\3\2\2\2\u0944\u0945\3\2\2\2\u0945\u0946")
>
> + buf.write("\3\2\2\2\u0946\u0947\7.\2\2\u0947\u0948\7\b\2\2\u0948")
>
> +
> buf.write("\u0949\7\u00ec\2\2\u0949\u094a\7\30\2\2\u094a\u094b\7")
>
> +
> buf.write("\u00fa\2\2\u094b\u094c\7\31\2\2\u094c\u0957\7!\2\2\u094d")
>
> +
> buf.write("\u094e\7\u008d\2\2\u094e\u094f\7\u00fa\2\2\u094f\u0950")
>
> +
> buf.write("\7!\2\2\u0950\u0951\7\u0089\2\2\u0951\u0952\t\t\2\2\u0952")
>
> + buf.write("\u0958\7
> \2\2\u0953\u0954\7M\2\2\u0954\u0955\7\b\2\2\u0955")
>
> + buf.write("\u0956\7\u00fa\2\2\u0956\u0958\7 \2\2\u0957\u094d\3\2")
>
> +
> buf.write("\2\2\u0957\u0953\3\2\2\2\u0958\u011b\3\2\2\2\u0959\u095a")
>
> +
> buf.write("\7\u00a7\2\2\u095a\u095b\7[\2\2\u095b\u095c\7\b\2\2\u095c")
>
> +
> buf.write("\u09a4\5L\'\2\u095d\u095e\7!\2\2\u095e\u095f\7\u00a9\2")
>
> + buf.write("\2\u095f\u099c\7\b\2\2\u0960\u0964\7S\2\2\u0961\u0962")
>
> +
> buf.write("\7\32\2\2\u0962\u0963\7\u00fa\2\2\u0963\u0965\7\33\2\2")
>
> +
> buf.write("\u0964\u0961\3\2\2\2\u0964\u0965\3\2\2\2\u0965\u099d\3")
>
> +
> buf.write("\2\2\2\u0966\u096a\7T\2\2\u0967\u0968\7\32\2\2\u0968\u0969"
> )
>
> + buf.write("\7\u00fa\2\2\u0969\u096b\7\33\2\2\u096a\u0967\3\2\2\2")
>
> +
> buf.write("\u096a\u096b\3\2\2\2\u096b\u099d\3\2\2\2\u096c\u0970\7")
>
> +
> buf.write("U\2\2\u096d\u096e\7\32\2\2\u096e\u096f\7\u00fa\2\2\u096f")
>
> + buf.write("\u0971\7\33\2\2\u0970\u096d\3\2\2\2\u0970\u0971\3\2\2")
>
> +
> buf.write("\2\u0971\u099d\3\2\2\2\u0972\u0976\7V\2\2\u0973\u0974")
>
> +
> buf.write("\7\32\2\2\u0974\u0975\7\u00fa\2\2\u0975\u0977\7\33\2\2")
>
> +
> buf.write("\u0976\u0973\3\2\2\2\u0976\u0977\3\2\2\2\u0977\u099d\3")
>
> +
> buf.write("\2\2\2\u0978\u097c\7R\2\2\u0979\u097a\7\32\2\2\u097a\u097b"
> )
>
> + buf.write("\7\u00fa\2\2\u097b\u097d\7\33\2\2\u097c\u0979\3\2\2\2")
>
> +
> buf.write("\u097c\u097d\3\2\2\2\u097d\u099d\3\2\2\2\u097e\u0982\7")
>
> +
> buf.write("W\2\2\u097f\u0980\7\32\2\2\u0980\u0981\7\u00fa\2\2\u0981")
>
> + buf.write("\u0983\7\33\2\2\u0982\u097f\3\2\2\2\u0982\u0983\3\2\2")
>
> +
> buf.write("\2\u0983\u099d\3\2\2\2\u0984\u0988\7X\2\2\u0985\u0986")
>
> +
> buf.write("\7\32\2\2\u0986\u0987\7\u00fa\2\2\u0987\u0989\7\33\2\2")
>
> +
> buf.write("\u0988\u0985\3\2\2\2\u0988\u0989\3\2\2\2\u0989\u099d\3")
>
> +
> buf.write("\2\2\2\u098a\u098e\7Y\2\2\u098b\u098c\7\32\2\2\u098c\u098d"
> )
>
> + buf.write("\7\u00fa\2\2\u098d\u098f\7\33\2\2\u098e\u098b\3\2\2\2")
>
> +
> buf.write("\u098e\u098f\3\2\2\2\u098f\u099d\3\2\2\2\u0990\u0994\7")
>
> +
> buf.write("Z\2\2\u0991\u0992\7\32\2\2\u0992\u0993\7\u00fa\2\2\u0993")
>
> + buf.write("\u0995\7\33\2\2\u0994\u0991\3\2\2\2\u0994\u0995\3\2\2")
>
> +
> buf.write("\2\u0995\u099d\3\2\2\2\u0996\u099a\7\u00fb\2\2\u0997\u0998"
> )
>
> +
> buf.write("\7\32\2\2\u0998\u0999\7\u00fa\2\2\u0999\u099b\7\33\2\2")
>
> +
> buf.write("\u099a\u0997\3\2\2\2\u099a\u099b\3\2\2\2\u099b\u099d\3")
>
> +
> buf.write("\2\2\2\u099c\u0960\3\2\2\2\u099c\u0966\3\2\2\2\u099c\u096c")
>
> +
> buf.write("\3\2\2\2\u099c\u0972\3\2\2\2\u099c\u0978\3\2\2\2\u099c")
>
> +
> buf.write("\u097e\3\2\2\2\u099c\u0984\3\2\2\2\u099c\u098a\3\2\2\2")
>
> +
> buf.write("\u099c\u0990\3\2\2\2\u099c\u0996\3\2\2\2\u099d\u09a1\3")
>
> +
> buf.write("\2\2\2\u099e\u09a0\5\u011e\u0090\2\u099f\u099e\3\2\2\2")
>
> +
> buf.write("\u09a0\u09a3\3\2\2\2\u09a1\u099f\3\2\2\2\u09a1\u09a2\3")
>
> +
> buf.write("\2\2\2\u09a2\u09a5\3\2\2\2\u09a3\u09a1\3\2\2\2\u09a4\u095d"
> )
>
> +
> buf.write("\3\2\2\2\u09a4\u09a5\3\2\2\2\u09a5\u09ae\3\2\2\2\u09a6")
>
> +
> buf.write("\u09aa\7!\2\2\u09a7\u09a9\5\u011c\u008f\2\u09a8\u09a7")
>
> +
> buf.write("\3\2\2\2\u09a9\u09ac\3\2\2\2\u09aa\u09a8\3\2\2\2\u09aa")
>
> +
> buf.write("\u09ab\3\2\2\2\u09ab\u09ad\3\2\2\2\u09ac\u09aa\3\2\2\2")
>
> +
> buf.write("\u09ad\u09af\7\u00a8\2\2\u09ae\u09a6\3\2\2\2\u09ae\u09af")
>
> + buf.write("\3\2\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b1\7 \2\2\u09b1")
>
> +
> buf.write("\u011d\3\2\2\2\u09b2\u09b3\7!\2\2\u09b3\u09b7\7\u00aa")
>
> +
> buf.write("\2\2\u09b4\u09b5\7\32\2\2\u09b5\u09b6\7\u00fa\2\2\u09b6")
>
> +
> buf.write("\u09b8\7\33\2\2\u09b7\u09b4\3\2\2\2\u09b7\u09b8\3\2\2")
>
> +
> buf.write("\2\u09b8\u09bd\3\2\2\2\u09b9\u09ba\7\34\2\2\u09ba\u09bc")
>
> +
> buf.write("\5\u015e\u00b0\2\u09bb\u09b9\3\2\2\2\u09bc\u09bf\3\2\2")
>
> +
> buf.write("\2\u09bd\u09bb\3\2\2\2\u09bd\u09be\3\2\2\2\u09be\u09c0")
>
> + buf.write("\3\2\2\2\u09bf\u09bd\3\2\2\2\u09c0\u09c1\7\b\2\2\u09c1")
>
> +
> buf.write("\u09c2\7\u00fa\2\2\u09c2\u011f\3\2\2\2\u09c3\u09c4\5\u0122")
>
> + buf.write("\u0092\2\u09c4\u09c5\7 \2\2\u09c5\u0121\3\2\2\2\u09c6")
>
> +
> buf.write("\u09c7\7\u00ab\2\2\u09c7\u0123\3\2\2\2\u09c8\u09cd\5\u0128"
> )
>
> +
> buf.write("\u0095\2\u09c9\u09ca\7\u00dc\2\2\u09ca\u09cc\5\u0128\u0095"
> )
>
> + buf.write("\2\u09cb\u09c9\3\2\2\2\u09cc\u09cf\3\2\2\2\u09cd\u09cb")
>
> + buf.write("\3\2\2\2\u09cd\u09ce\3\2\2\2\u09ce\u0125\3\2\2\2\u09cf")
>
> +
> buf.write("\u09cd\3\2\2\2\u09d0\u09d5\5\u0128\u0095\2\u09d1\u09d2")
>
> +
> buf.write("\7\u00dc\2\2\u09d2\u09d4\5\u0128\u0095\2\u09d3\u09d1\3")
>
> +
> buf.write("\2\2\2\u09d4\u09d7\3\2\2\2\u09d5\u09d3\3\2\2\2\u09d5\u09d6"
> )
>
> +
> buf.write("\3\2\2\2\u09d6\u0127\3\2\2\2\u09d7\u09d5\3\2\2\2\u09d8")
>
> +
> buf.write("\u09dd\5\u012a\u0096\2\u09d9\u09da\7\u00db\2\2\u09da\u09d
> c")
>
> +
> buf.write("\5\u012a\u0096\2\u09db\u09d9\3\2\2\2\u09dc\u09df\3\2\2")
>
> +
> buf.write("\2\u09dd\u09db\3\2\2\2\u09dd\u09de\3\2\2\2\u09de\u0129")
>
> +
> buf.write("\3\2\2\2\u09df\u09dd\3\2\2\2\u09e0\u09e5\5\u012c\u0097")
>
> +
> buf.write("\2\u09e1\u09e2\7(\2\2\u09e2\u09e4\5\u012c\u0097\2\u09e3")
>
> +
> buf.write("\u09e1\3\2\2\2\u09e4\u09e7\3\2\2\2\u09e5\u09e3\3\2\2\2")
>
> +
> buf.write("\u09e5\u09e6\3\2\2\2\u09e6\u012b\3\2\2\2\u09e7\u09e5\3")
>
> +
> buf.write("\2\2\2\u09e8\u09ed\5\u012e\u0098\2\u09e9\u09ea\7)\2\2")
>
> +
> buf.write("\u09ea\u09ec\5\u012e\u0098\2\u09eb\u09e9\3\2\2\2\u09ec")
>
> +
> buf.write("\u09ef\3\2\2\2\u09ed\u09eb\3\2\2\2\u09ed\u09ee\3\2\2\2")
>
> +
> buf.write("\u09ee\u012d\3\2\2\2\u09ef\u09ed\3\2\2\2\u09f0\u09f4\5")
>
> +
> buf.write("\u0132\u009a\2\u09f1\u09f3\5\u0130\u0099\2\u09f2\u09f1")
>
> + buf.write("\3\2\2\2\u09f3\u09f6\3\2\2\2\u09f4\u09f2\3\2\2\2\u09f4")
>
> + buf.write("\u09f5\3\2\2\2\u09f5\u012f\3\2\2\2\u09f6\u09f4\3\2\2\2")
>
> + buf.write("\u09f7\u09f8\7\"\2\2\u09f8\u09fc\5\u0132\u009a\2\u09f9")
>
> + buf.write("\u09fa\7#\2\2\u09fa\u09fc\5\u0132\u009a\2\u09fb\u09f7")
>
> + buf.write("\3\2\2\2\u09fb\u09f9\3\2\2\2\u09fc\u0131\3\2\2\2\u09fd")
>
> +
> buf.write("\u0a01\5\u0136\u009c\2\u09fe\u0a00\5\u0134\u009b\2\u09ff")
>
> + buf.write("\u09fe\3\2\2\2\u0a00\u0a03\3\2\2\2\u0a01\u09ff\3\2\2\2")
>
> +
> buf.write("\u0a01\u0a02\3\2\2\2\u0a02\u0133\3\2\2\2\u0a03\u0a01\3")
>
> +
> buf.write("\2\2\2\u0a04\u0a05\7%\2\2\u0a05\u0a0d\5\u0136\u009c\2")
>
> +
> buf.write("\u0a06\u0a07\7$\2\2\u0a07\u0a0d\5\u0136\u009c\2\u0a08")
>
> +
> buf.write("\u0a09\7\'\2\2\u0a09\u0a0d\5\u0136\u009c\2\u0a0a\u0a0b")
>
> +
> buf.write("\7&\2\2\u0a0b\u0a0d\5\u0136\u009c\2\u0a0c\u0a04\3\2\2")
>
> +
> buf.write("\2\u0a0c\u0a06\3\2\2\2\u0a0c\u0a08\3\2\2\2\u0a0c\u0a0a")
>
> +
> buf.write("\3\2\2\2\u0a0d\u0135\3\2\2\2\u0a0e\u0a12\5\u013a\u009e")
>
> +
> buf.write("\2\u0a0f\u0a11\5\u0138\u009d\2\u0a10\u0a0f\3\2\2\2\u0a11")
>
> +
> buf.write("\u0a14\3\2\2\2\u0a12\u0a10\3\2\2\2\u0a12\u0a13\3\2\2\2")
>
> +
> buf.write("\u0a13\u0137\3\2\2\2\u0a14\u0a12\3\2\2\2\u0a15\u0a16\7")
>
> +
> buf.write("\f\2\2\u0a16\u0a1a\5\u013a\u009e\2\u0a17\u0a18\7\r\2\2")
>
> +
> buf.write("\u0a18\u0a1a\5\u013a\u009e\2\u0a19\u0a15\3\2\2\2\u0a19")
>
> +
> buf.write("\u0a17\3\2\2\2\u0a1a\u0139\3\2\2\2\u0a1b\u0a1f\5\u013e")
>
> +
> buf.write("\u00a0\2\u0a1c\u0a1e\5\u013c\u009f\2\u0a1d\u0a1c\3\2\2")
>
> +
> buf.write("\2\u0a1e\u0a21\3\2\2\2\u0a1f\u0a1d\3\2\2\2\u0a1f\u0a20")
>
> +
> buf.write("\3\2\2\2\u0a20\u013b\3\2\2\2\u0a21\u0a1f\3\2\2\2\u0a22")
>
> +
> buf.write("\u0a23\7\16\2\2\u0a23\u0a27\5\u013e\u00a0\2\u0a24\u0a25")
>
> +
> buf.write("\7\35\2\2\u0a25\u0a27\5\u013e\u00a0\2\u0a26\u0a22\3\2")
>
> +
> buf.write("\2\2\u0a26\u0a24\3\2\2\2\u0a27\u013d\3\2\2\2\u0a28\u0a2c")
>
> +
> buf.write("\5\u0142\u00a2\2\u0a29\u0a2b\5\u0140\u00a1\2\u0a2a\u0a29")
>
> +
> buf.write("\3\2\2\2\u0a2b\u0a2e\3\2\2\2\u0a2c\u0a2a\3\2\2\2\u0a2c")
>
> +
> buf.write("\u0a2d\3\2\2\2\u0a2d\u013f\3\2\2\2\u0a2e\u0a2c\3\2\2\2")
>
> +
> buf.write("\u0a2f\u0a30\7\17\2\2\u0a30\u0a36\5\u0142\u00a2\2\u0a31")
>
> +
> buf.write("\u0a32\7\37\2\2\u0a32\u0a36\5\u0142\u00a2\2\u0a33\u0a34")
>
> +
> buf.write("\7\20\2\2\u0a34\u0a36\5\u0142\u00a2\2\u0a35\u0a2f\3\2")
>
> +
> buf.write("\2\2\u0a35\u0a31\3\2\2\2\u0a35\u0a33\3\2\2\2\u0a36\u0141")
>
> +
> buf.write("\3\2\2\2\u0a37\u0a39\5\u0144\u00a3\2\u0a38\u0a37\3\2\2")
>
> +
> buf.write("\2\u0a39\u0a3c\3\2\2\2\u0a3a\u0a38\3\2\2\2\u0a3a\u0a3b")
>
> +
> buf.write("\3\2\2\2\u0a3b\u0a3d\3\2\2\2\u0a3c\u0a3a\3\2\2\2\u0a3d")
>
> +
> buf.write("\u0a3e\5\u0146\u00a4\2\u0a3e\u0143\3\2\2\2\u0a3f\u0a40")
>
> +
> buf.write("\7\30\2\2\u0a40\u0a41\t\n\2\2\u0a41\u0a42\7\31\2\2\u0a42")
>
> +
> buf.write("\u0145\3\2\2\2\u0a43\u0a4f\5\u0148\u00a5\2\u0a44\u0a4f")
>
> +
> buf.write("\5\u014a\u00a6\2\u0a45\u0a4f\5\u014c\u00a7\2\u0a46\u0a4f")
>
> +
> buf.write("\5\u014e\u00a8\2\u0a47\u0a4f\5\u0150\u00a9\2\u0a48\u0a4f")
>
> +
> buf.write("\5\u016e\u00b8\2\u0a49\u0a4f\5\u0170\u00b9\2\u0a4a\u0a4f")
>
> +
> buf.write("\5\u0186\u00c4\2\u0a4b\u0a4f\5\u0196\u00cc\2\u0a4c\u0a4d")
>
> +
> buf.write("\7\u00dd\2\2\u0a4d\u0a4f\5\u0146\u00a4\2\u0a4e\u0a43\3")
>
> +
> buf.write("\2\2\2\u0a4e\u0a44\3\2\2\2\u0a4e\u0a45\3\2\2\2\u0a4e\u0a46"
> )
>
> +
> buf.write("\3\2\2\2\u0a4e\u0a47\3\2\2\2\u0a4e\u0a48\3\2\2\2\u0a4e")
>
> +
> buf.write("\u0a49\3\2\2\2\u0a4e\u0a4a\3\2\2\2\u0a4e\u0a4b\3\2\2\2")
>
> +
> buf.write("\u0a4e\u0a4c\3\2\2\2\u0a4f\u0147\3\2\2\2\u0a50\u0a51\7")
>
> +
> buf.write("\u00e7\2\2\u0a51\u0a52\7\30\2\2\u0a52\u0a53\5\u0126\u0094")
>
> +
> buf.write("\2\u0a53\u0a54\7!\2\2\u0a54\u0a55\5\u0126\u0094\2\u0a55")
>
> +
> buf.write("\u0a56\7\31\2\2\u0a56\u0149\3\2\2\2\u0a57\u0a58\7\u00e5")
>
> +
> buf.write("\2\2\u0a58\u0a59\7\30\2\2\u0a59\u0a5a\5\u0126\u0094\2")
>
> +
> buf.write("\u0a5a\u0a5b\7!\2\2\u0a5b\u0a5c\5\u0126\u0094\2\u0a5c")
>
> +
> buf.write("\u0a5d\7\31\2\2\u0a5d\u014b\3\2\2\2\u0a5e\u0a5f\7\u00e6")
>
> +
> buf.write("\2\2\u0a5f\u0a60\7\30\2\2\u0a60\u0a61\5\u0126\u0094\2")
>
> +
> buf.write("\u0a61\u0a62\7!\2\2\u0a62\u0a63\5\u0126\u0094\2\u0a63")
>
> + buf.write("\u0a64\7!\2\2\u0a64\u0a65\5L\'\2\u0a65\u0a66\7\31\2\2")
>
> +
> buf.write("\u0a66\u014d\3\2\2\2\u0a67\u0a68\7\30\2\2\u0a68\u0a69")
>
> +
> buf.write("\5\u0126\u0094\2\u0a69\u0a6a\7\31\2\2\u0a6a\u014f\3\2")
>
> +
> buf.write("\2\2\u0a6b\u0a77\5\u0152\u00aa\2\u0a6c\u0a77\5\u0154\u00ab
> ")
>
> +
> buf.write("\2\u0a6d\u0a77\5\u0156\u00ac\2\u0a6e\u0a77\5\u0158\u00ad")
>
> +
> buf.write("\2\u0a6f\u0a77\5\u015a\u00ae\2\u0a70\u0a77\5\u0160\u00b1")
>
> +
> buf.write("\2\u0a71\u0a77\5\u0162\u00b2\2\u0a72\u0a77\5\u0164\u00b3")
>
> +
> buf.write("\2\u0a73\u0a77\5\u0166\u00b4\2\u0a74\u0a77\5\u0168\u00b5")
>
> +
> buf.write("\2\u0a75\u0a77\5\u016c\u00b7\2\u0a76\u0a6b\3\2\2\2\u0a76")
>
> +
> buf.write("\u0a6c\3\2\2\2\u0a76\u0a6d\3\2\2\2\u0a76\u0a6e\3\2\2\2")
>
> +
> buf.write("\u0a76\u0a6f\3\2\2\2\u0a76\u0a70\3\2\2\2\u0a76\u0a71\3")
>
> +
> buf.write("\2\2\2\u0a76\u0a72\3\2\2\2\u0a76\u0a73\3\2\2\2\u0a76\u0a74"
> )
>
> +
> buf.write("\3\2\2\2\u0a76\u0a75\3\2\2\2\u0a77\u0151\3\2\2\2\u0a78")
>
> +
> buf.write("\u0a79\7\u00c7\2\2\u0a79\u0153\3\2\2\2\u0a7a\u0a7b\7\u00c8"
> )
>
> +
> buf.write("\2\2\u0a7b\u0a7c\7\u00c9\2\2\u0a7c\u0a7d\7\30\2\2\u0a7d")
>
> + buf.write("\u0a7e\7\u00fa\2\2\u0a7e\u0a89\7\31\2\2\u0a7f\u0a80\7")
>
> +
> buf.write("\"\2\2\u0a80\u0a8a\7\u00fa\2\2\u0a81\u0a82\7$\2\2\u0a82")
>
> +
> buf.write("\u0a8a\7\u00fa\2\2\u0a83\u0a84\7%\2\2\u0a84\u0a8a\7\u00fa")
>
> +
> buf.write("\2\2\u0a85\u0a86\7&\2\2\u0a86\u0a8a\7\u00fa\2\2\u0a87")
>
> + buf.write("\u0a88\7\'\2\2\u0a88\u0a8a\7\u00fa\2\2\u0a89\u0a7f\3\2")
>
> +
> buf.write("\2\2\u0a89\u0a81\3\2\2\2\u0a89\u0a83\3\2\2\2\u0a89\u0a85")
>
> +
> buf.write("\3\2\2\2\u0a89\u0a87\3\2\2\2\u0a8a\u0155\3\2\2\2\u0a8b")
>
> +
> buf.write("\u0a8c\7\u00ca\2\2\u0a8c\u0a97\5\u015c\u00af\2\u0a8d\u0a8e"
> )
>
> +
> buf.write("\7\"\2\2\u0a8e\u0a98\7\u00fa\2\2\u0a8f\u0a90\7$\2\2\u0a90")
>
> +
> buf.write("\u0a98\7\u00fa\2\2\u0a91\u0a92\7%\2\2\u0a92\u0a98\7\u00fa")
>
> +
> buf.write("\2\2\u0a93\u0a94\7&\2\2\u0a94\u0a98\7\u00fa\2\2\u0a95")
>
> +
> buf.write("\u0a96\7\'\2\2\u0a96\u0a98\7\u00fa\2\2\u0a97\u0a8d\3\2")
>
> +
> buf.write("\2\2\u0a97\u0a8f\3\2\2\2\u0a97\u0a91\3\2\2\2\u0a97\u0a93")
>
> +
> buf.write("\3\2\2\2\u0a97\u0a95\3\2\2\2\u0a98\u0157\3\2\2\2\u0a99")
>
> +
> buf.write("\u0a9a\7\u00cb\2\2\u0a9a\u0aa5\5\u015c\u00af\2\u0a9b\u0a9c"
> )
>
> + buf.write("\7\"\2\2\u0a9c\u0aa6\5\u015c\u00af\2\u0a9d\u0a9e\7$\2")
>
> +
> buf.write("\2\u0a9e\u0aa6\5\u015c\u00af\2\u0a9f\u0aa0\7%\2\2\u0aa0")
>
> +
> buf.write("\u0aa6\5\u015c\u00af\2\u0aa1\u0aa2\7&\2\2\u0aa2\u0aa6")
>
> +
> buf.write("\5\u015c\u00af\2\u0aa3\u0aa4\7\'\2\2\u0aa4\u0aa6\5\u015c")
>
> +
> buf.write("\u00af\2\u0aa5\u0a9b\3\2\2\2\u0aa5\u0a9d\3\2\2\2\u0aa5")
>
> +
> buf.write("\u0a9f\3\2\2\2\u0aa5\u0aa1\3\2\2\2\u0aa5\u0aa3\3\2\2\2")
>
> +
> buf.write("\u0aa6\u0159\3\2\2\2\u0aa7\u0aa8\7\u00cc\2\2\u0aa8\u0aa9")
>
> +
> buf.write("\5\u015c\u00af\2\u0aa9\u0aab\7\"\2\2\u0aaa\u0aac\7\u00fa")
>
> +
> buf.write("\2\2\u0aab\u0aaa\3\2\2\2\u0aac\u0aad\3\2\2\2\u0aad\u0aab")
>
> +
> buf.write("\3\2\2\2\u0aad\u0aae\3\2\2\2\u0aae\u015b\3\2\2\2\u0aaf")
>
> +
> buf.write("\u0ab0\7\u00fb\2\2\u0ab0\u0ab1\7\32\2\2\u0ab1\u0ab2\7")
>
> + buf.write("\u00fa\2\2\u0ab2\u0abc\7\33\2\2\u0ab3\u0ab8\7\u00fb\2")
>
> +
> buf.write("\2\u0ab4\u0ab5\7\34\2\2\u0ab5\u0ab7\5\u015e\u00b0\2\u0ab6"
> )
>
> +
> buf.write("\u0ab4\3\2\2\2\u0ab7\u0aba\3\2\2\2\u0ab8\u0ab6\3\2\2\2")
>
> +
> buf.write("\u0ab8\u0ab9\3\2\2\2\u0ab9\u0abc\3\2\2\2\u0aba\u0ab8\3")
>
> +
> buf.write("\2\2\2\u0abb\u0aaf\3\2\2\2\u0abb\u0ab3\3\2\2\2\u0abc\u015d"
> )
>
> + buf.write("\3\2\2\2\u0abd\u0ac1\7\u00fb\2\2\u0abe\u0abf\7\32\2\2")
>
> +
> buf.write("\u0abf\u0ac0\7\u00fa\2\2\u0ac0\u0ac2\7\33\2\2\u0ac1\u0abe")
>
> + buf.write("\3\2\2\2\u0ac1\u0ac2\3\2\2\2\u0ac2\u015f\3\2\2\2\u0ac3")
>
> + buf.write("\u0ac4\7\u00cd\2\2\u0ac4\u0ac5\7\30\2\2\u0ac5\u0ac6\t")
>
> +
> buf.write("\13\2\2\u0ac6\u0ac7\7\31\2\2\u0ac7\u0161\3\2\2\2\u0ac8")
>
> + buf.write("\u0ac9\7\u00ce\2\2\u0ac9\u0aca\7\30\2\2\u0aca\u0acb\7")
>
> +
> buf.write("\u00fb\2\2\u0acb\u0acc\7\31\2\2\u0acc\u0163\3\2\2\2\u0acd")
>
> + buf.write("\u0ace\7\u00cf\2\2\u0ace\u0ad4\7\30\2\2\u0acf\u0ad0\7")
>
> +
> buf.write("\u00ec\2\2\u0ad0\u0ad1\7\30\2\2\u0ad1\u0ad2\7\u00fa\2")
>
> +
> buf.write("\2\u0ad2\u0ad5\7\31\2\2\u0ad3\u0ad5\7\u00fa\2\2\u0ad4")
>
> +
> buf.write("\u0acf\3\2\2\2\u0ad4\u0ad3\3\2\2\2\u0ad5\u0ad6\3\2\2\2")
>
> +
> buf.write("\u0ad6\u0ad7\7\31\2\2\u0ad7\u0165\3\2\2\2\u0ad8\u0ad9")
>
> +
> buf.write("\7\u00d0\2\2\u0ad9\u0167\3\2\2\2\u0ada\u0adb\7\u00d1\2")
>
> +
> buf.write("\2\u0adb\u0adc\7\30\2\2\u0adc\u0add\5L\'\2\u0add\u0ade")
>
> +
> buf.write("\7\31\2\2\u0ade\u0169\3\2\2\2\u0adf\u0ae0\t\f\2\2\u0ae0")
>
> +
> buf.write("\u016b\3\2\2\2\u0ae1\u0ae2\7\u00d2\2\2\u0ae2\u0ae3\7\30")
>
> + buf.write("\2\2\u0ae3\u0ae8\5X-
> \2\u0ae4\u0ae5\7(\2\2\u0ae5\u0ae6")
>
> +
> buf.write("\7@\2\2\u0ae6\u0ae7\7\b\2\2\u0ae7\u0ae9\5\u016a\u00b6")
>
> +
> buf.write("\2\u0ae8\u0ae4\3\2\2\2\u0ae8\u0ae9\3\2\2\2\u0ae9\u0aea")
>
> +
> buf.write("\3\2\2\2\u0aea\u0aeb\7\31\2\2\u0aeb\u016d\3\2\2\2\u0aec")
>
> + buf.write("\u0aed\t\r\2\2\u0aed\u016f\3\2\2\2\u0aee\u0af9\5\u0172")
>
> +
> buf.write("\u00ba\2\u0aef\u0af9\5\u0174\u00bb\2\u0af0\u0af9\5\u0176")
>
> +
> buf.write("\u00bc\2\u0af1\u0af9\5\u0178\u00bd\2\u0af2\u0af9\5\u017a")
>
> +
> buf.write("\u00be\2\u0af3\u0af9\5\u017c\u00bf\2\u0af4\u0af9\5\u017e")
>
> +
> buf.write("\u00c0\2\u0af5\u0af9\5\u0180\u00c1\2\u0af6\u0af9\5\u0182")
>
> +
> buf.write("\u00c2\2\u0af7\u0af9\5\u0184\u00c3\2\u0af8\u0aee\3\2\2")
>
> + buf.write("\2\u0af8\u0aef\3\2\2\2\u0af8\u0af0\3\2\2\2\u0af8\u0af1")
>
> + buf.write("\3\2\2\2\u0af8\u0af2\3\2\2\2\u0af8\u0af3\3\2\2\2\u0af8")
>
> + buf.write("\u0af4\3\2\2\2\u0af8\u0af5\3\2\2\2\u0af8\u0af6\3\2\2\2")
>
> + buf.write("\u0af8\u0af7\3\2\2\2\u0af9\u0171\3\2\2\2\u0afa\u0afb\7")
>
> +
> buf.write("\u00da\2\2\u0afb\u0afc\7\30\2\2\u0afc\u0afd\5\u0126\u0094")
>
> + buf.write("\2\u0afd\u0afe\7\31\2\2\u0afe\u0173\3\2\2\2\u0aff\u0b00")
>
> +
> buf.write("\7\u00df\2\2\u0b00\u0b01\7\30\2\2\u0b01\u0b02\5\u0126")
>
> +
> buf.write("\u0094\2\u0b02\u0b03\7\31\2\2\u0b03\u0175\3\2\2\2\u0b04")
>
> +
> buf.write("\u0b05\7\u00e8\2\2\u0b05\u0b0d\7\30\2\2\u0b06\u0b07\7")
>
> +
> buf.write("*\2\2\u0b07\u0b08\7\b\2\2\u0b08\u0b09\7\u00ec\2\2\u0b09")
>
> +
> buf.write("\u0b0a\7\30\2\2\u0b0a\u0b0b\7\u00fa\2\2\u0b0b\u0b0c\7")
>
> +
> buf.write("\31\2\2\u0b0c\u0b0e\7!\2\2\u0b0d\u0b06\3\2\2\2\u0b0d\u0b0e"
> )
>
> + buf.write("\3\2\2\2\u0b0e\u0b14\3\2\2\2\u0b0f\u0b10\7[\2\2\u0b10")
>
> +
> buf.write("\u0b11\7\b\2\2\u0b11\u0b12\5L\'\2\u0b12\u0b13\7!\2\2\u0b13")
>
> +
> buf.write("\u0b15\3\2\2\2\u0b14\u0b0f\3\2\2\2\u0b14\u0b15\3\2\2\2")
>
> +
> buf.write("\u0b15\u0b16\3\2\2\2\u0b16\u0b17\5\u0126\u0094\2\u0b17")
>
> +
> buf.write("\u0b18\7\31\2\2\u0b18\u0177\3\2\2\2\u0b19\u0b1a\7\u00e9")
>
> +
> buf.write("\2\2\u0b1a\u0b1b\7\30\2\2\u0b1b\u0b1c\5\u0126\u0094\2")
>
> +
> buf.write("\u0b1c\u0b1d\7\31\2\2\u0b1d\u0179\3\2\2\2\u0b1e\u0b1f")
>
> +
> buf.write("\7\u00e0\2\2\u0b1f\u0b20\7\30\2\2\u0b20\u0b21\5\u0126")
>
> +
> buf.write("\u0094\2\u0b21\u0b22\7\31\2\2\u0b22\u017b\3\2\2\2\u0b23")
>
> +
> buf.write("\u0b28\7\u00e1\2\2\u0b24\u0b25\7\21\2\2\u0b25\u0b26\7")
>
> +
> buf.write("\b\2\2\u0b26\u0b27\7\u00fa\2\2\u0b27\u0b29\7!\2\2\u0b28")
>
> +
> buf.write("\u0b24\3\2\2\2\u0b28\u0b29\3\2\2\2\u0b29\u0b2a\3\2\2\2")
>
> +
> buf.write("\u0b2a\u0b2b\7\30\2\2\u0b2b\u0b2c\5\u0126\u0094\2\u0b2c")
>
> +
> buf.write("\u0b2d\7\31\2\2\u0b2d\u017d\3\2\2\2\u0b2e\u0b2f\7\u00e2")
>
> +
> buf.write("\2\2\u0b2f\u0b30\7\30\2\2\u0b30\u0b31\5\u0126\u0094\2")
>
> +
> buf.write("\u0b31\u0b32\7\31\2\2\u0b32\u017f\3\2\2\2\u0b33\u0b34")
>
> +
> buf.write("\7\u00e3\2\2\u0b34\u0b35\7\30\2\2\u0b35\u0b36\5\u0126")
>
> +
> buf.write("\u0094\2\u0b36\u0b37\7\31\2\2\u0b37\u0181\3\2\2\2\u0b38")
>
> +
> buf.write("\u0b39\7\u00e4\2\2\u0b39\u0b3a\7\30\2\2\u0b3a\u0b3b\5")
>
> +
> buf.write("\u0126\u0094\2\u0b3b\u0b3c\7\31\2\2\u0b3c\u0183\3\2\2")
>
> +
> buf.write("\2\u0b3d\u0b3e\7\u00de\2\2\u0b3e\u0b3f\7\30\2\2\u0b3f")
>
> + buf.write("\u0b44\5X-
> \2\u0b40\u0b41\7(\2\2\u0b41\u0b42\7@\2\2\u0b42")
>
> +
> buf.write("\u0b43\7\b\2\2\u0b43\u0b45\5\u016a\u00b6\2\u0b44\u0b40")
>
> +
> buf.write("\3\2\2\2\u0b44\u0b45\3\2\2\2\u0b45\u0b46\3\2\2\2\u0b46")
>
> +
> buf.write("\u0b47\7!\2\2\u0b47\u0b48\5\u0126\u0094\2\u0b48\u0b49")
>
> +
> buf.write("\7\31\2\2\u0b49\u0185\3\2\2\2\u0b4a\u0b50\5\u0188\u00c5")
>
> +
> buf.write("\2\u0b4b\u0b50\5\u018a\u00c6\2\u0b4c\u0b50\5\u018e\u00c8")
>
> +
> buf.write("\2\u0b4d\u0b50\5\u0190\u00c9\2\u0b4e\u0b50\5\u0192\u00ca")
>
> +
> buf.write("\2\u0b4f\u0b4a\3\2\2\2\u0b4f\u0b4b\3\2\2\2\u0b4f\u0b4c")
>
> +
> buf.write("\3\2\2\2\u0b4f\u0b4d\3\2\2\2\u0b4f\u0b4e\3\2\2\2\u0b50")
>
> +
> buf.write("\u0187\3\2\2\2\u0b51\u0b52\7\u00c2\2\2\u0b52\u0b53\7\30")
>
> +
> buf.write("\2\2\u0b53\u0b54\5\u0126\u0094\2\u0b54\u0b55\7\22\2\2")
>
> +
> buf.write("\u0b55\u0b56\5\u0126\u0094\2\u0b56\u0b57\7\36\2\2\u0b57")
>
> +
> buf.write("\u0b58\5\u0126\u0094\2\u0b58\u0b59\7\31\2\2\u0b59\u0189")
>
> +
> buf.write("\3\2\2\2\u0b5a\u0b5b\7\u00c3\2\2\u0b5b\u0b5c\7\30\2\2")
>
> +
> buf.write("\u0b5c\u0b61\5\u018c\u00c7\2\u0b5d\u0b5e\7(\2\2\u0b5e")
>
> +
> buf.write("\u0b60\5\u018c\u00c7\2\u0b5f\u0b5d\3\2\2\2\u0b60\u0b63")
>
> +
> buf.write("\3\2\2\2\u0b61\u0b5f\3\2\2\2\u0b61\u0b62\3\2\2\2\u0b62")
>
> + buf.write("\u0b64\3\2\2\2\u0b63\u0b61\3\2\2\2\u0b64\u0b65\7!\2\2")
>
> +
> buf.write("\u0b65\u0b66\5\u0126\u0094\2\u0b66\u0b67\7!\2\2\u0b67")
>
> +
> buf.write("\u0b68\5\u0126\u0094\2\u0b68\u0b69\7!\2\2\u0b69\u0b6a")
>
> +
> buf.write("\5\u0126\u0094\2\u0b6a\u0b6b\7\31\2\2\u0b6b\u018b\3\2")
>
> +
> buf.write("\2\2\u0b6c\u0b6d\t\16\2\2\u0b6d\u018d\3\2\2\2\u0b6e\u0b6f")
>
> +
> buf.write("\7\u00c4\2\2\u0b6f\u0b70\7\30\2\2\u0b70\u0b71\5\u0126")
>
> +
> buf.write("\u0094\2\u0b71\u0b72\7!\2\2\u0b72\u0b73\5\u0126\u0094")
>
> +
> buf.write("\2\u0b73\u0b74\7!\2\2\u0b74\u0b75\5\u0126\u0094\2\u0b75")
>
> +
> buf.write("\u0b76\7\31\2\2\u0b76\u018f\3\2\2\2\u0b77\u0b78\7\u00c5")
>
> +
> buf.write("\2\2\u0b78\u0b79\7\30\2\2\u0b79\u0b7a\5\u0126\u0094\2")
>
> +
> buf.write("\u0b7a\u0b7b\7!\2\2\u0b7b\u0b7c\5\u0126\u0094\2\u0b7c")
>
> +
> buf.write("\u0b7d\7!\2\2\u0b7d\u0b7e\5\u0126\u0094\2\u0b7e\u0b7f")
>
> + buf.write("\7\31\2\2\u0b7f\u0191\3\2\2\2\u0b80\u0b81\7\u00c6\2\2")
>
> +
> buf.write("\u0b81\u0b82\7\30\2\2\u0b82\u0b83\7@\2\2\u0b83\u0b84\7")
>
> +
> buf.write("\b\2\2\u0b84\u0b89\5\u0194\u00cb\2\u0b85\u0b86\7(\2\2")
>
> +
> buf.write("\u0b86\u0b88\5\u0194\u00cb\2\u0b87\u0b85\3\2\2\2\u0b88")
>
> +
> buf.write("\u0b8b\3\2\2\2\u0b89\u0b87\3\2\2\2\u0b89\u0b8a\3\2\2\2")
>
> +
> buf.write("\u0b8a\u0b8c\3\2\2\2\u0b8b\u0b89\3\2\2\2\u0b8c\u0b8d\7")
>
> +
> buf.write("!\2\2\u0b8d\u0b8e\5\u0126\u0094\2\u0b8e\u0b8f\7!\2\2\u0b8f"
> )
>
> +
> buf.write("\u0b90\5\u0126\u0094\2\u0b90\u0b91\7!\2\2\u0b91\u0b92")
>
> +
> buf.write("\5\u0126\u0094\2\u0b92\u0b93\7\31\2\2\u0b93\u0193\3\2")
>
> +
> buf.write("\2\2\u0b94\u0b95\t\17\2\2\u0b95\u0195\3\2\2\2\u0b96\u0b97")
>
> +
> buf.write("\7\u00ea\2\2\u0b97\u0b98\7\30\2\2\u0b98\u0b99\5\u0126")
>
> +
> buf.write("\u0094\2\u0b99\u0ba1\7\36\2\2\u0b9a\u0b9b\5\u0124\u0093")
>
> +
> buf.write("\2\u0b9b\u0b9c\7!\2\2\u0b9c\u0b9d\5\u0124\u0093\2\u0b9d")
>
> + buf.write("\u0b9e\7 \2\2\u0b9e\u0ba0\3\2\2\2\u0b9f\u0b9a\3\2\2\2")
>
> +
> buf.write("\u0ba0\u0ba3\3\2\2\2\u0ba1\u0b9f\3\2\2\2\u0ba1\u0ba2\3")
>
> +
> buf.write("\2\2\2\u0ba2\u0ba4\3\2\2\2\u0ba3\u0ba1\3\2\2\2\u0ba4\u0ba5"
> )
>
> +
> buf.write("\7\31\2\2\u0ba5\u0197\3\2\2\2\u00f1\u019b\u019d\u01a1")
>
> +
> buf.write("\u01a8\u01ac\u01af\u01b7\u01bc\u01c0\u01c3\u01c9\u01ce")
>
> +
> buf.write("\u01d2\u01d5\u01db\u01ed\u01ef\u01f7\u0200\u0209\u0212")
>
> +
> buf.write("\u021b\u0224\u022d\u0236\u023f\u0248\u024e\u0256\u025e")
>
> +
> buf.write("\u0266\u0284\u028b\u0292\u029b\u029f\u02a3\u02aa\u02b4")
>
> +
> buf.write("\u02c1\u02d0\u02e5\u02eb\u0307\u030d\u0316\u0329\u0339")
>
> +
> buf.write("\u0344\u0375\u0385\u038c\u0392\u03aa\u03b5\u03b8\u03bb")
>
> +
> buf.write("\u03e2\u03e6\u03f3\u03fa\u040c\u0421\u0436\u043c\u0452")
>
> +
> buf.write("\u045f\u0463\u0468\u046e\u0471\u0475\u0479\u0480\u049a")
>
> +
> buf.write("\u04a4\u04ac\u04b0\u04b6\u04ba\u04e8\u04ec\u04f3\u04f9")
>
> +
> buf.write("\u04fd\u0506\u050b\u0517\u0522\u052f\u0540\u0545\u054a")
>
> +
> buf.write("\u055b\u0560\u0565\u056d\u058d\u0592\u0597\u05a1\u05ab")
>
> +
> buf.write("\u05b7\u05bc\u05c1\u05cd\u05d2\u05d7\u05e1\u05e7\u0602")
>
> +
> buf.write("\u0608\u0612\u0620\u062d\u0632\u0636\u0641\u0647\u0652")
>
> +
> buf.write("\u065b\u0665\u0677\u067c\u0680\u068b\u0691\u069b\u06a2")
>
> +
> buf.write("\u06aa\u06b1\u06bd\u06c8\u06cb\u06d6\u06db\u06e5\u06eb")
>
> +
> buf.write("\u06fe\u0704\u070e\u0714\u0722\u072d\u0732\u073b\u0742")
>
> +
> buf.write("\u074d\u0754\u075e\u07a9\u07ae\u07b1\u07c2\u07c8\u07cf")
>
> +
> buf.write("\u07dc\u0827\u082c\u082f\u0840\u0846\u084d\u0856\u0867")
>
> +
> buf.write("\u086d\u0875\u0883\u0888\u0895\u089a\u08a7\u08ac\u08b3")
>
> +
> buf.write("\u08c1\u08c6\u08cd\u08e2\u08e7\u08f0\u0911\u0931\u0934")
>
> +
> buf.write("\u093a\u0944\u0957\u0964\u096a\u0970\u0976\u097c\u0982")
>
> +
> buf.write("\u0988\u098e\u0994\u099a\u099c\u09a1\u09a4\u09aa\u09ae")
>
> +
> buf.write("\u09b7\u09bd\u09cd\u09d5\u09dd\u09e5\u09ed\u09f4\u09fb")
>
> +
> buf.write("\u0a01\u0a0c\u0a12\u0a19\u0a1f\u0a26\u0a2c\u0a35\u0a3a")
>
> +
> buf.write("\u0a4e\u0a76\u0a89\u0a97\u0aa5\u0aad\u0ab8\u0abb\u0ac1")
>
> +
> buf.write("\u0ad4\u0ae8\u0af8\u0b0d\u0b14\u0b28\u0b44\u0b4f\u0b61")
>
> + buf.write("\u0b89\u0ba1")
>
> return buf.getvalue()
>
>
>
>
>
> @@ -1871,47 +1874,48 @@ class VfrSyntaxParser ( Parser ):
> 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
>
> + RULE_castTermSub = 161
>
> + RULE_atomTerm = 162
>
> + RULE_vfrExpressionCatenate = 163
>
> + RULE_vfrExpressionMatch = 164
>
> + RULE_vfrExpressionMatch2 = 165
>
> + RULE_vfrExpressionParen = 166
>
> + RULE_vfrExpressionBuildInFunction = 167
>
> + RULE_dupExp = 168
>
> + RULE_vareqvalExp = 169
>
> + RULE_ideqvalExp = 170
>
> + RULE_ideqidExp = 171
>
> + RULE_ideqvallistExp = 172
>
> + RULE_vfrQuestionDataFieldName = 173
>
> + RULE_arrayName = 174
>
> + RULE_questionref1Exp = 175
>
> + RULE_rulerefExp = 176
>
> + RULE_stringref1Exp = 177
>
> + RULE_pushthisExp = 178
>
> + RULE_securityExp = 179
>
> + RULE_numericVarStoreType = 180
>
> + RULE_getExp = 181
>
> + RULE_vfrExpressionConstant = 182
>
> + RULE_vfrExpressionUnaryOp = 183
>
> + RULE_lengthExp = 184
>
> + RULE_bitwisenotExp = 185
>
> + RULE_question23refExp = 186
>
> + RULE_stringref2Exp = 187
>
> + RULE_toboolExp = 188
>
> + RULE_tostringExp = 189
>
> + RULE_unintExp = 190
>
> + RULE_toupperExp = 191
>
> + RULE_tolwerExp = 192
>
> + RULE_setExp = 193
>
> + RULE_vfrExpressionTernaryOp = 194
>
> + RULE_conditionalExp = 195
>
> + RULE_findExp = 196
>
> + RULE_findFormat = 197
>
> + RULE_midExp = 198
>
> + RULE_tokenExp = 199
>
> + RULE_spanExp = 200
>
> + RULE_spanFlags = 201
>
> + RULE_vfrExpressionMap = 202
>
>
>
> ruleNames = [ "vfrProgram", "pragmaPackShowDef",
> "pragmaPackStackDef",
>
> "pragmaPackNumber", "vfrPragmaPackDefinition",
> "vfrDataStructDefinition",
>
> @@ -1972,7 +1976,7 @@ class VfrSyntaxParser ( Parser ):
> "compareTerm", "compareTermSupplementary", "shiftTerm",
>
> "shiftTermSupplementary", "addMinusTerm",
> "addMinusTermSupplementary",
>
> "multdivmodTerm", "multdivmodTermSupplementary",
> "castTerm",
>
> - "atomTerm", "vfrExpressionCatenate", "vfrExpressionMatch",
>
> + "castTermSub", "atomTerm", "vfrExpressionCatenate",
> "vfrExpressionMatch",
>
> "vfrExpressionMatch2", "vfrExpressionParen",
> "vfrExpressionBuildInFunction",
>
> "dupExp", "vareqvalExp", "ideqvalExp", "ideqidExp",
> "ideqvallistExp",
>
> "vfrQuestionDataFieldName", "arrayName", "questionref1Exp",
>
> @@ -2257,10 +2261,6 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> @@ -2282,6 +2282,10 @@ class VfrSyntaxParser ( Parser ):
> return
> self.getTypedRuleContext(VfrSyntaxParser.VfrDataUnionDefinitionContext,i)
>
>
>
>
>
> + def vfrFormSetDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetDefinitionContext,0)
>
> +
>
> +
>
> def getRuleIndex(self):
>
> return VfrSyntaxParser.RULE_vfrProgram
>
>
>
> @@ -2301,35 +2305,41 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 409
>
> + self.state = 411
>
> 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.state = 409
>
> self._errHandler.sync(self)
>
> la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
>
> if la_ == 1:
>
> - self.state = 404
>
> + self.state = 406
>
> self.vfrPragmaPackDefinition()
>
> pass
>
>
>
> elif la_ == 2:
>
> - self.state = 405
>
> + self.state = 407
>
> self.vfrDataStructDefinition()
>
> pass
>
>
>
> elif la_ == 3:
>
> - self.state = 406
>
> + self.state = 408
>
> self.vfrDataUnionDefinition()
>
> pass
>
>
>
>
>
> - self.state = 411
>
> + self.state = 413
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 412
>
> - self.vfrFormSetDefinition()
>
> + self.state = 415
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FormSet:
>
> + self.state = 414
>
> + self.vfrFormSetDefinition()
>
> +
>
> +
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> self._errHandler.reportError(self, re)
>
> @@ -2364,7 +2374,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 2, self.RULE_pragmaPackShowDef)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 414
>
> + self.state = 417
>
> self.match(VfrSyntaxParser.T__0)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -2412,30 +2422,30 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 416
>
> + self.state = 419
>
> _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.state = 422
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
>
> if la_ == 1:
>
> - self.state = 417
>
> + self.state = 420
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 418
>
> + self.state = 421
>
> self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 423
>
> + self.state = 426
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 421
>
> + self.state = 424
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 422
>
> + self.state = 425
>
> self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> @@ -2476,11 +2486,11 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 426
>
> + self.state = 429
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Number:
>
> - self.state = 425
>
> + self.state = 428
>
> self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> @@ -2535,29 +2545,29 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 8, self.RULE_vfrPragmaPackDefinition)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 428
>
> + self.state = 431
>
> self.match(VfrSyntaxParser.T__3)
>
> - self.state = 429
>
> + self.state = 432
>
> self.match(VfrSyntaxParser.T__4)
>
> - self.state = 430
>
> + self.state = 433
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 434
>
> + self.state = 437
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
>
> if la_ == 1:
>
> - self.state = 431
>
> + self.state = 434
>
> self.pragmaPackShowDef()
>
>
>
> elif la_ == 2:
>
> - self.state = 432
>
> + self.state = 435
>
> self.pragmaPackStackDef()
>
>
>
> elif la_ == 3:
>
> - self.state = 433
>
> + self.state = 436
>
> self.pragmaPackNumber()
>
>
>
>
>
> - self.state = 436
>
> + self.state = 439
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -2623,47 +2633,47 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 439
>
> + self.state = 442
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.TypeDef:
>
> - self.state = 438
>
> + self.state = 441
>
> self.match(VfrSyntaxParser.TypeDef)
>
>
>
>
>
> - self.state = 441
>
> + self.state = 444
>
> self.match(VfrSyntaxParser.Struct)
>
> - self.state = 443
>
> + self.state = 446
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.NonNvDataMap:
>
> - self.state = 442
>
> + self.state = 445
>
> self.match(VfrSyntaxParser.NonNvDataMap)
>
>
>
>
>
> - self.state = 446
>
> + self.state = 449
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 445
>
> + self.state = 448
>
> localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 448
>
> + self.state = 451
>
> self.match(VfrSyntaxParser.OpenBrace)
>
> - self.state = 449
>
> + self.state = 452
>
> self.vfrDataStructFields(False)
>
> - self.state = 450
>
> + self.state = 453
>
> self.match(VfrSyntaxParser.CloseBrace)
>
> - self.state = 452
>
> + self.state = 455
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 451
>
> + self.state = 454
>
> localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 454
>
> + self.state = 457
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -2729,47 +2739,47 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 457
>
> + self.state = 460
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.TypeDef:
>
> - self.state = 456
>
> + self.state = 459
>
> self.match(VfrSyntaxParser.TypeDef)
>
>
>
>
>
> - self.state = 459
>
> + self.state = 462
>
> self.match(VfrSyntaxParser.Union)
>
> - self.state = 461
>
> + self.state = 464
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.NonNvDataMap:
>
> - self.state = 460
>
> + self.state = 463
>
> self.match(VfrSyntaxParser.NonNvDataMap)
>
>
>
>
>
> - self.state = 464
>
> + self.state = 467
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 463
>
> + self.state = 466
>
> localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 466
>
> + self.state = 469
>
> self.match(VfrSyntaxParser.OpenBrace)
>
> - self.state = 467
>
> + self.state = 470
>
> self.vfrDataStructFields(True)
>
> - self.state = 468
>
> + self.state = 471
>
> self.match(VfrSyntaxParser.CloseBrace)
>
> - self.state = 470
>
> + self.state = 473
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 469
>
> + self.state = 472
>
> localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 472
>
> + self.state = 475
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -2905,85 +2915,85 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 490
>
> + self.state = 493
>
> 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.state = 491
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
>
> if la_ == 1:
>
> - self.state = 474
>
> + self.state = 477
>
> self.dataStructField64(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 2:
>
> - self.state = 475
>
> + self.state = 478
>
> self.dataStructField32(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 3:
>
> - self.state = 476
>
> + self.state = 479
>
> self.dataStructField16(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 4:
>
> - self.state = 477
>
> + self.state = 480
>
> self.dataStructField8(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 5:
>
> - self.state = 478
>
> + self.state = 481
>
> self.dataStructFieldBool(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 6:
>
> - self.state = 479
>
> + self.state = 482
>
> self.dataStructFieldString(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 7:
>
> - self.state = 480
>
> + self.state = 483
>
> self.dataStructFieldDate(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 8:
>
> - self.state = 481
>
> + self.state = 484
>
> self.dataStructFieldTime(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 9:
>
> - self.state = 482
>
> + self.state = 485
>
> self.dataStructFieldRef(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 10:
>
> - self.state = 483
>
> + self.state = 486
>
> self.dataStructFieldUser(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 11:
>
> - self.state = 484
>
> + self.state = 487
>
> self.dataStructBitField64(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 12:
>
> - self.state = 485
>
> + self.state = 488
>
> self.dataStructBitField32(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 13:
>
> - self.state = 486
>
> + self.state = 489
>
> self.dataStructBitField16(FieldInUnion)
>
> pass
>
>
>
> elif la_ == 14:
>
> - self.state = 487
>
> + self.state = 490
>
> self.dataStructBitField8(FieldInUnion)
>
> pass
>
>
>
>
>
> - self.state = 492
>
> + self.state = 495
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -3042,23 +3052,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 493
>
> + self.state = 496
>
> self.match(VfrSyntaxParser.Uint64)
>
> - self.state = 494
>
> + self.state = 497
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 498
>
> + self.state = 501
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 495
>
> + self.state = 498
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 496
>
> + self.state = 499
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 497
>
> + self.state = 500
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 500
>
> + self.state = 503
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3115,23 +3125,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 502
>
> + self.state = 505
>
> self.match(VfrSyntaxParser.Uint32)
>
> - self.state = 503
>
> + self.state = 506
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 507
>
> + self.state = 510
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 504
>
> + self.state = 507
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 505
>
> + self.state = 508
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 506
>
> + self.state = 509
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 509
>
> + self.state = 512
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3188,23 +3198,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 511
>
> + self.state = 514
>
> self.match(VfrSyntaxParser.Uint16)
>
> - self.state = 512
>
> + self.state = 515
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 516
>
> + self.state = 519
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 513
>
> + self.state = 516
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 514
>
> + self.state = 517
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 515
>
> + self.state = 518
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 518
>
> + self.state = 521
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3261,23 +3271,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 520
>
> + self.state = 523
>
> self.match(VfrSyntaxParser.Uint8)
>
> - self.state = 521
>
> + self.state = 524
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 525
>
> + self.state = 528
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 522
>
> + self.state = 525
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 523
>
> + self.state = 526
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 524
>
> + self.state = 527
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 527
>
> + self.state = 530
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3334,23 +3344,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 529
>
> + self.state = 532
>
> self.match(VfrSyntaxParser.Boolean)
>
> - self.state = 530
>
> + self.state = 533
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 534
>
> + self.state = 537
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 531
>
> + self.state = 534
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 532
>
> + self.state = 535
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 533
>
> + self.state = 536
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 536
>
> + self.state = 539
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3407,23 +3417,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 538
>
> + self.state = 541
>
> self.match(VfrSyntaxParser.EFI_STRING_ID)
>
> - self.state = 539
>
> + self.state = 542
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 543
>
> + self.state = 546
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 540
>
> + self.state = 543
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 541
>
> + self.state = 544
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 542
>
> + self.state = 545
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 545
>
> + self.state = 548
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3480,23 +3490,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 547
>
> + self.state = 550
>
> self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> - self.state = 548
>
> + self.state = 551
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 552
>
> + self.state = 555
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 549
>
> + self.state = 552
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 550
>
> + self.state = 553
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 551
>
> + self.state = 554
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 554
>
> + self.state = 557
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3553,23 +3563,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 556
>
> + self.state = 559
>
> self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> - self.state = 557
>
> + self.state = 560
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 561
>
> + self.state = 564
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 558
>
> + self.state = 561
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 559
>
> + self.state = 562
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 560
>
> + self.state = 563
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 563
>
> + self.state = 566
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3626,23 +3636,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 565
>
> + self.state = 568
>
> self.match(VfrSyntaxParser.EFI_HII_REF)
>
> - self.state = 566
>
> + self.state = 569
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 570
>
> + self.state = 573
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 567
>
> + self.state = 570
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 568
>
> + self.state = 571
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 569
>
> + self.state = 572
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 572
>
> + self.state = 575
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3700,23 +3710,23 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 574
>
> + self.state = 577
>
> localctx.T = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 575
>
> + self.state = 578
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 579
>
> + self.state = 582
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 576
>
> + self.state = 579
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 577
>
> + self.state = 580
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 578
>
> + self.state = 581
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 581
>
> + self.state = 584
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3771,21 +3781,21 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 583
>
> + self.state = 586
>
> localctx.D = self.match(VfrSyntaxParser.Uint64)
>
> - self.state = 585
>
> + self.state = 588
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 584
>
> + self.state = 587
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 587
>
> + self.state = 590
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 588
>
> + self.state = 591
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 589
>
> + self.state = 592
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3840,21 +3850,21 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 591
>
> + self.state = 594
>
> localctx.D = self.match(VfrSyntaxParser.Uint32)
>
> - self.state = 593
>
> + self.state = 596
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 592
>
> + self.state = 595
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 595
>
> + self.state = 598
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 596
>
> + self.state = 599
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 597
>
> + self.state = 600
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3909,21 +3919,21 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 599
>
> + self.state = 602
>
> localctx.D = self.match(VfrSyntaxParser.Uint16)
>
> - self.state = 601
>
> + self.state = 604
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 600
>
> + self.state = 603
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 603
>
> + self.state = 606
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 604
>
> + self.state = 607
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 605
>
> + self.state = 608
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -3978,21 +3988,21 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 607
>
> + self.state = 610
>
> localctx.D = self.match(VfrSyntaxParser.Uint8)
>
> - self.state = 609
>
> + self.state = 612
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.StringIdentifier:
>
> - self.state = 608
>
> + self.state = 611
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
>
>
>
>
> - self.state = 611
>
> + self.state = 614
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 612
>
> + self.state = 615
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 613
>
> + self.state = 616
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -4008,7 +4018,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_FORM_SET_OP)
>
>
>
> def FormSet(self):
>
> return self.getToken(VfrSyntaxParser.FormSet, 0)
>
> @@ -4106,91 +4116,91 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 615
>
> + self.state = 618
>
> self.match(VfrSyntaxParser.FormSet)
>
> - self.state = 616
>
> + self.state = 619
>
> self.match(VfrSyntaxParser.Uuid)
>
> - self.state = 617
>
> + self.state = 620
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 618
>
> + self.state = 621
>
> self.guidDefinition()
>
> - self.state = 619
>
> + self.state = 622
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 620
>
> + self.state = 623
>
> self.match(VfrSyntaxParser.Title)
>
> - self.state = 621
>
> + self.state = 624
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 622
>
> + self.state = 625
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 623
>
> + self.state = 626
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 624
>
> + self.state = 627
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 625
>
> + self.state = 628
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 626
>
> + self.state = 629
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 627
>
> + self.state = 630
>
> self.match(VfrSyntaxParser.Help)
>
> - self.state = 628
>
> + self.state = 631
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 629
>
> + self.state = 632
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 630
>
> + self.state = 633
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 631
>
> + self.state = 634
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 632
>
> + self.state = 635
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 633
>
> + self.state = 636
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 639
>
> + self.state = 642
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.ClassGuid:
>
> - self.state = 634
>
> + self.state = 637
>
> self.match(VfrSyntaxParser.ClassGuid)
>
> - self.state = 635
>
> + self.state = 638
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 636
>
> + self.state = 639
>
> self.classguidDefinition(localctx.Node)
>
> - self.state = 637
>
> + self.state = 640
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 646
>
> + self.state = 649
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Class:
>
> - self.state = 641
>
> + self.state = 644
>
> self.match(VfrSyntaxParser.Class)
>
> - self.state = 642
>
> + self.state = 645
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 643
>
> + self.state = 646
>
> self.classDefinition()
>
> - self.state = 644
>
> + self.state = 647
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 653
>
> + self.state = 656
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Subclass:
>
> - self.state = 648
>
> + self.state = 651
>
> self.match(VfrSyntaxParser.Subclass)
>
> - self.state = 649
>
> + self.state = 652
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 650
>
> + self.state = 653
>
> self.subclassDefinition()
>
> - self.state = 651
>
> + self.state = 654
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 655
>
> + self.state = 658
>
> self.vfrFormSetList(localctx.Node)
>
> - self.state = 656
>
> + self.state = 659
>
> self.match(VfrSyntaxParser.EndFormSet)
>
> - self.state = 657
>
> + self.state = 660
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -4242,35 +4252,35 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 659
>
> - self.guidDefinition()
>
> self.state = 662
>
> + self.guidDefinition()
>
> + self.state = 665
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
>
> if la_ == 1:
>
> - self.state = 660
>
> + self.state = 663
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 661
>
> + self.state = 664
>
> self.guidDefinition()
>
>
>
>
>
> - self.state = 666
>
> + self.state = 669
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
>
> if la_ == 1:
>
> - self.state = 664
>
> + self.state = 667
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 665
>
> + self.state = 668
>
> self.guidDefinition()
>
>
>
>
>
> - self.state = 670
>
> + self.state = 673
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 668
>
> + self.state = 671
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 669
>
> + self.state = 672
>
> self.guidDefinition()
>
>
>
>
>
> @@ -4288,7 +4298,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
>
>
> def validClassNames(self, i:int=None):
>
> if i is None:
>
> @@ -4322,17 +4332,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 672
>
> + self.state = 675
>
> self.validClassNames()
>
> - self.state = 677
>
> + self.state = 680
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 673
>
> + self.state = 676
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 674
>
> + self.state = 677
>
> self.validClassNames()
>
> - self.state = 679
>
> + self.state = 682
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -4395,7 +4405,7 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 680
>
> + self.state = 683
>
> _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)
>
> @@ -4416,7 +4426,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
>
>
> def SubclassSetupApplication(self):
>
> return self.getToken(VfrSyntaxParser.SubclassSetupApplication, 0)
>
> @@ -4452,7 +4462,7 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 682
>
> + self.state = 685
>
> _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)
>
> @@ -4502,13 +4512,13 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 687
>
> + self.state = 690
>
> 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.state = 687
>
> self.vfrFormSet()
>
> - self.state = 689
>
> + self.state = 692
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -4586,47 +4596,47 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 56, self.RULE_vfrFormSet)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 700
>
> + self.state = 703
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Form]:
>
> - self.state = 690
>
> + self.state = 693
>
> self.vfrFormDefinition()
>
> pass
>
> elif token in [VfrSyntaxParser.FormMap]:
>
> - self.state = 691
>
> + self.state = 694
>
> self.vfrFormMapDefinition()
>
> pass
>
> elif token in [VfrSyntaxParser.Image]:
>
> - self.state = 692
>
> + self.state = 695
>
> self.vfrStatementImage()
>
> pass
>
> elif token in [VfrSyntaxParser.Varstore]:
>
> - self.state = 693
>
> + self.state = 696
>
> self.vfrStatementVarStoreLinear()
>
> pass
>
> elif token in [VfrSyntaxParser.Efivarstore]:
>
> - self.state = 694
>
> + self.state = 697
>
> self.vfrStatementVarStoreEfi()
>
> pass
>
> elif token in [VfrSyntaxParser.NameValueVarStore]:
>
> - self.state = 695
>
> + self.state = 698
>
> self.vfrStatementVarStoreNameValue()
>
> pass
>
> elif token in [VfrSyntaxParser.DefaultStore]:
>
> - self.state = 696
>
> + self.state = 699
>
> self.vfrStatementDefaultStore()
>
> pass
>
> elif token in [VfrSyntaxParser.DisableIf]:
>
> - self.state = 697
>
> + self.state = 700
>
> self.vfrStatementDisableIfFormSet()
>
> pass
>
> elif token in [VfrSyntaxParser.SuppressIf]:
>
> - self.state = 698
>
> + self.state = 701
>
> self.vfrStatementSuppressIfFormSet()
>
> pass
>
> elif token in [VfrSyntaxParser.GuidOp]:
>
> - self.state = 699
>
> + self.state = 702
>
> self.vfrStatementExtension()
>
> pass
>
> else:
>
> @@ -4646,7 +4656,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)
>
> self.N = None # Token
>
> self.S = None # Token
>
> self.A = None # Token
>
> @@ -4706,39 +4716,39 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 702
>
> + self.state = 705
>
> self.match(VfrSyntaxParser.DefaultStore)
>
> - self.state = 703
>
> + self.state = 706
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 704
>
> + self.state = 707
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 705
>
> + self.state = 708
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 706
>
> + self.state = 709
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 707
>
> + self.state = 710
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 708
>
> + self.state = 711
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 709
>
> + self.state = 712
>
> localctx.S = self.match(VfrSyntaxParser.Number)
>
> - self.state = 710
>
> + self.state = 713
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 715
>
> + self.state = 718
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 711
>
> + self.state = 714
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 712
>
> + self.state = 715
>
> self.match(VfrSyntaxParser.Attribute)
>
> - self.state = 713
>
> + self.state = 716
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 714
>
> + self.state = 717
>
> localctx.A = self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> - self.state = 717
>
> + self.state = 720
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -4754,7 +4764,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_VARSTORE_OP)
>
> self.TN = None # Token
>
> self.ID = None # Token
>
> self.SN = None # Token
>
> @@ -4833,91 +4843,91 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 719
>
> + self.state = 722
>
> self.match(VfrSyntaxParser.Varstore)
>
> - self.state = 736
>
> + self.state = 739
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.StringIdentifier]:
>
> - self.state = 720
>
> + self.state = 723
>
> localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 721
>
> + self.state = 724
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint8]:
>
> - self.state = 722
>
> + self.state = 725
>
> self.match(VfrSyntaxParser.Uint8)
>
> - self.state = 723
>
> + self.state = 726
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint16]:
>
> - self.state = 724
>
> + self.state = 727
>
> self.match(VfrSyntaxParser.Uint16)
>
> - self.state = 725
>
> + self.state = 728
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint32]:
>
> - self.state = 726
>
> + self.state = 729
>
> self.match(VfrSyntaxParser.Uint32)
>
> - self.state = 727
>
> + self.state = 730
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint64]:
>
> - self.state = 728
>
> + self.state = 731
>
> self.match(VfrSyntaxParser.Uint64)
>
> - self.state = 729
>
> + self.state = 732
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_DATE]:
>
> - self.state = 730
>
> + self.state = 733
>
> self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> - self.state = 731
>
> + self.state = 734
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_TIME]:
>
> - self.state = 732
>
> + self.state = 735
>
> self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> - self.state = 733
>
> + self.state = 736
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_REF]:
>
> - self.state = 734
>
> + self.state = 737
>
> self.match(VfrSyntaxParser.EFI_HII_REF)
>
> - self.state = 735
>
> + self.state = 738
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 742
>
> + self.state = 745
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.VarId:
>
> - self.state = 738
>
> + self.state = 741
>
> self.match(VfrSyntaxParser.VarId)
>
> - self.state = 739
>
> + self.state = 742
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 740
>
> + self.state = 743
>
> localctx.ID = self.match(VfrSyntaxParser.Number)
>
> - self.state = 741
>
> + self.state = 744
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 744
>
> + self.state = 747
>
> self.match(VfrSyntaxParser.Name)
>
> - self.state = 745
>
> + self.state = 748
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 746
>
> + self.state = 749
>
> localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 747
>
> + self.state = 750
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 748
>
> + self.state = 751
>
> self.match(VfrSyntaxParser.Uuid)
>
> - self.state = 749
>
> + self.state = 752
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 750
>
> + self.state = 753
>
> self.guidDefinition()
>
> - self.state = 751
>
> + self.state = 754
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -4933,7 +4943,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)
>
> self.TN = None # Token
>
> self.ID = None # Token
>
> self.SN = None # Token
>
> @@ -5045,143 +5055,143 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 753
>
> + self.state = 756
>
> self.match(VfrSyntaxParser.Efivarstore)
>
> - self.state = 770
>
> + self.state = 773
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.StringIdentifier]:
>
> - self.state = 754
>
> + self.state = 757
>
> localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 755
>
> + self.state = 758
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint8]:
>
> - self.state = 756
>
> + self.state = 759
>
> self.match(VfrSyntaxParser.Uint8)
>
> - self.state = 757
>
> + self.state = 760
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint16]:
>
> - self.state = 758
>
> + self.state = 761
>
> self.match(VfrSyntaxParser.Uint16)
>
> - self.state = 759
>
> + self.state = 762
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint32]:
>
> - self.state = 760
>
> + self.state = 763
>
> self.match(VfrSyntaxParser.Uint32)
>
> - self.state = 761
>
> + self.state = 764
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Uint64]:
>
> - self.state = 762
>
> + self.state = 765
>
> self.match(VfrSyntaxParser.Uint64)
>
> - self.state = 763
>
> + self.state = 766
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_DATE]:
>
> - self.state = 764
>
> + self.state = 767
>
> self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> - self.state = 765
>
> + self.state = 768
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_TIME]:
>
> - self.state = 766
>
> + self.state = 769
>
> self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> - self.state = 767
>
> + self.state = 770
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_REF]:
>
> - self.state = 768
>
> + self.state = 771
>
> self.match(VfrSyntaxParser.EFI_HII_REF)
>
> - self.state = 769
>
> + self.state = 772
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 776
>
> + self.state = 779
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.VarId:
>
> - self.state = 772
>
> + self.state = 775
>
> self.match(VfrSyntaxParser.VarId)
>
> - self.state = 773
>
> + self.state = 776
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 774
>
> + self.state = 777
>
> localctx.ID = self.match(VfrSyntaxParser.Number)
>
> - self.state = 775
>
> + self.state = 778
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 778
>
> + self.state = 781
>
> self.match(VfrSyntaxParser.Attribute)
>
> - self.state = 779
>
> + self.state = 782
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 780
>
> + self.state = 783
>
> self.vfrVarStoreEfiAttr()
>
> - self.state = 785
>
> + self.state = 788
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 781
>
> + self.state = 784
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 782
>
> + self.state = 785
>
> self.vfrVarStoreEfiAttr()
>
> - self.state = 787
>
> + self.state = 790
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 788
>
> + self.state = 791
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 804
>
> + self.state = 807
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
>
> if la_ == 1:
>
> - self.state = 789
>
> + self.state = 792
>
> self.match(VfrSyntaxParser.Name)
>
> - self.state = 790
>
> + self.state = 793
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 791
>
> + self.state = 794
>
> localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 792
>
> + self.state = 795
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
>
>
> elif la_ == 2:
>
> - self.state = 793
>
> + self.state = 796
>
> self.match(VfrSyntaxParser.Name)
>
> - self.state = 794
>
> + self.state = 797
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 795
>
> + self.state = 798
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 796
>
> + self.state = 799
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 797
>
> + self.state = 800
>
> localctx.VN = self.match(VfrSyntaxParser.Number)
>
> - self.state = 798
>
> + self.state = 801
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 799
>
> + self.state = 802
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 800
>
> + self.state = 803
>
> self.match(VfrSyntaxParser.VarSize)
>
> - self.state = 801
>
> + self.state = 804
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 802
>
> + self.state = 805
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> - self.state = 803
>
> + self.state = 806
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
>
>
>
>
> - self.state = 806
>
> + self.state = 809
>
> self.match(VfrSyntaxParser.Uuid)
>
> - self.state = 807
>
> + self.state = 810
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 808
>
> + self.state = 811
>
> self.guidDefinition()
>
> - self.state = 809
>
> + self.state = 812
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5220,7 +5230,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 64, self.RULE_vfrVarStoreEfiAttr)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 811
>
> + self.state = 814
>
> self.match(VfrSyntaxParser.Number)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5236,7 +5246,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)
>
> self.SN = None # Token
>
> self.ID = None # Token
>
>
>
> @@ -5314,57 +5324,57 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 813
>
> + self.state = 816
>
> self.match(VfrSyntaxParser.NameValueVarStore)
>
> - self.state = 814
>
> + self.state = 817
>
> localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 815
>
> + self.state = 818
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 820
>
> + self.state = 823
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.VarId:
>
> - self.state = 816
>
> + self.state = 819
>
> self.match(VfrSyntaxParser.VarId)
>
> - self.state = 817
>
> + self.state = 820
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 818
>
> + self.state = 821
>
> localctx.ID = self.match(VfrSyntaxParser.Number)
>
> - self.state = 819
>
> + self.state = 822
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 829
>
> + self.state = 832
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while True:
>
> - self.state = 822
>
> + self.state = 825
>
> self.match(VfrSyntaxParser.Name)
>
> - self.state = 823
>
> + self.state = 826
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 824
>
> + self.state = 827
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 825
>
> + self.state = 828
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 826
>
> + self.state = 829
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 827
>
> + self.state = 830
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 828
>
> - self.match(VfrSyntaxParser.Comma)
>
> self.state = 831
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 834
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if not (_la==VfrSyntaxParser.Name):
>
> break
>
>
>
> - self.state = 833
>
> + self.state = 836
>
> self.match(VfrSyntaxParser.Uuid)
>
> - self.state = 834
>
> + self.state = 837
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 835
>
> + self.state = 838
>
> self.guidDefinition()
>
> - self.state = 836
>
> + self.state = 839
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5380,7 +5390,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
>
>
>
> def DisableIf(self):
>
> return self.getToken(VfrSyntaxParser.DisableIf, 0)
>
> @@ -5420,17 +5430,17 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 68, self.RULE_vfrStatementDisableIfFormSet)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 838
>
> + self.state = 841
>
> self.match(VfrSyntaxParser.DisableIf)
>
> - self.state = 839
>
> - self.vfrStatementExpression()
>
> - self.state = 840
>
> + self.state = 842
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 843
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 841
>
> + self.state = 844
>
> self.vfrFormSetList(localctx.Node)
>
> - self.state = 842
>
> + self.state = 845
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 843
>
> + self.state = 846
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5446,7 +5456,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
>
>
> def SuppressIf(self):
>
> return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> @@ -5486,17 +5496,17 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 70, self.RULE_vfrStatementSuppressIfFormSet)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 845
>
> + self.state = 848
>
> self.match(VfrSyntaxParser.SuppressIf)
>
> - self.state = 846
>
> - self.vfrStatementExpression()
>
> - self.state = 847
>
> + self.state = 849
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 850
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 848
>
> + self.state = 851
>
> self.vfrFormSetList(localctx.Node)
>
> - self.state = 849
>
> + self.state = 852
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 850
>
> + self.state = 853
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5545,35 +5555,35 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 72, self.RULE_guidSubDefinition)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 852
>
> + self.state = 855
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 853
>
> + self.state = 856
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 854
>
> + self.state = 857
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 855
>
> + self.state = 858
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 856
>
> + self.state = 859
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 857
>
> + self.state = 860
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 858
>
> + self.state = 861
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 859
>
> + self.state = 862
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 860
>
> + self.state = 863
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 861
>
> + self.state = 864
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 862
>
> + self.state = 865
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 863
>
> + self.state = 866
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 864
>
> + self.state = 867
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 865
>
> + self.state = 868
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 866
>
> + self.state = 869
>
> self.match(VfrSyntaxParser.Number)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5589,7 +5599,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode()
>
> + self.Node = IfrTreeNode()
>
> self.Guid = EFI_GUID()
>
>
>
> def OpenBrace(self, i:int=None):
>
> @@ -5638,39 +5648,39 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 74, self.RULE_guidDefinition)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 868
>
> + self.state = 871
>
> self.match(VfrSyntaxParser.OpenBrace)
>
> - self.state = 869
>
> + self.state = 872
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 870
>
> + self.state = 873
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 871
>
> + self.state = 874
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 872
>
> + self.state = 875
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 873
>
> + self.state = 876
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 874
>
> + self.state = 877
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 880
>
> + self.state = 883
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.OpenBrace]:
>
> - self.state = 875
>
> + self.state = 878
>
> self.match(VfrSyntaxParser.OpenBrace)
>
> - self.state = 876
>
> + self.state = 879
>
> self.guidSubDefinition(localctx.Guid)
>
> - self.state = 877
>
> + self.state = 880
>
> self.match(VfrSyntaxParser.CloseBrace)
>
> pass
>
> elif token in [VfrSyntaxParser.Number]:
>
> - self.state = 879
>
> + self.state = 882
>
> self.guidSubDefinition(localctx.Guid)
>
> pass
>
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 882
>
> + self.state = 885
>
> self.match(VfrSyntaxParser.CloseBrace)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5718,13 +5728,13 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 76, self.RULE_getStringId)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 884
>
> + self.state = 887
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 885
>
> + self.state = 888
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 886
>
> + self.state = 889
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 887
>
> + self.state = 890
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -5737,12 +5747,12 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrQuestionHeaderContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, OpObj=None, QType=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None, QType=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.OpObj = None
>
> + self.Node = None
>
> self.QType = None
>
> - self.OpObj = OpObj
>
> + self.Node = Node
>
> self.QType = QType
>
>
>
> def vfrQuestionBaseInfo(self):
>
> @@ -5765,16 +5775,16 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrQuestionHeader(self, OpObj, QType):
>
> + def vfrQuestionHeader(self, Node, QType):
>
>
>
> - localctx = VfrSyntaxParser.VfrQuestionHeaderContext(self, self._ctx,
> self.state, OpObj, QType)
>
> + localctx = VfrSyntaxParser.VfrQuestionHeaderContext(self, self._ctx,
> self.state, Node, 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)
>
> + self.state = 892
>
> + self.vfrQuestionBaseInfo(Node, QType)
>
> + self.state = 893
>
> + self.vfrStatementHeader(Node)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> self._errHandler.reportError(self, re)
>
> @@ -5786,17 +5796,19 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrQuestionBaseInfoContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, OpObj=None, QType=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None, QType=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.OpObj = None
>
> + self.Node = None
>
> self.QType = None
>
> self.BaseInfo = EFI_VARSTORE_INFO()
>
> self.QId = EFI_QUESTION_ID_INVALID
>
> self.CheckFlag = True
>
> + self.QName = None
>
> + self.VarIdStr = ''
>
> self.QN = None # Token
>
> self.ID = None # Token
>
> - self.OpObj = OpObj
>
> + self.Node = Node
>
> self.QType = QType
>
>
>
> def Name(self):
>
> @@ -5836,52 +5848,52 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrQuestionBaseInfo(self, OpObj, QType):
>
> + def vfrQuestionBaseInfo(self, Node, QType):
>
>
>
> - localctx = VfrSyntaxParser.VfrQuestionBaseInfoContext(self, self._ctx,
> self.state, OpObj, QType)
>
> + localctx = VfrSyntaxParser.VfrQuestionBaseInfoContext(self, self._ctx,
> self.state, Node, QType)
>
> self.enterRule(localctx, 80, self.RULE_vfrQuestionBaseInfo)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 896
>
> + self.state = 899
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Name:
>
> - self.state = 892
>
> + self.state = 895
>
> self.match(VfrSyntaxParser.Name)
>
> - self.state = 893
>
> + self.state = 896
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 894
>
> + self.state = 897
>
> localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 895
>
> + self.state = 898
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 903
>
> + self.state = 906
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.VarId:
>
> - self.state = 898
>
> + self.state = 901
>
> self.match(VfrSyntaxParser.VarId)
>
> - self.state = 899
>
> + self.state = 902
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 900
>
> + self.state = 903
>
> self.vfrStorageVarId(localctx.BaseInfo, localctx.CheckFlag)
>
> - self.state = 901
>
> + self.state = 904
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 909
>
> + self.state = 912
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.QuestionId:
>
> - self.state = 905
>
> + self.state = 908
>
> self.match(VfrSyntaxParser.QuestionId)
>
> - self.state = 906
>
> + self.state = 909
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 907
>
> + self.state = 910
>
> localctx.ID = self.match(VfrSyntaxParser.Number)
>
> - self.state = 908
>
> + self.state = 911
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> @@ -5896,11 +5908,11 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrStatementHeaderContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, OpObj=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.OpObj = None
>
> - self.OpObj = OpObj
>
> + self.Node = None
>
> + self.Node = Node
>
>
>
> def Prompt(self):
>
> return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> @@ -5947,37 +5959,37 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrStatementHeader(self, OpObj):
>
> + def vfrStatementHeader(self, Node):
>
>
>
> - localctx = VfrSyntaxParser.VfrStatementHeaderContext(self, self._ctx,
> self.state, OpObj)
>
> + localctx = VfrSyntaxParser.VfrStatementHeaderContext(self, self._ctx,
> self.state, Node)
>
> self.enterRule(localctx, 82, self.RULE_vfrStatementHeader)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 911
>
> + self.state = 914
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 912
>
> + self.state = 915
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 913
>
> + self.state = 916
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 914
>
> + self.state = 917
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 915
>
> + self.state = 918
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 916
>
> + self.state = 919
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 917
>
> + self.state = 920
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 918
>
> + self.state = 921
>
> self.match(VfrSyntaxParser.Help)
>
> - self.state = 919
>
> + self.state = 922
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 920
>
> + self.state = 923
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 921
>
> + self.state = 924
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 922
>
> + self.state = 925
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 923
>
> + self.state = 926
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -6039,47 +6051,47 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.QuestionheaderFlagsFieldContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 84, self.RULE_questionheaderFlagsField)
>
> try:
>
> - self.state = 933
>
> + self.state = 936
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.ReadOnlyFlag]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 925
>
> + self.state = 928
>
> self.match(VfrSyntaxParser.ReadOnlyFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.InteractiveFlag]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 926
>
> + self.state = 929
>
> self.match(VfrSyntaxParser.InteractiveFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ResetRequiredFlag]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 927
>
> + self.state = 930
>
> self.match(VfrSyntaxParser.ResetRequiredFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.RestStyleFlag]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 928
>
> + self.state = 931
>
> self.match(VfrSyntaxParser.RestStyleFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 929
>
> + self.state = 932
>
> self.match(VfrSyntaxParser.ReconnectRequiredFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.OptionOnlyFlag]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 930
>
> + self.state = 933
>
> localctx.O = self.match(VfrSyntaxParser.OptionOnlyFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.NVAccessFlag]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 931
>
> + self.state = 934
>
> localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.LateCheckFlag]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 932
>
> + self.state = 935
>
> localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
>
> pass
>
> else:
>
> @@ -6177,36 +6189,36 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 86, self.RULE_vfrStorageVarId)
>
> self._la = 0 # Token type
>
> try:
>
> - self.state = 947
>
> + self.state = 950
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
>
> if la_ == 1:
>
> localctx = VfrSyntaxParser.VfrStorageVarIdRule1Context(self, localctx)
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 935
>
> + self.state = 938
>
> localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 936
>
> + self.state = 939
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 937
>
> + self.state = 940
>
> localctx.I = self.match(VfrSyntaxParser.Number)
>
> - self.state = 938
>
> + self.state = 941
>
> self.match(VfrSyntaxParser.CloseBracket)
>
> pass
>
>
>
> elif la_ == 2:
>
> localctx = VfrSyntaxParser.VfrStorageVarIdRule2Context(self, localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 939
>
> + self.state = 942
>
> localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 944
>
> + self.state = 947
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.Dot:
>
> - self.state = 940
>
> + self.state = 943
>
> self.match(VfrSyntaxParser.Dot)
>
> - self.state = 941
>
> + self.state = 944
>
> self.arrayName()
>
> - self.state = 946
>
> + self.state = 949
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -6227,9 +6239,9 @@ class VfrSyntaxParser ( Parser ):
> 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
>
> + self.ValueType = None
>
>
>
> def Number(self, i:int=None):
>
> if i is None:
>
> @@ -6316,136 +6328,136 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 88, self.RULE_vfrConstantValueField)
>
> self._la = 0 # Token type
>
> try:
>
> - self.state = 993
>
> + self.state = 996
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
>
> if la_ == 1:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 950
>
> + self.state = 953
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Negative:
>
> - self.state = 949
>
> + self.state = 952
>
> self.match(VfrSyntaxParser.Negative)
>
>
>
>
>
> - self.state = 952
>
> + self.state = 955
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
>
>
> elif la_ == 2:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 953
>
> + self.state = 956
>
> self.match(VfrSyntaxParser.TrueSymbol)
>
> pass
>
>
>
> elif la_ == 3:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 954
>
> + self.state = 957
>
> self.match(VfrSyntaxParser.FalseSymbol)
>
> pass
>
>
>
> elif la_ == 4:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 955
>
> + self.state = 958
>
> self.match(VfrSyntaxParser.One)
>
> pass
>
>
>
> elif la_ == 5:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 956
>
> + self.state = 959
>
> self.match(VfrSyntaxParser.Ones)
>
> pass
>
>
>
> elif la_ == 6:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 957
>
> + self.state = 960
>
> self.match(VfrSyntaxParser.Zero)
>
> pass
>
>
>
> elif la_ == 7:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 958
>
> + self.state = 961
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 959
>
> + self.state = 962
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 960
>
> + self.state = 963
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 961
>
> + self.state = 964
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 962
>
> + self.state = 965
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
>
>
> elif la_ == 8:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 963
>
> + self.state = 966
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 964
>
> + self.state = 967
>
> self.match(VfrSyntaxParser.Slash)
>
> - self.state = 965
>
> + self.state = 968
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 966
>
> + self.state = 969
>
> self.match(VfrSyntaxParser.Slash)
>
> - self.state = 967
>
> + self.state = 970
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
>
>
> elif la_ == 9:
>
> self.enterOuterAlt(localctx, 9)
>
> - self.state = 968
>
> + self.state = 971
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 969
>
> + self.state = 972
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 970
>
> + self.state = 973
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 971
>
> + self.state = 974
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 972
>
> + self.state = 975
>
> self.guidDefinition()
>
> - self.state = 973
>
> + self.state = 976
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 974
>
> + self.state = 977
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 975
>
> + self.state = 978
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 976
>
> + self.state = 979
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 977
>
> + self.state = 980
>
> self.match(VfrSyntaxParser.CloseParen)
>
> pass
>
>
>
> elif la_ == 10:
>
> self.enterOuterAlt(localctx, 10)
>
> - self.state = 979
>
> + self.state = 982
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 980
>
> + self.state = 983
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 981
>
> + self.state = 984
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 982
>
> + self.state = 985
>
> self.match(VfrSyntaxParser.CloseParen)
>
> pass
>
>
>
> elif la_ == 11:
>
> self.enterOuterAlt(localctx, 11)
>
> - self.state = 983
>
> + self.state = 986
>
> self.match(VfrSyntaxParser.OpenBrace)
>
> - self.state = 984
>
> + self.state = 987
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 989
>
> + self.state = 992
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.Comma:
>
> - self.state = 985
>
> + self.state = 988
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 986
>
> + self.state = 989
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 991
>
> + self.state = 994
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 992
>
> + self.state = 995
>
> self.match(VfrSyntaxParser.CloseBrace)
>
> pass
>
>
>
> @@ -6464,7 +6476,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_IMAGE_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_IMAGE_OP)
>
>
>
> def Image(self):
>
> return self.getToken(VfrSyntaxParser.Image, 0)
>
> @@ -6496,17 +6508,17 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 90, self.RULE_vfrImageTag)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 995
>
> + self.state = 998
>
> self.match(VfrSyntaxParser.Image)
>
> - self.state = 996
>
> + self.state = 999
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 997
>
> + self.state = 1000
>
> self.match(VfrSyntaxParser.T__6)
>
> - self.state = 998
>
> + self.state = 1001
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 999
>
> + self.state = 1002
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1000
>
> + self.state = 1003
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -6522,7 +6534,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_LOCKED_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_LOCKED_OP)
>
>
>
> def Locked(self):
>
> return self.getToken(VfrSyntaxParser.Locked, 0)
>
> @@ -6545,7 +6557,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 92, self.RULE_vfrLockedTag)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1002
>
> + self.state = 1005
>
> self.match(VfrSyntaxParser.Locked)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -6588,17 +6600,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementStatTagContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 94, self.RULE_vfrStatementStatTag)
>
> try:
>
> - self.state = 1006
>
> + self.state = 1009
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Image]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1004
>
> + self.state = 1007
>
> self.vfrImageTag()
>
> pass
>
> elif token in [VfrSyntaxParser.Locked]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1005
>
> + self.state = 1008
>
> self.vfrLockedTag()
>
> pass
>
> else:
>
> @@ -6652,20 +6664,20 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 96, self.RULE_vfrStatementStatTagList)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1008
>
> + self.state = 1011
>
> self.vfrStatementStatTag()
>
> - self.state = 1013
>
> + self.state = 1016
>
> self._errHandler.sync(self)
>
> - _alt = self._interp.adaptivePredict(self._input,59,self._ctx)
>
> + _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
>
> while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
>
> if _alt==1:
>
> - self.state = 1009
>
> + self.state = 1012
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1010
>
> + self.state = 1013
>
> self.vfrStatementStatTag()
>
> - self.state = 1015
>
> + self.state = 1018
>
> self._errHandler.sync(self)
>
> - _alt = self._interp.adaptivePredict(self._input,59,self._ctx)
>
> + _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
>
>
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -6681,7 +6693,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_FORM_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_FORM_OP)
>
>
>
> def Form(self):
>
> return self.getToken(VfrSyntaxParser.Form, 0)
>
> @@ -6745,43 +6757,43 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1016
>
> + self.state = 1019
>
> self.match(VfrSyntaxParser.Form)
>
> - self.state = 1017
>
> + self.state = 1020
>
> self.match(VfrSyntaxParser.FormId)
>
> - self.state = 1018
>
> + self.state = 1021
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1019
>
> + self.state = 1022
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1020
>
> + self.state = 1023
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1021
>
> + self.state = 1024
>
> self.match(VfrSyntaxParser.Title)
>
> - self.state = 1022
>
> + self.state = 1025
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1023
>
> + self.state = 1026
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1024
>
> + self.state = 1027
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1025
>
> + self.state = 1028
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1026
>
> + self.state = 1029
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1027
>
> + self.state = 1030
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 1031
>
> + self.state = 1034
>
> 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.state = 1031
>
> self.vfrForm()
>
> - self.state = 1033
>
> + self.state = 1036
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1034
>
> + self.state = 1037
>
> self.match(VfrSyntaxParser.EndForm)
>
> - self.state = 1035
>
> + self.state = 1038
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -6872,61 +6884,61 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 100, self.RULE_vfrForm)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1052
>
> + self.state = 1055
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Image]:
>
> - self.state = 1037
>
> + self.state = 1040
>
> self.vfrStatementImage()
>
> pass
>
> elif token in [VfrSyntaxParser.Locked]:
>
> - self.state = 1038
>
> + self.state = 1041
>
> self.vfrStatementLocked()
>
> pass
>
> elif token in [VfrSyntaxParser.Rule]:
>
> - self.state = 1039
>
> + self.state = 1042
>
> self.vfrStatementRules()
>
> pass
>
> elif token in [VfrSyntaxParser.Default]:
>
> - self.state = 1040
>
> + self.state = 1043
>
> self.vfrStatementDefault()
>
> pass
>
> elif token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text,
> VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
>
> - self.state = 1041
>
> + self.state = 1044
>
> 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.state = 1045
>
> self.vfrStatementQuestions()
>
> pass
>
> elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf,
> VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
>
> - self.state = 1043
>
> + self.state = 1046
>
> self.vfrStatementConditional()
>
> pass
>
> elif token in [VfrSyntaxParser.Label]:
>
> - self.state = 1044
>
> + self.state = 1047
>
> self.vfrStatementLabel()
>
> pass
>
> elif token in [VfrSyntaxParser.Banner]:
>
> - self.state = 1045
>
> + self.state = 1048
>
> self.vfrStatementBanner()
>
> pass
>
> elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> - self.state = 1046
>
> + self.state = 1049
>
> self.vfrStatementInvalid()
>
> pass
>
> elif token in [VfrSyntaxParser.GuidOp]:
>
> - self.state = 1047
>
> + self.state = 1050
>
> self.vfrStatementExtension()
>
> pass
>
> elif token in [VfrSyntaxParser.Modal]:
>
> - self.state = 1048
>
> + self.state = 1051
>
> self.vfrStatementModal()
>
> pass
>
> elif token in [VfrSyntaxParser.RefreshGuid]:
>
> - self.state = 1049
>
> + self.state = 1052
>
> self.vfrStatementRefreshEvent()
>
> - self.state = 1050
>
> + self.state = 1053
>
> self.match(VfrSyntaxParser.Semicolon)
>
> pass
>
> else:
>
> @@ -6946,7 +6958,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_FORM_MAP_OP)
>
> self.S1 = None # Token
>
>
>
> def FormMap(self):
>
> @@ -7036,59 +7048,59 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1054
>
> + self.state = 1057
>
> self.match(VfrSyntaxParser.FormMap)
>
> - self.state = 1055
>
> + self.state = 1058
>
> self.match(VfrSyntaxParser.FormId)
>
> - self.state = 1056
>
> + self.state = 1059
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1057
>
> + self.state = 1060
>
> localctx.S1 = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1058
>
> + self.state = 1061
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1073
>
> + self.state = 1076
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.MapTitle:
>
> - self.state = 1059
>
> + self.state = 1062
>
> self.match(VfrSyntaxParser.MapTitle)
>
> - self.state = 1060
>
> + self.state = 1063
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1061
>
> + self.state = 1064
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1062
>
> + self.state = 1065
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1063
>
> + self.state = 1066
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1064
>
> + self.state = 1067
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1065
>
> + self.state = 1068
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 1066
>
> + self.state = 1069
>
> self.match(VfrSyntaxParser.MapGuid)
>
> - self.state = 1067
>
> + self.state = 1070
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1068
>
> + self.state = 1071
>
> self.guidDefinition()
>
> - self.state = 1069
>
> + self.state = 1072
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 1075
>
> + self.state = 1078
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1079
>
> + self.state = 1082
>
> 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.state = 1079
>
> self.vfrForm()
>
> - self.state = 1081
>
> + self.state = 1084
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1082
>
> + self.state = 1085
>
> self.match(VfrSyntaxParser.EndForm)
>
> - self.state = 1083
>
> + self.state = 1086
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -7131,9 +7143,9 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 104, self.RULE_vfrStatementImage)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1085
>
> + self.state = 1088
>
> self.vfrImageTag()
>
> - self.state = 1086
>
> + self.state = 1089
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -7176,9 +7188,9 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 106, self.RULE_vfrStatementLocked)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1088
>
> + self.state = 1091
>
> self.vfrLockedTag()
>
> - self.state = 1089
>
> + self.state = 1092
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -7194,7 +7206,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_RULE_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_RULE_OP)
>
>
>
> def Rule(self):
>
> return self.getToken(VfrSyntaxParser.Rule, 0)
>
> @@ -7233,17 +7245,17 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 108, self.RULE_vfrStatementRules)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1091
>
> + self.state = 1094
>
> self.match(VfrSyntaxParser.Rule)
>
> - self.state = 1092
>
> + self.state = 1095
>
> self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 1093
>
> + self.state = 1096
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1094
>
> - self.vfrStatementExpression()
>
> - self.state = 1095
>
> + self.state = 1097
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1098
>
> self.match(VfrSyntaxParser.EndRule)
>
> - self.state = 1096
>
> + self.state = 1099
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -7290,22 +7302,22 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementStatContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 110, self.RULE_vfrStatementStat)
>
> try:
>
> - self.state = 1101
>
> + self.state = 1104
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Subtitle]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1098
>
> + self.state = 1101
>
> self.vfrStatementSubTitle()
>
> pass
>
> elif token in [VfrSyntaxParser.Text]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1099
>
> + self.state = 1102
>
> self.vfrStatementStaticText()
>
> pass
>
> elif token in [VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1100
>
> + self.state = 1103
>
> self.vfrStatementCrossReference()
>
> pass
>
> else:
>
> @@ -7325,8 +7337,7 @@ class VfrSyntaxParser ( Parser ):
> 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()
>
> + self.Node = IfrTreeNode(EFI_IFR_SUBTITLE_OP)
>
>
>
> def Subtitle(self):
>
> return self.getToken(VfrSyntaxParser.Subtitle, 0)
>
> @@ -7395,84 +7406,84 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1103
>
> + self.state = 1106
>
> self.match(VfrSyntaxParser.Subtitle)
>
> - self.state = 1104
>
> + self.state = 1107
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 1105
>
> + self.state = 1108
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1106
>
> + self.state = 1109
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1107
>
> + self.state = 1110
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1108
>
> + self.state = 1111
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1109
>
> + self.state = 1112
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1114
>
> + self.state = 1117
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1110
>
> + self.state = 1113
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1111
>
> + self.state = 1114
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1112
>
> + self.state = 1115
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1113
>
> + self.state = 1116
>
> self.vfrSubtitleFlags()
>
>
>
>
>
> - self.state = 1136
>
> + self.state = 1139
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1118
>
> + self.state = 1121
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 1116
>
> + self.state = 1119
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1117
>
> + self.state = 1120
>
> self.vfrStatementStatTagList(localctx.Node)
>
>
>
>
>
> - self.state = 1120
>
> + self.state = 1123
>
> self.match(VfrSyntaxParser.Semicolon)
>
> pass
>
>
>
> elif la_ == 2:
>
> - self.state = 1123
>
> + self.state = 1126
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1121
>
> + self.state = 1124
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1122
>
> + self.state = 1125
>
> self.vfrStatementStatTagList(localctx.Node)
>
>
>
>
>
> - self.state = 1132
>
> + self.state = 1135
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 1125
>
> + self.state = 1128
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1129
>
> + self.state = 1132
>
> 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.state = 1129
>
> self.vfrStatementSubTitleComponent()
>
> - self.state = 1131
>
> + self.state = 1134
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
>
>
>
>
> - self.state = 1134
>
> + self.state = 1137
>
> self.match(VfrSyntaxParser.EndSubtitle)
>
> - self.state = 1135
>
> + self.state = 1138
>
> self.match(VfrSyntaxParser.Semicolon)
>
> pass
>
>
>
> @@ -7518,17 +7529,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementSubTitleComponentContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 114, self.RULE_vfrStatementSubTitleComponent)
>
> try:
>
> - self.state = 1140
>
> + self.state = 1143
>
> 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.state = 1141
>
> 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.state = 1142
>
> self.vfrStatementQuestions()
>
> pass
>
> else:
>
> @@ -7582,17 +7593,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1142
>
> + self.state = 1145
>
> self.subtitleFlagsField()
>
> - self.state = 1147
>
> + self.state = 1150
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1143
>
> + self.state = 1146
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1144
>
> + self.state = 1147
>
> self.subtitleFlagsField()
>
> - self.state = 1149
>
> + self.state = 1152
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -7634,7 +7645,7 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1150
>
> + self.state = 1153
>
> _la = self._input.LA(1)
>
> if not(_la==VfrSyntaxParser.T__7 or _la==VfrSyntaxParser.Number):
>
> self._errHandler.recoverInline(self)
>
> @@ -7655,7 +7666,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_TEXT_OP)
>
> self.S1 = None # Token
>
> self.S2 = None # Token
>
> self.S3 = None # Token
>
> @@ -7746,99 +7757,99 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1152
>
> + self.state = 1155
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 1153
>
> + self.state = 1156
>
> self.match(VfrSyntaxParser.Help)
>
> - self.state = 1154
>
> + self.state = 1157
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1155
>
> + self.state = 1158
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1156
>
> + self.state = 1159
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1157
>
> + self.state = 1160
>
> localctx.S1 = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1158
>
> + self.state = 1161
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1159
>
> + self.state = 1162
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1160
>
> + self.state = 1163
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 1161
>
> + self.state = 1164
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1162
>
> + self.state = 1165
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1163
>
> + self.state = 1166
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1164
>
> + self.state = 1167
>
> localctx.S2 = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1165
>
> + self.state = 1168
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1173
>
> + self.state = 1176
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1166
>
> + self.state = 1169
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1167
>
> + self.state = 1170
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 1168
>
> + self.state = 1171
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1169
>
> + self.state = 1172
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1170
>
> + self.state = 1173
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1171
>
> + self.state = 1174
>
> localctx.S3 = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1172
>
> + self.state = 1175
>
> self.match(VfrSyntaxParser.CloseParen)
>
>
>
>
>
> - self.state = 1191
>
> + self.state = 1194
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1175
>
> + self.state = 1178
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1176
>
> + self.state = 1179
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1177
>
> + self.state = 1180
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1178
>
> + self.state = 1181
>
> self.staticTextFlagsField()
>
> - self.state = 1183
>
> + self.state = 1186
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1179
>
> + self.state = 1182
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1180
>
> + self.state = 1183
>
> self.staticTextFlagsField()
>
> - self.state = 1185
>
> + self.state = 1188
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1186
>
> + self.state = 1189
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1187
>
> + self.state = 1190
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1188
>
> + self.state = 1191
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1189
>
> + self.state = 1192
>
> localctx.S4 = self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> - self.state = 1195
>
> + self.state = 1198
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 1193
>
> + self.state = 1196
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1194
>
> + self.state = 1197
>
> self.vfrStatementStatTagList(localctx.Node)
>
>
>
>
>
> - self.state = 1197
>
> + self.state = 1200
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -7881,17 +7892,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.StaticTextFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 122, self.RULE_staticTextFlagsField)
>
> try:
>
> - self.state = 1201
>
> + self.state = 1204
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1199
>
> + self.state = 1202
>
> 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.state = 1203
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -7938,17 +7949,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementCrossReferenceContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 124, self.RULE_vfrStatementCrossReference)
>
> try:
>
> - self.state = 1205
>
> + self.state = 1208
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Goto]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1203
>
> + self.state = 1206
>
> self.vfrStatementGoto()
>
> pass
>
> elif token in [VfrSyntaxParser.ResetButton]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1204
>
> + self.state = 1207
>
> self.vfrStatementResetButton()
>
> pass
>
> else:
>
> @@ -7968,11 +7979,11 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_REF_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_REF
>
> self.QN = None # Token
>
> + self.N = None # Token
>
> + self.E = None # Token
>
>
>
> def Goto(self):
>
> return self.getToken(VfrSyntaxParser.Goto, 0)
>
> @@ -8057,103 +8068,103 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1207
>
> + self.state = 1210
>
> self.match(VfrSyntaxParser.Goto)
>
> - self.state = 1255
>
> + self.state = 1258
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.DevicePath]:
>
> - self.state = 1208
>
> + self.state = 1211
>
> self.match(VfrSyntaxParser.DevicePath)
>
> - self.state = 1209
>
> + self.state = 1212
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1210
>
> + self.state = 1213
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1211
>
> + self.state = 1214
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1212
>
> + self.state = 1215
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1213
>
> + self.state = 1216
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1214
>
> + self.state = 1217
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1215
>
> + self.state = 1218
>
> self.match(VfrSyntaxParser.FormSetGuid)
>
> - self.state = 1216
>
> + self.state = 1219
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1217
>
> + self.state = 1220
>
> self.guidDefinition()
>
> - self.state = 1218
>
> + self.state = 1221
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1219
>
> + self.state = 1222
>
> self.match(VfrSyntaxParser.FormId)
>
> - self.state = 1220
>
> + self.state = 1223
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1221
>
> + self.state = 1224
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1222
>
> + self.state = 1225
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1223
>
> + self.state = 1226
>
> self.match(VfrSyntaxParser.Question)
>
> - self.state = 1224
>
> + self.state = 1227
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1225
>
> + self.state = 1228
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1226
>
> + self.state = 1229
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.FormSetGuid]:
>
> - self.state = 1228
>
> + self.state = 1231
>
> self.match(VfrSyntaxParser.FormSetGuid)
>
> - self.state = 1229
>
> + self.state = 1232
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1230
>
> + self.state = 1233
>
> self.guidDefinition()
>
> - self.state = 1231
>
> + self.state = 1234
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1232
>
> + self.state = 1235
>
> self.match(VfrSyntaxParser.FormId)
>
> - self.state = 1233
>
> + self.state = 1236
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1234
>
> + self.state = 1237
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1235
>
> + self.state = 1238
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1236
>
> + self.state = 1239
>
> self.match(VfrSyntaxParser.Question)
>
> - self.state = 1237
>
> + self.state = 1240
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1238
>
> + self.state = 1241
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1239
>
> + self.state = 1242
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.FormId]:
>
> - self.state = 1241
>
> + self.state = 1244
>
> self.match(VfrSyntaxParser.FormId)
>
> - self.state = 1242
>
> + self.state = 1245
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1243
>
> + self.state = 1246
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1244
>
> + self.state = 1247
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1245
>
> + self.state = 1248
>
> self.match(VfrSyntaxParser.Question)
>
> - self.state = 1246
>
> + self.state = 1249
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1251
>
> + self.state = 1254
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.StringIdentifier]:
>
> - self.state = 1247
>
> + self.state = 1250
>
> localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 1248
>
> + self.state = 1251
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.Number]:
>
> - self.state = 1249
>
> + self.state = 1252
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1250
>
> + self.state = 1253
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> else:
>
> @@ -8161,56 +8172,56 @@ class VfrSyntaxParser ( Parser ):
>
>
> pass
>
> elif token in [VfrSyntaxParser.Number]:
>
> - self.state = 1253
>
> - self.match(VfrSyntaxParser.Number)
>
> - self.state = 1254
>
> + self.state = 1256
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1257
>
> 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.state = 1260
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1265
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1258
>
> + self.state = 1261
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1259
>
> + self.state = 1262
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1260
>
> + self.state = 1263
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1261
>
> - self.vfrGotoFlags(localctx.OpObj)
>
> + self.state = 1264
>
> + self.vfrGotoFlags()
>
>
>
>
>
> - self.state = 1268
>
> + self.state = 1271
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1264
>
> + self.state = 1267
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1265
>
> + self.state = 1268
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1266
>
> + self.state = 1269
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1267
>
> + self.state = 1270
>
> self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> - self.state = 1272
>
> + self.state = 1275
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 1270
>
> - self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1271
>
> + self.state = 1273
>
> + localctx.E = self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1274
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
>
>
>
>
> - self.state = 1274
>
> + self.state = 1277
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -8223,12 +8234,10 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrGotoFlagsContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Obj=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> 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:
>
> @@ -8255,24 +8264,24 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrGotoFlags(self, Obj):
>
> + def vfrGotoFlags(self):
>
>
>
> - localctx = VfrSyntaxParser.VfrGotoFlagsContext(self, self._ctx, self.state,
> Obj)
>
> + localctx = VfrSyntaxParser.VfrGotoFlagsContext(self, self._ctx, self.state)
>
> self.enterRule(localctx, 128, self.RULE_vfrGotoFlags)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1276
>
> + self.state = 1279
>
> self.gotoFlagsField()
>
> - self.state = 1281
>
> + self.state = 1284
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1277
>
> + self.state = 1280
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1278
>
> + self.state = 1281
>
> self.gotoFlagsField()
>
> - self.state = 1283
>
> + self.state = 1286
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -8317,17 +8326,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.GotoFlagsFieldContext(self, self._ctx, self.state)
>
> self.enterRule(localctx, 130, self.RULE_gotoFlagsField)
>
> try:
>
> - self.state = 1286
>
> + self.state = 1289
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1284
>
> + self.state = 1287
>
> 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.state = 1288
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -8347,8 +8356,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_RESET_BUTTON_OP)
>
> self.N = None # Token
>
>
>
> def ResetButton(self):
>
> @@ -8399,33 +8407,33 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1288
>
> + self.state = 1291
>
> self.match(VfrSyntaxParser.ResetButton)
>
> - self.state = 1289
>
> + self.state = 1292
>
> self.match(VfrSyntaxParser.DefaultStore)
>
> - self.state = 1290
>
> + self.state = 1293
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1291
>
> + self.state = 1294
>
> localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 1292
>
> + self.state = 1295
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1293
>
> - self.vfrStatementHeader(localctx.OpObj)
>
> - self.state = 1294
>
> + self.state = 1296
>
> + self.vfrStatementHeader(localctx.Node)
>
> + self.state = 1297
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1298
>
> + self.state = 1301
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Image or _la==VfrSyntaxParser.Locked:
>
> - self.state = 1295
>
> + self.state = 1298
>
> self.vfrStatementStatTagList(localctx.Node)
>
> - self.state = 1296
>
> + self.state = 1299
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1300
>
> + self.state = 1303
>
> self.match(VfrSyntaxParser.EndResetButton)
>
> - self.state = 1301
>
> + self.state = 1304
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -8484,37 +8492,37 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementQuestionsContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 134, self.RULE_vfrStatementQuestions)
>
> try:
>
> - self.state = 1309
>
> + self.state = 1312
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.CheckBox, VfrSyntaxParser.Action]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1303
>
> + self.state = 1306
>
> self.vfrStatementBooleanType()
>
> pass
>
> elif token in [VfrSyntaxParser.Date]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1304
>
> + self.state = 1307
>
> self.vfrStatementDate()
>
> pass
>
> elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.Numeric]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1305
>
> + self.state = 1308
>
> self.vfrStatementNumericType()
>
> pass
>
> elif token in [VfrSyntaxParser.Password, VfrSyntaxParser.String]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1306
>
> + self.state = 1309
>
> self.vfrStatementStringType()
>
> pass
>
> elif token in [VfrSyntaxParser.OrderedList]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1307
>
> + self.state = 1310
>
> self.vfrStatementOrderedList()
>
> pass
>
> elif token in [VfrSyntaxParser.Time]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 1308
>
> + self.state = 1311
>
> self.vfrStatementTime()
>
> pass
>
> else:
>
> @@ -8592,54 +8600,54 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementQuestionTagContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 136, self.RULE_vfrStatementQuestionTag)
>
> try:
>
> - self.state = 1322
>
> + self.state = 1325
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Image, VfrSyntaxParser.Locked]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1311
>
> + self.state = 1314
>
> self.vfrStatementStatTag()
>
> - self.state = 1312
>
> + self.state = 1315
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.InconsistentIf]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1314
>
> + self.state = 1317
>
> self.vfrStatementInconsistentIf()
>
> pass
>
> elif token in [VfrSyntaxParser.NoSubmitIf]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1315
>
> + self.state = 1318
>
> self.vfrStatementNoSubmitIf()
>
> pass
>
> elif token in [VfrSyntaxParser.DisableIf]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1316
>
> + self.state = 1319
>
> self.vfrStatementDisableIfQuest()
>
> pass
>
> elif token in [VfrSyntaxParser.Refresh]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1317
>
> + self.state = 1320
>
> self.vfrStatementRefresh()
>
> pass
>
> elif token in [VfrSyntaxParser.VarstoreDevice]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 1318
>
> + self.state = 1321
>
> self.vfrStatementVarstoreDevice()
>
> pass
>
> elif token in [VfrSyntaxParser.GuidOp]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 1319
>
> + self.state = 1322
>
> self.vfrStatementExtension()
>
> pass
>
> elif token in [VfrSyntaxParser.RefreshGuid]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 1320
>
> + self.state = 1323
>
> self.vfrStatementRefreshEvent()
>
> pass
>
> elif token in [VfrSyntaxParser.WarningIf]:
>
> self.enterOuterAlt(localctx, 9)
>
> - self.state = 1321
>
> + self.state = 1324
>
> self.vfrStatementWarningIf()
>
> pass
>
> else:
>
> @@ -8659,7 +8667,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
>
>
>
> def InconsistentIf(self):
>
> return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
>
> @@ -8730,57 +8738,57 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1324
>
> + self.state = 1327
>
> self.match(VfrSyntaxParser.InconsistentIf)
>
> - self.state = 1325
>
> + self.state = 1328
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 1326
>
> + self.state = 1329
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1327
>
> + self.state = 1330
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1328
>
> + self.state = 1331
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1329
>
> + self.state = 1332
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1330
>
> + self.state = 1333
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1331
>
> + self.state = 1334
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1344
>
> + self.state = 1347
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1332
>
> + self.state = 1335
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1333
>
> + self.state = 1336
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1334
>
> + self.state = 1337
>
> self.flagsField()
>
> - self.state = 1339
>
> + self.state = 1342
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1335
>
> + self.state = 1338
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1336
>
> + self.state = 1339
>
> self.flagsField()
>
> - self.state = 1341
>
> + self.state = 1344
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1342
>
> + self.state = 1345
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1346
>
> - self.vfrStatementExpression()
>
> - self.state = 1347
>
> - self.match(VfrSyntaxParser.EndIf)
>
> self.state = 1349
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1350
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 1352
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1348
>
> + self.state = 1351
>
> self.match(VfrSyntaxParser.Semicolon)
>
>
>
>
>
> @@ -8798,7 +8806,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)
>
>
>
> def NoSubmitIf(self):
>
> return self.getToken(VfrSyntaxParser.NoSubmitIf, 0)
>
> @@ -8869,57 +8877,57 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1351
>
> + self.state = 1354
>
> self.match(VfrSyntaxParser.NoSubmitIf)
>
> - self.state = 1352
>
> + self.state = 1355
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 1353
>
> + self.state = 1356
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1354
>
> + self.state = 1357
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1355
>
> + self.state = 1358
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1356
>
> + self.state = 1359
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1357
>
> + self.state = 1360
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1358
>
> + self.state = 1361
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1371
>
> + self.state = 1374
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1359
>
> + self.state = 1362
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1360
>
> + self.state = 1363
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1361
>
> + self.state = 1364
>
> self.flagsField()
>
> - self.state = 1366
>
> + self.state = 1369
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1362
>
> + self.state = 1365
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1363
>
> + self.state = 1366
>
> self.flagsField()
>
> - self.state = 1368
>
> + self.state = 1371
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1369
>
> + self.state = 1372
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1373
>
> - self.vfrStatementExpression()
>
> - self.state = 1374
>
> - self.match(VfrSyntaxParser.EndIf)
>
> self.state = 1376
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1377
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 1379
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1375
>
> + self.state = 1378
>
> self.match(VfrSyntaxParser.Semicolon)
>
>
>
>
>
> @@ -8937,7 +8945,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
>
>
>
> def DisableIf(self):
>
> return self.getToken(VfrSyntaxParser.DisableIf, 0)
>
> @@ -8977,21 +8985,21 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 142, self.RULE_vfrStatementDisableIfQuest)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1378
>
> + self.state = 1381
>
> self.match(VfrSyntaxParser.DisableIf)
>
> - self.state = 1379
>
> - self.vfrStatementExpression()
>
> - self.state = 1380
>
> + self.state = 1382
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1383
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 1381
>
> + self.state = 1384
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1382
>
> + self.state = 1385
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 1384
>
> + self.state = 1387
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1383
>
> + self.state = 1386
>
> self.match(VfrSyntaxParser.Semicolon)
>
>
>
>
>
> @@ -9009,7 +9017,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_REFRESH_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_REFRESH_OP)
>
>
>
> def Refresh(self):
>
> return self.getToken(VfrSyntaxParser.Refresh, 0)
>
> @@ -9038,13 +9046,13 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 144, self.RULE_vfrStatementRefresh)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1386
>
> + self.state = 1389
>
> self.match(VfrSyntaxParser.Refresh)
>
> - self.state = 1387
>
> + self.state = 1390
>
> self.match(VfrSyntaxParser.Interval)
>
> - self.state = 1388
>
> + self.state = 1391
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1389
>
> + self.state = 1392
>
> self.match(VfrSyntaxParser.Number)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -9060,7 +9068,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)
>
>
>
> def VarstoreDevice(self):
>
> return self.getToken(VfrSyntaxParser.VarstoreDevice, 0)
>
> @@ -9098,19 +9106,19 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 146, self.RULE_vfrStatementVarstoreDevice)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1391
>
> + self.state = 1394
>
> self.match(VfrSyntaxParser.VarstoreDevice)
>
> - self.state = 1392
>
> + self.state = 1395
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1393
>
> + self.state = 1396
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1394
>
> + self.state = 1397
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1395
>
> + self.state = 1398
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1396
>
> + self.state = 1399
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1397
>
> + self.state = 1400
>
> self.match(VfrSyntaxParser.Comma)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -9126,7 +9134,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_REFRESH_ID_OP)
>
>
>
> def RefreshGuid(self):
>
> return self.getToken(VfrSyntaxParser.RefreshGuid, 0)
>
> @@ -9156,13 +9164,13 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 148, self.RULE_vfrStatementRefreshEvent)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1399
>
> + self.state = 1402
>
> self.match(VfrSyntaxParser.RefreshGuid)
>
> - self.state = 1400
>
> + self.state = 1403
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1401
>
> + self.state = 1404
>
> self.guidDefinition()
>
> - self.state = 1402
>
> + self.state = 1405
>
> self.match(VfrSyntaxParser.Comma)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -9178,7 +9186,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_WARNING_IF_OP)
>
>
>
> def WarningIf(self):
>
> return self.getToken(VfrSyntaxParser.WarningIf, 0)
>
> @@ -9239,45 +9247,45 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1404
>
> + self.state = 1407
>
> self.match(VfrSyntaxParser.WarningIf)
>
> - self.state = 1405
>
> + self.state = 1408
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 1406
>
> + self.state = 1409
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1407
>
> + self.state = 1410
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1408
>
> + self.state = 1411
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1409
>
> + self.state = 1412
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1410
>
> + self.state = 1413
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1411
>
> + self.state = 1414
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1416
>
> + self.state = 1419
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Timeout:
>
> - self.state = 1412
>
> + self.state = 1415
>
> self.match(VfrSyntaxParser.Timeout)
>
> - self.state = 1413
>
> + self.state = 1416
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1414
>
> + self.state = 1417
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1415
>
> + self.state = 1418
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1418
>
> - self.vfrStatementExpression()
>
> - self.state = 1419
>
> - self.match(VfrSyntaxParser.EndIf)
>
> self.state = 1421
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1422
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 1424
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1420
>
> + self.state = 1423
>
> self.match(VfrSyntaxParser.Semicolon)
>
>
>
>
>
> @@ -9324,13 +9332,13 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1426
>
> + self.state = 1429
>
> 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.state = 1426
>
> self.vfrStatementQuestionTag()
>
> - self.state = 1428
>
> + self.state = 1431
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -9395,42 +9403,42 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementQuestionOptionTagContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 154, self.RULE_vfrStatementQuestionOptionTag)
>
> try:
>
> - self.state = 1436
>
> + self.state = 1439
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.SuppressIf]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1429
>
> + self.state = 1432
>
> self.vfrStatementSuppressIfQuest()
>
> pass
>
> elif token in [VfrSyntaxParser.GrayOutIf]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1430
>
> + self.state = 1433
>
> self.vfrStatementGrayOutIfQuest()
>
> pass
>
> elif token in [VfrSyntaxParser.Value]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1431
>
> + self.state = 1434
>
> self.vfrStatementValue()
>
> pass
>
> elif token in [VfrSyntaxParser.Default]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1432
>
> + self.state = 1435
>
> self.vfrStatementDefault()
>
> pass
>
> elif token in [VfrSyntaxParser.Option]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1433
>
> + self.state = 1436
>
> self.vfrStatementOptions()
>
> pass
>
> elif token in [VfrSyntaxParser.Read]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 1434
>
> + self.state = 1437
>
> self.vfrStatementRead()
>
> pass
>
> elif token in [VfrSyntaxParser.Write]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 1435
>
> + self.state = 1438
>
> self.vfrStatementWrite()
>
> pass
>
> else:
>
> @@ -9494,47 +9502,47 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.FlagsFieldContext(self, self._ctx, self.state)
>
> self.enterRule(localctx, 156, self.RULE_flagsField)
>
> try:
>
> - self.state = 1446
>
> + self.state = 1449
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1438
>
> + self.state = 1441
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.InteractiveFlag]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1439
>
> + self.state = 1442
>
> self.match(VfrSyntaxParser.InteractiveFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ManufacturingFlag]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1440
>
> + self.state = 1443
>
> self.match(VfrSyntaxParser.ManufacturingFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.DefaultFlag]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1441
>
> + self.state = 1444
>
> self.match(VfrSyntaxParser.DefaultFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ResetRequiredFlag]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1442
>
> + self.state = 1445
>
> self.match(VfrSyntaxParser.ResetRequiredFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 1443
>
> + self.state = 1446
>
> self.match(VfrSyntaxParser.ReconnectRequiredFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.NVAccessFlag]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 1444
>
> + self.state = 1447
>
> localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.LateCheckFlag]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 1445
>
> + self.state = 1448
>
> localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
>
> pass
>
> else:
>
> @@ -9554,7 +9562,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
>
>
> def SuppressIf(self):
>
> return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> @@ -9614,47 +9622,47 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1448
>
> + self.state = 1451
>
> self.match(VfrSyntaxParser.SuppressIf)
>
> - self.state = 1449
>
> - self.vfrStatementExpression()
>
> - self.state = 1450
>
> + self.state = 1452
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1453
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 1463
>
> + self.state = 1466
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1451
>
> + self.state = 1454
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1452
>
> + self.state = 1455
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1453
>
> + self.state = 1456
>
> self.flagsField()
>
> - self.state = 1458
>
> + self.state = 1461
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1454
>
> + self.state = 1457
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1455
>
> + self.state = 1458
>
> self.flagsField()
>
> - self.state = 1460
>
> + self.state = 1463
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1461
>
> + self.state = 1464
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1465
>
> + self.state = 1468
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1466
>
> + self.state = 1469
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 1468
>
> + self.state = 1471
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1467
>
> + self.state = 1470
>
> self.match(VfrSyntaxParser.Semicolon)
>
>
>
>
>
> @@ -9672,7 +9680,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
>
>
> def GrayOutIf(self):
>
> return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
>
> @@ -9732,47 +9740,47 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1470
>
> + self.state = 1473
>
> self.match(VfrSyntaxParser.GrayOutIf)
>
> - self.state = 1471
>
> - self.vfrStatementExpression()
>
> - self.state = 1472
>
> + self.state = 1474
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1475
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 1485
>
> + self.state = 1488
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1473
>
> + self.state = 1476
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1474
>
> + self.state = 1477
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1475
>
> + self.state = 1478
>
> self.flagsField()
>
> - self.state = 1480
>
> + self.state = 1483
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1476
>
> + self.state = 1479
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1477
>
> + self.state = 1480
>
> self.flagsField()
>
> - self.state = 1482
>
> + self.state = 1485
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1483
>
> + self.state = 1486
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1487
>
> + self.state = 1490
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1488
>
> + self.state = 1491
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 1490
>
> + self.state = 1493
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1489
>
> + self.state = 1492
>
> self.match(VfrSyntaxParser.Semicolon)
>
>
>
>
>
> @@ -9790,17 +9798,14 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_DEFAULT_OP)
>
> self.D = None # Token
>
> + self.V = None # VfrStatementValueContext
>
> 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)
>
> @@ -9811,6 +9816,10 @@ class VfrSyntaxParser ( Parser ):
> return
> self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
>
>
>
>
>
> + def vfrStatementValue(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
>
> +
>
> +
>
> def DefaultStore(self):
>
> return self.getToken(VfrSyntaxParser.DefaultStore, 0)
>
>
>
> @@ -9836,40 +9845,40 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1492
>
> + self.state = 1495
>
> localctx.D = self.match(VfrSyntaxParser.Default)
>
>
>
> - self.state = 1500
>
> + self.state = 1503
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Value]:
>
> - self.state = 1493
>
> - self.vfrStatementValue()
>
> - self.state = 1494
>
> + self.state = 1496
>
> + localctx.V = self.vfrStatementValue()
>
> + self.state = 1497
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> elif token in [VfrSyntaxParser.T__5]:
>
> - self.state = 1496
>
> + self.state = 1499
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1497
>
> + self.state = 1500
>
> self.vfrConstantValueField()
>
> - self.state = 1498
>
> + self.state = 1501
>
> self.match(VfrSyntaxParser.Comma)
>
> pass
>
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 1506
>
> + self.state = 1509
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.DefaultStore:
>
> - self.state = 1502
>
> + self.state = 1505
>
> self.match(VfrSyntaxParser.DefaultStore)
>
> - self.state = 1503
>
> + self.state = 1506
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1504
>
> + self.state = 1507
>
> localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 1505
>
> + self.state = 1508
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> @@ -9887,7 +9896,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_VALUE_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_VALUE_OP)
>
>
>
> def Value(self):
>
> return self.getToken(VfrSyntaxParser.Value, 0)
>
> @@ -9914,12 +9923,12 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 164, self.RULE_vfrStatementValue)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1508
>
> + self.state = 1511
>
> self.match(VfrSyntaxParser.Value)
>
> - self.state = 1509
>
> + self.state = 1512
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1510
>
> - self.vfrStatementExpression()
>
> + self.state = 1513
>
> + self.vfrStatementExpression(localctx.Node)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> self._errHandler.reportError(self, re)
>
> @@ -9958,7 +9967,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 166, self.RULE_vfrStatementOptions)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1512
>
> + self.state = 1515
>
> self.vfrStatementOneOfOption()
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -9974,9 +9983,10 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_ONE_OF_OPTION_OP)
>
> self.F = None # Token
>
> self.KN = None # Token
>
> + self.T = None # Token
>
>
>
> def Option(self):
>
> return self.getToken(VfrSyntaxParser.Option, 0)
>
> @@ -10051,63 +10061,63 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1514
>
> + self.state = 1517
>
> self.match(VfrSyntaxParser.Option)
>
> - self.state = 1515
>
> + self.state = 1518
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 1516
>
> + self.state = 1519
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1517
>
> + self.state = 1520
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1518
>
> + self.state = 1521
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1519
>
> + self.state = 1522
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1520
>
> + self.state = 1523
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1521
>
> + self.state = 1524
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1522
>
> + self.state = 1525
>
> self.match(VfrSyntaxParser.Value)
>
> - self.state = 1523
>
> + self.state = 1526
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1524
>
> + self.state = 1527
>
> self.vfrConstantValueField()
>
> - self.state = 1525
>
> + self.state = 1528
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1526
>
> + self.state = 1529
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1527
>
> + self.state = 1530
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1528
>
> + self.state = 1531
>
> self.vfrOneOfOptionFlags()
>
> - self.state = 1533
>
> + self.state = 1536
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
>
> if la_ == 1:
>
> - self.state = 1529
>
> + self.state = 1532
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1530
>
> + self.state = 1533
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1531
>
> + self.state = 1534
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1532
>
> + self.state = 1535
>
> localctx.KN = self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> - self.state = 1539
>
> + self.state = 1542
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.Comma:
>
> - self.state = 1535
>
> - self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1536
>
> + self.state = 1538
>
> + localctx.T = self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1539
>
> self.vfrImageTag()
>
> - self.state = 1541
>
> + self.state = 1544
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 1542
>
> + self.state = 1545
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -10158,17 +10168,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1544
>
> + self.state = 1547
>
> self.oneofoptionFlagsField()
>
> - self.state = 1549
>
> + self.state = 1552
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1545
>
> + self.state = 1548
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1546
>
> + self.state = 1549
>
> self.oneofoptionFlagsField()
>
> - self.state = 1551
>
> + self.state = 1554
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -10241,62 +10251,62 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.OneofoptionFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 172, self.RULE_oneofoptionFlagsField)
>
> try:
>
> - self.state = 1563
>
> + self.state = 1566
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1552
>
> + self.state = 1555
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.OptionDefault]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1553
>
> + self.state = 1556
>
> self.match(VfrSyntaxParser.OptionDefault)
>
> pass
>
> elif token in [VfrSyntaxParser.OptionDefaultMfg]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1554
>
> + self.state = 1557
>
> self.match(VfrSyntaxParser.OptionDefaultMfg)
>
> pass
>
> elif token in [VfrSyntaxParser.InteractiveFlag]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1555
>
> + self.state = 1558
>
> self.match(VfrSyntaxParser.InteractiveFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ResetRequiredFlag]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1556
>
> + self.state = 1559
>
> self.match(VfrSyntaxParser.ResetRequiredFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.RestStyleFlag]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 1557
>
> + self.state = 1560
>
> self.match(VfrSyntaxParser.RestStyleFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 1558
>
> + self.state = 1561
>
> self.match(VfrSyntaxParser.ReconnectRequiredFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ManufacturingFlag]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 1559
>
> + self.state = 1562
>
> self.match(VfrSyntaxParser.ManufacturingFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.DefaultFlag]:
>
> self.enterOuterAlt(localctx, 9)
>
> - self.state = 1560
>
> + self.state = 1563
>
> self.match(VfrSyntaxParser.DefaultFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.NVAccessFlag]:
>
> self.enterOuterAlt(localctx, 10)
>
> - self.state = 1561
>
> + self.state = 1564
>
> localctx.A = self.match(VfrSyntaxParser.NVAccessFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.LateCheckFlag]:
>
> self.enterOuterAlt(localctx, 11)
>
> - self.state = 1562
>
> + self.state = 1565
>
> localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
>
> pass
>
> else:
>
> @@ -10316,7 +10326,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_READ_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_READ_OP)
>
>
>
> def Read(self):
>
> return self.getToken(VfrSyntaxParser.Read, 0)
>
> @@ -10346,11 +10356,11 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 174, self.RULE_vfrStatementRead)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1565
>
> + self.state = 1568
>
> self.match(VfrSyntaxParser.Read)
>
> - self.state = 1566
>
> - self.vfrStatementExpression()
>
> - self.state = 1567
>
> + self.state = 1569
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1570
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -10366,7 +10376,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.Node = VfrTreeNode(EFI_IFR_WRITE_OP)
>
> + self.Node = IfrTreeNode(EFI_IFR_WRITE_OP)
>
>
>
> def Write(self):
>
> return self.getToken(VfrSyntaxParser.Write, 0)
>
> @@ -10396,11 +10406,11 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 176, self.RULE_vfrStatementWrite)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1569
>
> + self.state = 1572
>
> self.match(VfrSyntaxParser.Write)
>
> - self.state = 1570
>
> - self.vfrStatementExpression()
>
> - self.state = 1571
>
> + self.state = 1573
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1574
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -10445,13 +10455,13 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1576
>
> + self.state = 1579
>
> 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.state = 1576
>
> self.vfrStatementQuestionOption()
>
> - self.state = 1578
>
> + self.state = 1581
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -10496,17 +10506,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementQuestionOptionContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 180, self.RULE_vfrStatementQuestionOption)
>
> try:
>
> - self.state = 1581
>
> + self.state = 1584
>
> 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.state = 1582
>
> 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.state = 1583
>
> self.vfrStatementQuestionOptionTag()
>
> pass
>
> else:
>
> @@ -10553,17 +10563,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementBooleanTypeContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 182, self.RULE_vfrStatementBooleanType)
>
> try:
>
> - self.state = 1585
>
> + self.state = 1588
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.CheckBox]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1583
>
> + self.state = 1586
>
> self.vfrStatementCheckBox()
>
> pass
>
> elif token in [VfrSyntaxParser.Action]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1584
>
> + self.state = 1587
>
> self.vfrStatementAction()
>
> pass
>
> else:
>
> @@ -10583,8 +10593,8 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_CHECKBOX_OP)
>
> + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> self.L = None # Token
>
> self.F = None # Token
>
> @@ -10648,47 +10658,47 @@ class VfrSyntaxParser ( Parser ):
> 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
>
> + localctx.L = self.match(VfrSyntaxParser.CheckBox)
>
> + self.state = 1591
>
> + self.vfrQuestionBaseInfo(localctx.Node, localctx.QType)
>
> + self.state = 1592
>
> + self.vfrStatementHeader(localctx.Node)
>
> + self.state = 1593
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1596
>
> + self.state = 1599
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1591
>
> + self.state = 1594
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1592
>
> + self.state = 1595
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1593
>
> + self.state = 1596
>
> self.vfrCheckBoxFlags()
>
> - self.state = 1594
>
> + self.state = 1597
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1602
>
> + self.state = 1605
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Key:
>
> - self.state = 1598
>
> + self.state = 1601
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1599
>
> + self.state = 1602
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1600
>
> + self.state = 1603
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1601
>
> + self.state = 1604
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1604
>
> + self.state = 1607
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1605
>
> + self.state = 1608
>
> self.match(VfrSyntaxParser.EndCheckBox)
>
> - self.state = 1606
>
> + self.state = 1609
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -10739,17 +10749,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1608
>
> + self.state = 1611
>
> self.checkboxFlagsField()
>
> - self.state = 1613
>
> + self.state = 1616
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1609
>
> + self.state = 1612
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1610
>
> + self.state = 1613
>
> self.checkboxFlagsField()
>
> - self.state = 1615
>
> + self.state = 1618
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -10808,37 +10818,37 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.CheckboxFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 188, self.RULE_checkboxFlagsField)
>
> try:
>
> - self.state = 1622
>
> + self.state = 1625
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1616
>
> + self.state = 1619
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.DefaultFlag]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1617
>
> + self.state = 1620
>
> localctx.D = self.match(VfrSyntaxParser.DefaultFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.ManufacturingFlag]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1618
>
> + self.state = 1621
>
> localctx.M = self.match(VfrSyntaxParser.ManufacturingFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.CheckBoxDefaultFlag]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1619
>
> + self.state = 1622
>
> self.match(VfrSyntaxParser.CheckBoxDefaultFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.CheckBoxDefaultMfgFlag]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1620
>
> + self.state = 1623
>
> 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.state = 1624
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -10858,8 +10868,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_ACTION_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
>
>
> def Action(self):
>
> @@ -10926,45 +10935,45 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1624
>
> + self.state = 1627
>
> self.match(VfrSyntaxParser.Action)
>
> - self.state = 1625
>
> - self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
>
> - self.state = 1626
>
> + self.state = 1628
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1629
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1632
>
> + self.state = 1635
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1627
>
> + self.state = 1630
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1628
>
> + self.state = 1631
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1629
>
> + self.state = 1632
>
> self.vfrActionFlags()
>
> - self.state = 1630
>
> + self.state = 1633
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1634
>
> + self.state = 1637
>
> self.match(VfrSyntaxParser.Config)
>
> - self.state = 1635
>
> + self.state = 1638
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1636
>
> + self.state = 1639
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 1637
>
> + self.state = 1640
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 1638
>
> + self.state = 1641
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1639
>
> + self.state = 1642
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 1640
>
> + self.state = 1643
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1641
>
> + self.state = 1644
>
> self.vfrStatementQuestionTagList(localctx.Node)
>
> - self.state = 1642
>
> + self.state = 1645
>
> self.match(VfrSyntaxParser.EndAction)
>
> - self.state = 1643
>
> + self.state = 1646
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -11014,17 +11023,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1645
>
> + self.state = 1648
>
> self.actionFlagsField()
>
> - self.state = 1650
>
> + self.state = 1653
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1646
>
> + self.state = 1649
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1647
>
> + self.state = 1650
>
> self.actionFlagsField()
>
> - self.state = 1652
>
> + self.state = 1655
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -11069,17 +11078,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.ActionFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 194, self.RULE_actionFlagsField)
>
> try:
>
> - self.state = 1655
>
> + self.state = 1658
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1653
>
> + self.state = 1656
>
> 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.state = 1657
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -11126,17 +11135,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementNumericTypeContext(self,
> self._ctx, self.state)
>
> self.enterRule(localctx, 196, self.RULE_vfrStatementNumericType)
>
> try:
>
> - self.state = 1659
>
> + self.state = 1662
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Numeric]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1657
>
> + self.state = 1660
>
> self.vfrStatementNumeric()
>
> pass
>
> elif token in [VfrSyntaxParser.OneOf]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1658
>
> + self.state = 1661
>
> self.vfrStatementOneOf()
>
> pass
>
> else:
>
> @@ -11156,8 +11165,8 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_NUMERIC_OP)
>
> + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> self.F = None # Token
>
>
>
> @@ -11224,49 +11233,49 @@ class VfrSyntaxParser ( Parser ):
> 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.Numeric)
>
> + self.state = 1665
>
> + self.vfrQuestionBaseInfo(localctx.Node, localctx.QType)
>
> + self.state = 1666
>
> + self.vfrStatementHeader(localctx.Node)
>
> + self.state = 1667
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1670
>
> + self.state = 1673
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1665
>
> + self.state = 1668
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1666
>
> + self.state = 1669
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1667
>
> + self.state = 1670
>
> self.vfrNumericFlags()
>
> - self.state = 1668
>
> + self.state = 1671
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1676
>
> + self.state = 1679
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Key:
>
> - self.state = 1672
>
> + self.state = 1675
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1673
>
> + self.state = 1676
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1674
>
> + self.state = 1677
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1675
>
> + self.state = 1678
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1678
>
> - self.vfrSetMinMaxStep(localctx.OpObj)
>
> - self.state = 1679
>
> + self.state = 1681
>
> + self.vfrSetMinMaxStep(localctx.Node)
>
> + self.state = 1682
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1680
>
> + self.state = 1683
>
> self.match(VfrSyntaxParser.EndNumeric)
>
> - self.state = 1681
>
> + self.state = 1684
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -11279,16 +11288,16 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrSetMinMaxStepContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, OpObj=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.OpObj = None
>
> + self.Node = None
>
> self.N1 = None # Token
>
> self.I = None # Token
>
> self.N2 = None # Token
>
> self.A = None # Token
>
> self.S = None # Token
>
> - self.OpObj = OpObj
>
> + self.Node = Node
>
>
>
> def Minimum(self):
>
> return self.getToken(VfrSyntaxParser.Minimum, 0)
>
> @@ -11329,56 +11338,56 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrSetMinMaxStep(self, OpObj):
>
> + def vfrSetMinMaxStep(self, Node):
>
>
>
> - localctx = VfrSyntaxParser.VfrSetMinMaxStepContext(self, self._ctx,
> self.state, OpObj)
>
> + localctx = VfrSyntaxParser.VfrSetMinMaxStepContext(self, self._ctx,
> self.state, Node)
>
> self.enterRule(localctx, 200, self.RULE_vfrSetMinMaxStep)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1683
>
> + self.state = 1686
>
> self.match(VfrSyntaxParser.Minimum)
>
> - self.state = 1684
>
> + self.state = 1687
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1686
>
> + self.state = 1689
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Negative:
>
> - self.state = 1685
>
> + self.state = 1688
>
> localctx.N1 = self.match(VfrSyntaxParser.Negative)
>
>
>
>
>
> - self.state = 1688
>
> + self.state = 1691
>
> localctx.I = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1689
>
> + self.state = 1692
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1690
>
> + self.state = 1693
>
> self.match(VfrSyntaxParser.Maximum)
>
> - self.state = 1691
>
> + self.state = 1694
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1693
>
> + self.state = 1696
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Negative:
>
> - self.state = 1692
>
> + self.state = 1695
>
> localctx.N2 = self.match(VfrSyntaxParser.Negative)
>
>
>
>
>
> - self.state = 1695
>
> + self.state = 1698
>
> localctx.A = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1696
>
> + self.state = 1699
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1701
>
> + self.state = 1704
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Step:
>
> - self.state = 1697
>
> + self.state = 1700
>
> self.match(VfrSyntaxParser.Step)
>
> - self.state = 1698
>
> + self.state = 1701
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1699
>
> + self.state = 1702
>
> localctx.S = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1700
>
> + self.state = 1703
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> @@ -11399,6 +11408,7 @@ class VfrSyntaxParser ( Parser ):
> self.HFlags = 0
>
> self.LFlags = 0
>
> self.IsDisplaySpecified = False
>
> + self.UpdateVarType = False
>
>
>
> def numericFlagsField(self, i:int=None):
>
> if i is None:
>
> @@ -11432,17 +11442,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1703
>
> + self.state = 1706
>
> self.numericFlagsField()
>
> - self.state = 1708
>
> + self.state = 1711
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1704
>
> + self.state = 1707
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1705
>
> + self.state = 1708
>
> self.numericFlagsField()
>
> - self.state = 1710
>
> + self.state = 1713
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -11510,52 +11520,52 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.NumericFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 204, self.RULE_numericFlagsField)
>
> try:
>
> - self.state = 1720
>
> + self.state = 1723
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1711
>
> + self.state = 1714
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.NumericSizeOne]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1712
>
> + self.state = 1715
>
> self.match(VfrSyntaxParser.NumericSizeOne)
>
> pass
>
> elif token in [VfrSyntaxParser.NumericSizeTwo]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1713
>
> + self.state = 1716
>
> self.match(VfrSyntaxParser.NumericSizeTwo)
>
> pass
>
> elif token in [VfrSyntaxParser.NumericSizeFour]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 1714
>
> + self.state = 1717
>
> self.match(VfrSyntaxParser.NumericSizeFour)
>
> pass
>
> elif token in [VfrSyntaxParser.NumericSizeEight]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 1715
>
> + self.state = 1718
>
> self.match(VfrSyntaxParser.NumericSizeEight)
>
> pass
>
> elif token in [VfrSyntaxParser.DisPlayIntDec]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 1716
>
> + self.state = 1719
>
> self.match(VfrSyntaxParser.DisPlayIntDec)
>
> pass
>
> elif token in [VfrSyntaxParser.DisPlayUIntDec]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 1717
>
> + self.state = 1720
>
> self.match(VfrSyntaxParser.DisPlayUIntDec)
>
> pass
>
> elif token in [VfrSyntaxParser.DisPlayUIntHex]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 1718
>
> + self.state = 1721
>
> 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.state = 1722
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -11575,8 +11585,8 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_ONE_OF_OP)
>
> + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> self.F = None # Token
>
>
>
> @@ -11637,41 +11647,41 @@ class VfrSyntaxParser ( Parser ):
> 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.OneOf)
>
> + self.state = 1726
>
> + self.vfrQuestionBaseInfo(localctx.Node, localctx.QType)
>
> + self.state = 1727
>
> + self.vfrStatementHeader(localctx.Node)
>
> + self.state = 1728
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1731
>
> + self.state = 1734
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1726
>
> + self.state = 1729
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1727
>
> + self.state = 1730
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1728
>
> + self.state = 1731
>
> self.vfrOneofFlagsField()
>
> - self.state = 1729
>
> + self.state = 1732
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1734
>
> + self.state = 1737
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Minimum:
>
> - self.state = 1733
>
> - self.vfrSetMinMaxStep(localctx.OpObj)
>
> + self.state = 1736
>
> + self.vfrSetMinMaxStep(localctx.Node)
>
>
>
>
>
> - self.state = 1736
>
> + self.state = 1739
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1737
>
> + self.state = 1740
>
> self.match(VfrSyntaxParser.EndOneOf)
>
> - self.state = 1738
>
> + self.state = 1741
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -11689,6 +11699,7 @@ class VfrSyntaxParser ( Parser ):
> self.parser = parser
>
> self.HFlags = 0
>
> self.LFlags = 0
>
> + self.UpdateVarType = False
>
>
>
> def numericFlagsField(self, i:int=None):
>
> if i is None:
>
> @@ -11722,17 +11733,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1740
>
> + self.state = 1743
>
> self.numericFlagsField()
>
> - self.state = 1745
>
> + self.state = 1748
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1741
>
> + self.state = 1744
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1742
>
> + self.state = 1745
>
> self.numericFlagsField()
>
> - self.state = 1747
>
> + self.state = 1750
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -11777,17 +11788,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementStringTypeContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 210, self.RULE_vfrStatementStringType)
>
> try:
>
> - self.state = 1750
>
> + self.state = 1753
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.String]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1748
>
> + self.state = 1751
>
> self.vfrStatementString()
>
> pass
>
> elif token in [VfrSyntaxParser.Password]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1749
>
> + self.state = 1752
>
> self.vfrStatementPassword()
>
> pass
>
> else:
>
> @@ -11807,8 +11818,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_STRING_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> self.F = None # Token
>
> self.Min = None # Token
>
> @@ -11878,61 +11888,61 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1752
>
> + self.state = 1755
>
> self.match(VfrSyntaxParser.String)
>
> - self.state = 1753
>
> - self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
>
> - self.state = 1754
>
> + self.state = 1756
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1757
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1760
>
> + self.state = 1763
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1755
>
> + self.state = 1758
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1756
>
> + self.state = 1759
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1757
>
> + self.state = 1760
>
> self.vfrStringFlagsField()
>
> - self.state = 1758
>
> + self.state = 1761
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1766
>
> + self.state = 1769
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Key:
>
> - self.state = 1762
>
> + self.state = 1765
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1763
>
> + self.state = 1766
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1764
>
> + self.state = 1767
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1765
>
> + self.state = 1768
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1768
>
> + self.state = 1771
>
> localctx.Min = self.match(VfrSyntaxParser.MinSize)
>
> - self.state = 1769
>
> + self.state = 1772
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1770
>
> + self.state = 1773
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1771
>
> + self.state = 1774
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1772
>
> + self.state = 1775
>
> localctx.Max = self.match(VfrSyntaxParser.MaxSize)
>
> - self.state = 1773
>
> + self.state = 1776
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1774
>
> + self.state = 1777
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1775
>
> + self.state = 1778
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1776
>
> + self.state = 1779
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1777
>
> + self.state = 1780
>
> self.match(VfrSyntaxParser.EndString)
>
> - self.state = 1778
>
> + self.state = 1781
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -11983,17 +11993,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1780
>
> + self.state = 1783
>
> self.stringFlagsField()
>
> - self.state = 1785
>
> + self.state = 1788
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1781
>
> + self.state = 1784
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1782
>
> + self.state = 1785
>
> self.stringFlagsField()
>
> - self.state = 1787
>
> + self.state = 1790
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -12039,22 +12049,22 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.StringFlagsFieldContext(self, self._ctx, self.state)
>
> self.enterRule(localctx, 216, self.RULE_stringFlagsField)
>
> try:
>
> - self.state = 1791
>
> + self.state = 1794
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1788
>
> + self.state = 1791
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.T__8]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1789
>
> + self.state = 1792
>
> 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.state = 1793
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -12074,8 +12084,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_PASSWORD_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> self.F = None # Token
>
> self.Min = None # Token
>
> @@ -12148,75 +12157,75 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1793
>
> + self.state = 1796
>
> self.match(VfrSyntaxParser.Password)
>
> - self.state = 1794
>
> - self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
>
> - self.state = 1795
>
> + self.state = 1797
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1798
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1801
>
> + self.state = 1804
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1796
>
> + self.state = 1799
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1797
>
> + self.state = 1800
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1798
>
> + self.state = 1801
>
> self.vfrPasswordFlagsField()
>
> - self.state = 1799
>
> + self.state = 1802
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1807
>
> + self.state = 1810
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Key:
>
> - self.state = 1803
>
> + self.state = 1806
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 1804
>
> + self.state = 1807
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1805
>
> + self.state = 1808
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1806
>
> + self.state = 1809
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1809
>
> + self.state = 1812
>
> localctx.Min = self.match(VfrSyntaxParser.MinSize)
>
> - self.state = 1810
>
> + self.state = 1813
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1811
>
> + self.state = 1814
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1812
>
> + self.state = 1815
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1813
>
> + self.state = 1816
>
> localctx.Max = self.match(VfrSyntaxParser.MaxSize)
>
> - self.state = 1814
>
> + self.state = 1817
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1815
>
> + self.state = 1818
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1816
>
> + self.state = 1819
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1821
>
> + self.state = 1824
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Encoding:
>
> - self.state = 1817
>
> + self.state = 1820
>
> self.match(VfrSyntaxParser.Encoding)
>
> - self.state = 1818
>
> + self.state = 1821
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1819
>
> + self.state = 1822
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1820
>
> + self.state = 1823
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1823
>
> + self.state = 1826
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1824
>
> + self.state = 1827
>
> self.match(VfrSyntaxParser.EndPassword)
>
> - self.state = 1825
>
> + self.state = 1828
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -12266,17 +12275,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1827
>
> + self.state = 1830
>
> self.passwordFlagsField()
>
> - self.state = 1832
>
> + self.state = 1835
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1828
>
> + self.state = 1831
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1829
>
> + self.state = 1832
>
> self.passwordFlagsField()
>
> - self.state = 1834
>
> + self.state = 1837
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -12320,17 +12329,17 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.PasswordFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 222, self.RULE_passwordFlagsField)
>
> try:
>
> - self.state = 1837
>
> + self.state = 1840
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1835
>
> + self.state = 1838
>
> 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.state = 1839
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -12350,8 +12359,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_ORDERED_LIST_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> self.M = None # Token
>
> self.F = None # Token
>
> @@ -12411,45 +12419,45 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1839
>
> + self.state = 1842
>
> self.match(VfrSyntaxParser.OrderedList)
>
> - self.state = 1840
>
> - self.vfrQuestionHeader(localctx.OpObj, localctx.QType)
>
> - self.state = 1841
>
> + self.state = 1843
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1844
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1846
>
> + self.state = 1849
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.MaxContainers:
>
> - self.state = 1842
>
> + self.state = 1845
>
> localctx.M = self.match(VfrSyntaxParser.MaxContainers)
>
> - self.state = 1843
>
> + self.state = 1846
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1844
>
> + self.state = 1847
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1845
>
> + self.state = 1848
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1853
>
> + self.state = 1856
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1848
>
> + self.state = 1851
>
> localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1849
>
> + self.state = 1852
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1850
>
> + self.state = 1853
>
> self.vfrOrderedListFlags()
>
> - self.state = 1851
>
> + self.state = 1854
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1855
>
> + self.state = 1858
>
> self.vfrStatementQuestionOptionList(localctx.Node)
>
> - self.state = 1856
>
> + self.state = 1859
>
> self.match(VfrSyntaxParser.EndList)
>
> - self.state = 1857
>
> + self.state = 1860
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -12500,17 +12508,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1859
>
> + self.state = 1862
>
> self.orderedlistFlagsField()
>
> - self.state = 1864
>
> + self.state = 1867
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1860
>
> + self.state = 1863
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1861
>
> + self.state = 1864
>
> self.orderedlistFlagsField()
>
> - self.state = 1866
>
> + self.state = 1869
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -12561,27 +12569,27 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.OrderedlistFlagsFieldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 228, self.RULE_orderedlistFlagsField)
>
> try:
>
> - self.state = 1871
>
> + self.state = 1874
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1867
>
> + self.state = 1870
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.UniQueFlag]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 1868
>
> + self.state = 1871
>
> self.match(VfrSyntaxParser.UniQueFlag)
>
> pass
>
> elif token in [VfrSyntaxParser.NoEmptyFlag]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 1869
>
> + self.state = 1872
>
> 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.state = 1873
>
> self.questionheaderFlagsField()
>
> pass
>
> else:
>
> @@ -12601,10 +12609,9 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_DATE_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_DATE
>
> - self.Val = EFI_IFR_TYPE_VALUE()
>
> + self.Val = EFI_HII_DATE()
>
> self.F1 = None # Token
>
> self.F2 = None # Token
>
>
>
> @@ -12734,187 +12741,187 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1873
>
> + self.state = 1876
>
> self.match(VfrSyntaxParser.Date)
>
> - self.state = 1964
>
> + self.state = 1967
>
> 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.state = 1877
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1878
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1881
>
> + self.state = 1884
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1876
>
> + self.state = 1879
>
> localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1877
>
> + self.state = 1880
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1878
>
> + self.state = 1881
>
> self.vfrDateFlags()
>
> - self.state = 1879
>
> + self.state = 1882
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1883
>
> + self.state = 1886
>
> 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.match(VfrSyntaxParser.Year)
>
> self.state = 1889
>
> - self.match(VfrSyntaxParser.Dot)
>
> + self.match(VfrSyntaxParser.VarId)
>
> self.state = 1890
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1891
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 1892
>
> - self.match(VfrSyntaxParser.Prompt)
>
> + self.match(VfrSyntaxParser.Dot)
>
> self.state = 1893
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 1894
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1895
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Prompt)
>
> self.state = 1896
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1897
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 1898
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 1899
>
> - self.match(VfrSyntaxParser.Help)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 1900
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 1901
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1902
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Help)
>
> self.state = 1903
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1904
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 1905
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 1906
>
> - self.minMaxDateStepDefault(localctx.Val.date, 0)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 1907
>
> - self.match(VfrSyntaxParser.Month)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 1908
>
> - self.match(VfrSyntaxParser.VarId)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1909
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 0)
>
> self.state = 1910
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.Month)
>
> self.state = 1911
>
> - self.match(VfrSyntaxParser.Dot)
>
> + self.match(VfrSyntaxParser.VarId)
>
> self.state = 1912
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1913
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 1914
>
> - self.match(VfrSyntaxParser.Prompt)
>
> + self.match(VfrSyntaxParser.Dot)
>
> self.state = 1915
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 1916
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1917
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Prompt)
>
> self.state = 1918
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1919
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 1920
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 1921
>
> - self.match(VfrSyntaxParser.Help)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 1922
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 1923
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1924
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Help)
>
> self.state = 1925
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1926
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 1927
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 1928
>
> - self.minMaxDateStepDefault(localctx.Val.date, 1)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 1929
>
> - self.match(VfrSyntaxParser.Day)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 1930
>
> - self.match(VfrSyntaxParser.VarId)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1931
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 1)
>
> self.state = 1932
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.Day)
>
> self.state = 1933
>
> - self.match(VfrSyntaxParser.Dot)
>
> + self.match(VfrSyntaxParser.VarId)
>
> self.state = 1934
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1935
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 1936
>
> - self.match(VfrSyntaxParser.Prompt)
>
> + self.match(VfrSyntaxParser.Dot)
>
> self.state = 1937
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 1938
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1939
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Prompt)
>
> self.state = 1940
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1941
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 1942
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 1943
>
> - self.match(VfrSyntaxParser.Help)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 1944
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 1945
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 1946
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Help)
>
> self.state = 1947
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 1948
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 1949
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 1950
>
> - self.minMaxDateStepDefault(localctx.Val.date, 2)
>
> - self.state = 1956
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1951
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1952
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1953
>
> + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 2)
>
> + self.state = 1959
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 1951
>
> + self.state = 1954
>
> localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 1952
>
> + self.state = 1955
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1953
>
> + self.state = 1956
>
> self.vfrDateFlags()
>
> - self.state = 1954
>
> + self.state = 1957
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1961
>
> + self.state = 1964
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.InconsistentIf:
>
> - self.state = 1958
>
> + self.state = 1961
>
> self.vfrStatementInconsistentIf()
>
> - self.state = 1963
>
> + self.state = 1966
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -12922,9 +12929,9 @@ class VfrSyntaxParser ( Parser ):
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 1966
>
> + self.state = 1969
>
> self.match(VfrSyntaxParser.EndDate)
>
> - self.state = 1967
>
> + self.state = 1970
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -12937,12 +12944,14 @@ class VfrSyntaxParser ( Parser ):
>
>
> class MinMaxDateStepDefaultContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Date=None, KeyValue=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None, Date=None, KeyValue=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> + self.Node = None
>
> self.Date = None
>
> self.KeyValue = None
>
> self.N = None # Token
>
> + self.Node = Node
>
> self.Date = Date
>
> self.KeyValue = KeyValue
>
>
>
> @@ -12982,54 +12991,54 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def minMaxDateStepDefault(self, Date, KeyValue):
>
> + def minMaxDateStepDefault(self, Node, Date, KeyValue):
>
>
>
> - localctx = VfrSyntaxParser.MinMaxDateStepDefaultContext(self, self._ctx,
> self.state, Date, KeyValue)
>
> + localctx = VfrSyntaxParser.MinMaxDateStepDefaultContext(self, self._ctx,
> self.state, Node, Date, KeyValue)
>
> self.enterRule(localctx, 232, self.RULE_minMaxDateStepDefault)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1969
>
> + self.state = 1972
>
> self.match(VfrSyntaxParser.Minimum)
>
> - self.state = 1970
>
> + self.state = 1973
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1971
>
> + self.state = 1974
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1972
>
> + self.state = 1975
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1973
>
> + self.state = 1976
>
> self.match(VfrSyntaxParser.Maximum)
>
> - self.state = 1974
>
> + self.state = 1977
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1975
>
> + self.state = 1978
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1976
>
> + self.state = 1979
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 1981
>
> + self.state = 1984
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Step:
>
> - self.state = 1977
>
> + self.state = 1980
>
> self.match(VfrSyntaxParser.Step)
>
> - self.state = 1978
>
> + self.state = 1981
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1979
>
> + self.state = 1982
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 1980
>
> + self.state = 1983
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 1987
>
> + self.state = 1990
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Default:
>
> - self.state = 1983
>
> + self.state = 1986
>
> self.match(VfrSyntaxParser.Default)
>
> - self.state = 1984
>
> + self.state = 1987
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 1985
>
> + self.state = 1988
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> - self.state = 1986
>
> + self.state = 1989
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> @@ -13081,17 +13090,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1989
>
> + self.state = 1992
>
> self.dateFlagsField()
>
> - self.state = 1994
>
> + self.state = 1997
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 1990
>
> + self.state = 1993
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 1991
>
> + self.state = 1994
>
> self.dateFlagsField()
>
> - self.state = 1996
>
> + self.state = 1999
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -13151,7 +13160,7 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1997
>
> + self.state = 2000
>
> _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)
>
> @@ -13172,10 +13181,9 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_TIME_OP)
>
> self.QType = EFI_QUESION_TYPE.QUESTION_TIME
>
> - self.Val = EFI_IFR_TYPE_VALUE()
>
> + self.Val = EFI_HII_TIME()
>
> self.F1 = None # Token
>
> self.F2 = None # Token
>
>
>
> @@ -13305,187 +13313,187 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 1999
>
> + self.state = 2002
>
> self.match(VfrSyntaxParser.Time)
>
> - self.state = 2090
>
> + self.state = 2093
>
> 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.state = 2003
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 2004
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2007
>
> + self.state = 2010
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2002
>
> + self.state = 2005
>
> localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2003
>
> + self.state = 2006
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2004
>
> + self.state = 2007
>
> self.vfrTimeFlags()
>
> - self.state = 2005
>
> + self.state = 2008
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2009
>
> + self.state = 2012
>
> 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.match(VfrSyntaxParser.Hour)
>
> self.state = 2015
>
> - self.match(VfrSyntaxParser.Dot)
>
> + self.match(VfrSyntaxParser.VarId)
>
> self.state = 2016
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2017
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2018
>
> - self.match(VfrSyntaxParser.Prompt)
>
> + self.match(VfrSyntaxParser.Dot)
>
> self.state = 2019
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2020
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2021
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Prompt)
>
> self.state = 2022
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2023
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 2024
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2025
>
> - self.match(VfrSyntaxParser.Help)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 2026
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 2027
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2028
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Help)
>
> self.state = 2029
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2030
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 2031
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2032
>
> - self.minMaxTimeStepDefault(localctx.Val.time, 0)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 2033
>
> - self.match(VfrSyntaxParser.Minute)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 2034
>
> - self.match(VfrSyntaxParser.VarId)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2035
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 0)
>
> self.state = 2036
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.Minute)
>
> self.state = 2037
>
> - self.match(VfrSyntaxParser.Dot)
>
> + self.match(VfrSyntaxParser.VarId)
>
> self.state = 2038
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2039
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2040
>
> - self.match(VfrSyntaxParser.Prompt)
>
> + self.match(VfrSyntaxParser.Dot)
>
> self.state = 2041
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2042
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2043
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Prompt)
>
> self.state = 2044
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2045
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 2046
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2047
>
> - self.match(VfrSyntaxParser.Help)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 2048
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 2049
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2050
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Help)
>
> self.state = 2051
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2052
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 2053
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2054
>
> - self.minMaxTimeStepDefault(localctx.Val.time, 1)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 2055
>
> - self.match(VfrSyntaxParser.Second)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 2056
>
> - self.match(VfrSyntaxParser.VarId)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2057
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 1)
>
> self.state = 2058
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.Second)
>
> self.state = 2059
>
> - self.match(VfrSyntaxParser.Dot)
>
> + self.match(VfrSyntaxParser.VarId)
>
> self.state = 2060
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2061
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2062
>
> - self.match(VfrSyntaxParser.Prompt)
>
> + self.match(VfrSyntaxParser.Dot)
>
> self.state = 2063
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2064
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2065
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Prompt)
>
> self.state = 2066
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2067
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 2068
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2069
>
> - self.match(VfrSyntaxParser.Help)
>
> + self.match(VfrSyntaxParser.Number)
>
> self.state = 2070
>
> - self.match(VfrSyntaxParser.T__5)
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> self.state = 2071
>
> - self.match(VfrSyntaxParser.StringToken)
>
> + self.match(VfrSyntaxParser.Comma)
>
> self.state = 2072
>
> - self.match(VfrSyntaxParser.OpenParen)
>
> + self.match(VfrSyntaxParser.Help)
>
> self.state = 2073
>
> - self.match(VfrSyntaxParser.Number)
>
> + self.match(VfrSyntaxParser.T__5)
>
> self.state = 2074
>
> - self.match(VfrSyntaxParser.CloseParen)
>
> + self.match(VfrSyntaxParser.StringToken)
>
> self.state = 2075
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2076
>
> - self.minMaxTimeStepDefault(localctx.Val.time, 2)
>
> - self.state = 2082
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2077
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2078
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2079
>
> + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 2)
>
> + self.state = 2085
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2077
>
> + self.state = 2080
>
> localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2078
>
> + self.state = 2081
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2079
>
> + self.state = 2082
>
> self.vfrTimeFlags()
>
> - self.state = 2080
>
> + self.state = 2083
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2087
>
> + self.state = 2090
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.InconsistentIf:
>
> - self.state = 2084
>
> + self.state = 2087
>
> self.vfrStatementInconsistentIf()
>
> - self.state = 2089
>
> + self.state = 2092
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -13493,9 +13501,9 @@ class VfrSyntaxParser ( Parser ):
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 2092
>
> + self.state = 2095
>
> self.match(VfrSyntaxParser.EndTime)
>
> - self.state = 2093
>
> + self.state = 2096
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -13508,12 +13516,14 @@ class VfrSyntaxParser ( Parser ):
>
>
> class MinMaxTimeStepDefaultContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Time=None, KeyValue=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None, Time=None, KeyValue=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> + self.Node = None
>
> self.Time = None
>
> self.KeyValue = None
>
> self.N = None # Token
>
> + self.Node = Node
>
> self.Time = Time
>
> self.KeyValue = KeyValue
>
>
>
> @@ -13553,54 +13563,54 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def minMaxTimeStepDefault(self, Time, KeyValue):
>
> + def minMaxTimeStepDefault(self, Node, Time, KeyValue):
>
>
>
> - localctx = VfrSyntaxParser.MinMaxTimeStepDefaultContext(self, self._ctx,
> self.state, Time, KeyValue)
>
> + localctx = VfrSyntaxParser.MinMaxTimeStepDefaultContext(self,
> self._ctx, self.state, Node, Time, KeyValue)
>
> self.enterRule(localctx, 240, self.RULE_minMaxTimeStepDefault)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2095
>
> + self.state = 2098
>
> self.match(VfrSyntaxParser.Minimum)
>
> - self.state = 2096
>
> + self.state = 2099
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2097
>
> + self.state = 2100
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2098
>
> + self.state = 2101
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2099
>
> + self.state = 2102
>
> self.match(VfrSyntaxParser.Maximum)
>
> - self.state = 2100
>
> + self.state = 2103
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2101
>
> + self.state = 2104
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2102
>
> + self.state = 2105
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2107
>
> + self.state = 2110
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Step:
>
> - self.state = 2103
>
> + self.state = 2106
>
> self.match(VfrSyntaxParser.Step)
>
> - self.state = 2104
>
> + self.state = 2107
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2105
>
> + self.state = 2108
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2106
>
> + self.state = 2109
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2113
>
> + self.state = 2116
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Default:
>
> - self.state = 2109
>
> + self.state = 2112
>
> self.match(VfrSyntaxParser.Default)
>
> - self.state = 2110
>
> + self.state = 2113
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2111
>
> + self.state = 2114
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> - self.state = 2112
>
> + self.state = 2115
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> @@ -13652,17 +13662,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2115
>
> + self.state = 2118
>
> self.timeFlagsField()
>
> - self.state = 2120
>
> + self.state = 2123
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2116
>
> + self.state = 2119
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2117
>
> + self.state = 2120
>
> self.timeFlagsField()
>
> - self.state = 2122
>
> + self.state = 2125
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -13722,7 +13732,7 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2123
>
> + self.state = 2126
>
> _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)
>
> @@ -13778,27 +13788,27 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementConditionalContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 246, self.RULE_vfrStatementConditional)
>
> try:
>
> - self.state = 2129
>
> + self.state = 2132
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.DisableIf]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2125
>
> + self.state = 2128
>
> self.vfrStatementDisableIfStat()
>
> pass
>
> elif token in [VfrSyntaxParser.SuppressIf]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2126
>
> + self.state = 2129
>
> self.vfrStatementSuppressIfStat()
>
> pass
>
> elif token in [VfrSyntaxParser.GrayOutIf]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2127
>
> + self.state = 2130
>
> self.vfrStatementGrayOutIfStat()
>
> pass
>
> elif token in [VfrSyntaxParser.InconsistentIf]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2128
>
> + self.state = 2131
>
> self.vfrStatementInconsistentIfStat()
>
> pass
>
> else:
>
> @@ -13854,13 +13864,13 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 248, self.RULE_vfrStatementConditionalNew)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2131
>
> + self.state = 2134
>
> self.vfrStatementDisableIfStat()
>
> - self.state = 2132
>
> + self.state = 2135
>
> self.vfrStatementSuppressIfStatNew()
>
> - self.state = 2133
>
> + self.state = 2136
>
> self.vfrStatementGrayOutIfStatNew()
>
> - self.state = 2134
>
> + self.state = 2137
>
> self.vfrStatementInconsistentIfStat()
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -13900,7 +13910,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 250, self.RULE_vfrStatementSuppressIfStat)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2136
>
> + self.state = 2139
>
> self.vfrStatementSuppressIfStatNew()
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -13940,7 +13950,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 252, self.RULE_vfrStatementGrayOutIfStat)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2138
>
> + self.state = 2141
>
> self.vfrStatementGrayOutIfStatNew()
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -13999,37 +14009,37 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementStatListContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 254, self.RULE_vfrStatementStatList)
>
> try:
>
> - self.state = 2146
>
> + self.state = 2149
>
> 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.state = 2143
>
> 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.state = 2144
>
> self.vfrStatementQuestions()
>
> pass
>
> elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf,
> VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2142
>
> + self.state = 2145
>
> self.vfrStatementConditional()
>
> pass
>
> elif token in [VfrSyntaxParser.Label]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2143
>
> + self.state = 2146
>
> self.vfrStatementLabel()
>
> pass
>
> elif token in [VfrSyntaxParser.GuidOp]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 2144
>
> + self.state = 2147
>
> self.vfrStatementExtension()
>
> pass
>
> elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 2145
>
> + self.state = 2148
>
> self.vfrStatementInvalid()
>
> pass
>
> else:
>
> @@ -14083,27 +14093,27 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementStatListOldContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 256, self.RULE_vfrStatementStatListOld)
>
> try:
>
> - self.state = 2152
>
> + self.state = 2155
>
> 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.state = 2151
>
> 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.state = 2152
>
> self.vfrStatementQuestions()
>
> pass
>
> elif token in [VfrSyntaxParser.Label]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2150
>
> + self.state = 2153
>
> self.vfrStatementLabel()
>
> pass
>
> elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2151
>
> + self.state = 2154
>
> self.vfrStatementInvalid()
>
> pass
>
> else:
>
> @@ -14123,7 +14133,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
>
>
>
> def DisableIf(self):
>
> return self.getToken(VfrSyntaxParser.DisableIf, 0)
>
> @@ -14167,25 +14177,25 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2154
>
> + self.state = 2157
>
> self.match(VfrSyntaxParser.DisableIf)
>
> - self.state = 2155
>
> - self.vfrStatementExpression()
>
> - self.state = 2156
>
> + self.state = 2158
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2159
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 2160
>
> + self.state = 2163
>
> 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.state = 2160
>
> self.vfrStatementStatList()
>
> - self.state = 2162
>
> + self.state = 2165
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2163
>
> + self.state = 2166
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 2164
>
> + self.state = 2167
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14201,6 +14211,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> + self.Node = None
>
>
>
> def SuppressIf(self):
>
> return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> @@ -14250,37 +14261,37 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2166
>
> + self.state = 2169
>
> self.match(VfrSyntaxParser.SuppressIf)
>
> - self.state = 2179
>
> + self.state = 2182
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2167
>
> + self.state = 2170
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2168
>
> + self.state = 2171
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2169
>
> + self.state = 2172
>
> self.flagsField()
>
> - self.state = 2174
>
> + self.state = 2177
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2170
>
> + self.state = 2173
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2171
>
> + self.state = 2174
>
> self.flagsField()
>
> - self.state = 2176
>
> + self.state = 2179
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2177
>
> + self.state = 2180
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2181
>
> - self.vfrStatementExpression()
>
> - self.state = 2182
>
> + self.state = 2184
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2185
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14296,6 +14307,7 @@ class VfrSyntaxParser ( Parser ):
> def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> + self.Node = None
>
>
>
> def GrayOutIf(self):
>
> return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
>
> @@ -14345,37 +14357,37 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2184
>
> + self.state = 2187
>
> self.match(VfrSyntaxParser.GrayOutIf)
>
> - self.state = 2197
>
> + self.state = 2200
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2185
>
> + self.state = 2188
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2186
>
> + self.state = 2189
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2187
>
> + self.state = 2190
>
> self.flagsField()
>
> - self.state = 2192
>
> + self.state = 2195
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2188
>
> + self.state = 2191
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2189
>
> + self.state = 2192
>
> self.flagsField()
>
> - self.state = 2194
>
> + self.state = 2197
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2195
>
> + self.state = 2198
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2199
>
> - self.vfrStatementExpression()
>
> - self.state = 2200
>
> + self.state = 2202
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2203
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14391,7 +14403,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
>
>
> def SuppressIf(self):
>
> return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> @@ -14454,51 +14466,51 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2202
>
> + self.state = 2205
>
> self.match(VfrSyntaxParser.SuppressIf)
>
> - self.state = 2215
>
> + self.state = 2218
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2203
>
> + self.state = 2206
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2204
>
> + self.state = 2207
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2205
>
> + self.state = 2208
>
> self.flagsField()
>
> - self.state = 2210
>
> + self.state = 2213
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2206
>
> + self.state = 2209
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2207
>
> + self.state = 2210
>
> self.flagsField()
>
> - self.state = 2212
>
> + self.state = 2215
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2213
>
> + self.state = 2216
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2217
>
> - self.vfrStatementExpression()
>
> - self.state = 2218
>
> + self.state = 2220
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2221
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 2222
>
> + self.state = 2225
>
> 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.state = 2222
>
> self.vfrStatementStatList()
>
> - self.state = 2224
>
> + self.state = 2227
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2225
>
> + self.state = 2228
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 2226
>
> + self.state = 2229
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14514,7 +14526,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)
>
>
>
> def GrayOutIf(self):
>
> return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
>
> @@ -14577,51 +14589,51 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2228
>
> + self.state = 2231
>
> self.match(VfrSyntaxParser.GrayOutIf)
>
> - self.state = 2241
>
> + self.state = 2244
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2229
>
> + self.state = 2232
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2230
>
> + self.state = 2233
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2231
>
> + self.state = 2234
>
> self.flagsField()
>
> - self.state = 2236
>
> + self.state = 2239
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2232
>
> + self.state = 2235
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2233
>
> + self.state = 2236
>
> self.flagsField()
>
> - self.state = 2238
>
> + self.state = 2241
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2239
>
> + self.state = 2242
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2243
>
> - self.vfrStatementExpression()
>
> - self.state = 2244
>
> + self.state = 2246
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2247
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 2248
>
> + self.state = 2251
>
> 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.state = 2248
>
> self.vfrStatementStatList()
>
> - self.state = 2250
>
> + self.state = 2253
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2251
>
> + self.state = 2254
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 2252
>
> + self.state = 2255
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14637,7 +14649,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
>
>
>
> def InconsistentIf(self):
>
> return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
>
> @@ -14708,53 +14720,53 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2254
>
> + self.state = 2257
>
> self.match(VfrSyntaxParser.InconsistentIf)
>
> - self.state = 2255
>
> + self.state = 2258
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 2256
>
> + self.state = 2259
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2257
>
> + self.state = 2260
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2258
>
> + self.state = 2261
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2259
>
> + self.state = 2262
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2260
>
> + self.state = 2263
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2261
>
> + self.state = 2264
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2274
>
> + self.state = 2277
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.FLAGS:
>
> - self.state = 2262
>
> + self.state = 2265
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2263
>
> + self.state = 2266
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2264
>
> + self.state = 2267
>
> self.flagsField()
>
> - self.state = 2269
>
> + self.state = 2272
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2265
>
> + self.state = 2268
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2266
>
> + self.state = 2269
>
> self.flagsField()
>
> - self.state = 2271
>
> + self.state = 2274
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2272
>
> + self.state = 2275
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2276
>
> - self.vfrStatementExpression()
>
> - self.state = 2277
>
> + self.state = 2279
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2280
>
> self.match(VfrSyntaxParser.EndIf)
>
> - self.state = 2278
>
> + self.state = 2281
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14800,22 +14812,22 @@ class VfrSyntaxParser ( Parser ):
> localctx = VfrSyntaxParser.VfrStatementInvalidContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 270, self.RULE_vfrStatementInvalid)
>
> try:
>
> - self.state = 2283
>
> + self.state = 2286
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Hidden]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2280
>
> + self.state = 2283
>
> self.vfrStatementInvalidHidden()
>
> pass
>
> elif token in [VfrSyntaxParser.Inventory]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2281
>
> + self.state = 2284
>
> self.vfrStatementInvalidInventory()
>
> pass
>
> elif token in [VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2282
>
> + self.state = 2285
>
> self.vfrStatementInvalidSaveRestoreDefaults()
>
> pass
>
> else:
>
> @@ -14875,23 +14887,23 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 272, self.RULE_vfrStatementInvalidHidden)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2285
>
> + self.state = 2288
>
> self.match(VfrSyntaxParser.Hidden)
>
> - self.state = 2286
>
> + self.state = 2289
>
> self.match(VfrSyntaxParser.Value)
>
> - self.state = 2287
>
> + self.state = 2290
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2288
>
> + self.state = 2291
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2289
>
> + self.state = 2292
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2290
>
> + self.state = 2293
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 2291
>
> + self.state = 2294
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2292
>
> + self.state = 2295
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2293
>
> + self.state = 2296
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -14972,55 +14984,55 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2295
>
> + self.state = 2298
>
> self.match(VfrSyntaxParser.Inventory)
>
> - self.state = 2296
>
> + self.state = 2299
>
> self.match(VfrSyntaxParser.Help)
>
> - self.state = 2297
>
> + self.state = 2300
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2298
>
> + self.state = 2301
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2299
>
> + self.state = 2302
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2300
>
> + self.state = 2303
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2301
>
> + self.state = 2304
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2302
>
> + self.state = 2305
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2303
>
> + self.state = 2306
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 2304
>
> + self.state = 2307
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2305
>
> + self.state = 2308
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2306
>
> + self.state = 2309
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2307
>
> + self.state = 2310
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2308
>
> + self.state = 2311
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2309
>
> + self.state = 2312
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2316
>
> + self.state = 2319
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Text:
>
> - self.state = 2310
>
> + self.state = 2313
>
> self.match(VfrSyntaxParser.Text)
>
> - self.state = 2311
>
> + self.state = 2314
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2312
>
> + self.state = 2315
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2313
>
> + self.state = 2316
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2314
>
> + self.state = 2317
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2315
>
> + self.state = 2318
>
> self.match(VfrSyntaxParser.CloseParen)
>
>
>
>
>
> - self.state = 2318
>
> + self.state = 2321
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15126,92 +15138,92 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2320
>
> + self.state = 2323
>
> _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.state = 2324
>
> self.match(VfrSyntaxParser.Defaults)
>
> - self.state = 2322
>
> + self.state = 2325
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2323
>
> + self.state = 2326
>
> self.match(VfrSyntaxParser.FormId)
>
> - self.state = 2324
>
> + self.state = 2327
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2325
>
> + self.state = 2328
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2326
>
> + self.state = 2329
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2327
>
> + self.state = 2330
>
> self.match(VfrSyntaxParser.Prompt)
>
> - self.state = 2328
>
> + self.state = 2331
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2329
>
> + self.state = 2332
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2330
>
> + self.state = 2333
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2331
>
> + self.state = 2334
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2332
>
> + self.state = 2335
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2333
>
> + self.state = 2336
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2334
>
> + self.state = 2337
>
> self.match(VfrSyntaxParser.Help)
>
> - self.state = 2335
>
> + self.state = 2338
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2336
>
> + self.state = 2339
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2337
>
> + self.state = 2340
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2338
>
> + self.state = 2341
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2339
>
> + self.state = 2342
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2351
>
> + self.state = 2354
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
>
> if la_ == 1:
>
> - self.state = 2340
>
> + self.state = 2343
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2341
>
> + self.state = 2344
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2342
>
> + self.state = 2345
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2343
>
> + self.state = 2346
>
> self.flagsField()
>
> - self.state = 2348
>
> + self.state = 2351
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2344
>
> + self.state = 2347
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2345
>
> + self.state = 2348
>
> self.flagsField()
>
> - self.state = 2350
>
> + self.state = 2353
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
>
>
>
>
> - self.state = 2357
>
> + self.state = 2360
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 2353
>
> + self.state = 2356
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2354
>
> + self.state = 2357
>
> self.match(VfrSyntaxParser.Key)
>
> - self.state = 2355
>
> + self.state = 2358
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2356
>
> + self.state = 2359
>
> self.match(VfrSyntaxParser.Number)
>
>
>
>
>
> - self.state = 2359
>
> + self.state = 2362
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15227,7 +15239,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
>
>
> def Label(self):
>
> return self.getToken(VfrSyntaxParser.Label, 0)
>
> @@ -15256,11 +15268,11 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 278, self.RULE_vfrStatementLabel)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2361
>
> + self.state = 2364
>
> self.match(VfrSyntaxParser.Label)
>
> - self.state = 2362
>
> + self.state = 2365
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2363
>
> + self.state = 2366
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15276,7 +15288,7 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
>
>
> def Banner(self):
>
> return self.getToken(VfrSyntaxParser.Banner, 0)
>
> @@ -15345,60 +15357,60 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2365
>
> + self.state = 2368
>
> self.match(VfrSyntaxParser.Banner)
>
> - self.state = 2367
>
> + self.state = 2370
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 2366
>
> + self.state = 2369
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2369
>
> + self.state = 2372
>
> self.match(VfrSyntaxParser.Title)
>
> - self.state = 2370
>
> + self.state = 2373
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2371
>
> + self.state = 2374
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2372
>
> + self.state = 2375
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2373
>
> + self.state = 2376
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2374
>
> + self.state = 2377
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2375
>
> + self.state = 2378
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2386
>
> + self.state = 2389
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Line]:
>
> - self.state = 2376
>
> + self.state = 2379
>
> self.match(VfrSyntaxParser.Line)
>
> - self.state = 2377
>
> + self.state = 2380
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2378
>
> + self.state = 2381
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2379
>
> + self.state = 2382
>
> self.match(VfrSyntaxParser.Align)
>
> - self.state = 2380
>
> + self.state = 2383
>
> _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.state = 2384
>
> self.match(VfrSyntaxParser.Semicolon)
>
> pass
>
> elif token in [VfrSyntaxParser.Timeout]:
>
> - self.state = 2382
>
> + self.state = 2385
>
> self.match(VfrSyntaxParser.Timeout)
>
> - self.state = 2383
>
> + self.state = 2386
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2384
>
> + self.state = 2387
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2385
>
> + self.state = 2388
>
> self.match(VfrSyntaxParser.Semicolon)
>
> pass
>
> else:
>
> @@ -15418,8 +15430,8 @@ class VfrSyntaxParser ( Parser ):
> 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.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
> + self.Buffer = None
>
> self.Size = 0
>
> self.TypeName = ''
>
> self.TypeSize = 0
>
> @@ -15524,183 +15536,183 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2388
>
> + self.state = 2391
>
> self.match(VfrSyntaxParser.GuidOp)
>
> - self.state = 2389
>
> + self.state = 2392
>
> self.match(VfrSyntaxParser.Uuid)
>
> - self.state = 2390
>
> + self.state = 2393
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2391
>
> + self.state = 2394
>
> self.guidDefinition()
>
> - self.state = 2463
>
> + self.state = 2466
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
>
> if la_ == 1:
>
> - self.state = 2392
>
> + self.state = 2395
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2393
>
> + self.state = 2396
>
> localctx.D = self.match(VfrSyntaxParser.DataType)
>
> - self.state = 2394
>
> + self.state = 2397
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2455
>
> + self.state = 2458
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Uint64]:
>
> - self.state = 2395
>
> + self.state = 2398
>
> self.match(VfrSyntaxParser.Uint64)
>
> - self.state = 2399
>
> + self.state = 2402
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2396
>
> + self.state = 2399
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2397
>
> + self.state = 2400
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2398
>
> + self.state = 2401
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.Uint32]:
>
> - self.state = 2401
>
> + self.state = 2404
>
> self.match(VfrSyntaxParser.Uint32)
>
> - self.state = 2405
>
> + self.state = 2408
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2402
>
> + self.state = 2405
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2403
>
> + self.state = 2406
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2404
>
> + self.state = 2407
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.Uint16]:
>
> - self.state = 2407
>
> + self.state = 2410
>
> self.match(VfrSyntaxParser.Uint16)
>
> - self.state = 2411
>
> + self.state = 2414
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2408
>
> + self.state = 2411
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2409
>
> + self.state = 2412
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2410
>
> + self.state = 2413
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.Uint8]:
>
> - self.state = 2413
>
> + self.state = 2416
>
> self.match(VfrSyntaxParser.Uint8)
>
> - self.state = 2417
>
> + self.state = 2420
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2414
>
> + self.state = 2417
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2415
>
> + self.state = 2418
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2416
>
> + self.state = 2419
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.Boolean]:
>
> - self.state = 2419
>
> + self.state = 2422
>
> self.match(VfrSyntaxParser.Boolean)
>
> - self.state = 2423
>
> + self.state = 2426
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2420
>
> + self.state = 2423
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2421
>
> + self.state = 2424
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2422
>
> + self.state = 2425
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_STRING_ID]:
>
> - self.state = 2425
>
> + self.state = 2428
>
> self.match(VfrSyntaxParser.EFI_STRING_ID)
>
> - self.state = 2429
>
> + self.state = 2432
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2426
>
> + self.state = 2429
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2427
>
> + self.state = 2430
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2428
>
> + self.state = 2431
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_DATE]:
>
> - self.state = 2431
>
> + self.state = 2434
>
> self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> - self.state = 2435
>
> + self.state = 2438
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2432
>
> + self.state = 2435
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2433
>
> + self.state = 2436
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2434
>
> + self.state = 2437
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_TIME]:
>
> - self.state = 2437
>
> + self.state = 2440
>
> self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> - self.state = 2441
>
> + self.state = 2444
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2438
>
> + self.state = 2441
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2439
>
> + self.state = 2442
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2440
>
> + self.state = 2443
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.EFI_HII_REF]:
>
> - self.state = 2443
>
> + self.state = 2446
>
> self.match(VfrSyntaxParser.EFI_HII_REF)
>
> - self.state = 2447
>
> + self.state = 2450
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2444
>
> + self.state = 2447
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2445
>
> + self.state = 2448
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2446
>
> + self.state = 2449
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> pass
>
> elif token in [VfrSyntaxParser.StringIdentifier]:
>
> - self.state = 2449
>
> + self.state = 2452
>
> self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 2453
>
> + self.state = 2456
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2450
>
> + self.state = 2453
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2451
>
> + self.state = 2454
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2452
>
> + self.state = 2455
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> @@ -15708,40 +15720,40 @@ class VfrSyntaxParser ( Parser ):
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 2460
>
> + self.state = 2463
>
> self._errHandler.sync(self)
>
> - _alt = self._interp.adaptivePredict(self._input,196,self._ctx)
>
> + _alt = self._interp.adaptivePredict(self._input,197,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.state = 2460
>
> + self.vfrExtensionData()
>
> + self.state = 2465
>
> self._errHandler.sync(self)
>
> - _alt = self._interp.adaptivePredict(self._input,196,self._ctx)
>
> + _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
>
>
>
>
>
>
>
> - self.state = 2473
>
> + self.state = 2476
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Comma:
>
> - self.state = 2465
>
> + self.state = 2468
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2469
>
> + self.state = 2472
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.GuidOp:
>
> - self.state = 2466
>
> + self.state = 2469
>
> self.vfrStatementExtension()
>
> - self.state = 2471
>
> + self.state = 2474
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2472
>
> + self.state = 2475
>
> self.match(VfrSyntaxParser.EndGuidOp)
>
>
>
>
>
> - self.state = 2475
>
> + self.state = 2478
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15754,13 +15766,14 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrExtensionDataContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, DataBuff=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> - self.DataBuff = None
>
> - self.IsStruct = None
>
> + self.TFName = ''
>
> + self.FName = ''
>
> + self.TFValue = None
>
> + self.I = None # Token
>
> self.N = None # Token
>
> - self.DataBuff = DataBuff
>
>
>
> def Comma(self):
>
> return self.getToken(VfrSyntaxParser.Comma, 0)
>
> @@ -15805,44 +15818,44 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrExtensionData(self, DataBuff):
>
> + def vfrExtensionData(self):
>
>
>
> - localctx = VfrSyntaxParser.VfrExtensionDataContext(self, self._ctx,
> self.state, DataBuff)
>
> + localctx = VfrSyntaxParser.VfrExtensionDataContext(self, self._ctx,
> self.state)
>
> self.enterRule(localctx, 284, self.RULE_vfrExtensionData)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2477
>
> + self.state = 2480
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2478
>
> + self.state = 2481
>
> self.match(VfrSyntaxParser.Data)
>
> - self.state = 2482
>
> + self.state = 2485
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2479
>
> + self.state = 2482
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2480
>
> - self.match(VfrSyntaxParser.Number)
>
> - self.state = 2481
>
> + self.state = 2483
>
> + localctx.I = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2484
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> - self.state = 2488
>
> + self.state = 2491
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.Dot:
>
> - self.state = 2484
>
> + self.state = 2487
>
> self.match(VfrSyntaxParser.Dot)
>
> - self.state = 2485
>
> + self.state = 2488
>
> self.arrayName()
>
> - self.state = 2490
>
> + self.state = 2493
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2491
>
> + self.state = 2494
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2492
>
> + self.state = 2495
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15885,9 +15898,9 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 286, self.RULE_vfrStatementModal)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2494
>
> + self.state = 2497
>
> self.vfrModalTag()
>
> - self.state = 2495
>
> + self.state = 2498
>
> self.match(VfrSyntaxParser.Semicolon)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15903,7 +15916,7 @@ class VfrSyntaxParser ( Parser ):
> 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)
>
> + self.Node = IfrTreeNode(EFI_IFR_MODAL_TAG_OP)
>
>
>
> def Modal(self):
>
> return self.getToken(VfrSyntaxParser.Modal, 0)
>
> @@ -15926,7 +15939,7 @@ class VfrSyntaxParser ( Parser ):
> self.enterRule(localctx, 288, self.RULE_vfrModalTag)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2497
>
> + self.state = 2500
>
> self.match(VfrSyntaxParser.Modal)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -15939,10 +15952,14 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrStatementExpressionContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ParentNode=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> + self.ParentNode = None
>
> self.ExpInfo = ExpressionInfo()
>
> + self.Nodes = []
>
> + self.L = None # Token
>
> + self.ParentNode = ParentNode
>
>
>
> def andTerm(self, i:int=None):
>
> if i is None:
>
> @@ -15969,24 +15986,24 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrStatementExpression(self):
>
> + def vfrStatementExpression(self, ParentNode):
>
>
>
> - localctx = VfrSyntaxParser.VfrStatementExpressionContext(self, self._ctx,
> self.state)
>
> + localctx = VfrSyntaxParser.VfrStatementExpressionContext(self, self._ctx,
> self.state, ParentNode)
>
> self.enterRule(localctx, 290, self.RULE_vfrStatementExpression)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2499
>
> + self.state = 2502
>
> self.andTerm(localctx.ExpInfo)
>
> - self.state = 2504
>
> + self.state = 2507
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.OR:
>
> - self.state = 2500
>
> - self.match(VfrSyntaxParser.OR)
>
> - self.state = 2501
>
> + self.state = 2503
>
> + localctx.L = self.match(VfrSyntaxParser.OR)
>
> + self.state = 2504
>
> self.andTerm(localctx.ExpInfo)
>
> - self.state = 2506
>
> + self.state = 2509
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16001,10 +16018,13 @@ class VfrSyntaxParser ( Parser ):
>
>
> class VfrStatementExpressionSubContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ParentNodes=None):
>
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> + self.ParentNodes = None
>
> self.ExpInfo = ExpressionInfo()
>
> + self.Nodes = []
>
> + self.ParentNodes = ParentNodes
>
>
>
> def andTerm(self, i:int=None):
>
> if i is None:
>
> @@ -16031,24 +16051,24 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def vfrStatementExpressionSub(self):
>
> + def vfrStatementExpressionSub(self, ParentNodes):
>
>
>
> - localctx = VfrSyntaxParser.VfrStatementExpressionSubContext(self,
> self._ctx, self.state)
>
> + localctx = VfrSyntaxParser.VfrStatementExpressionSubContext(self,
> self._ctx, self.state, ParentNodes)
>
> self.enterRule(localctx, 292, self.RULE_vfrStatementExpressionSub)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2507
>
> + self.state = 2510
>
> self.andTerm(localctx.ExpInfo)
>
> - self.state = 2512
>
> + self.state = 2515
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.OR:
>
> - self.state = 2508
>
> + self.state = 2511
>
> self.match(VfrSyntaxParser.OR)
>
> - self.state = 2509
>
> + self.state = 2512
>
> self.andTerm(localctx.ExpInfo)
>
> - self.state = 2514
>
> + self.state = 2517
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16067,7 +16087,9 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrAndList = []
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.L = None # Token
>
> self.ExpInfo = ExpInfo
>
>
>
> def bitwiseorTerm(self, i:int=None):
>
> @@ -16102,17 +16124,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2515
>
> + self.state = 2518
>
> self.bitwiseorTerm(ExpInfo)
>
> - self.state = 2520
>
> + self.state = 2523
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.AND:
>
> - self.state = 2516
>
> - self.match(VfrSyntaxParser.AND)
>
> - self.state = 2517
>
> + self.state = 2519
>
> + localctx.L = self.match(VfrSyntaxParser.AND)
>
> + self.state = 2520
>
> self.bitwiseorTerm(ExpInfo)
>
> - self.state = 2522
>
> + self.state = 2525
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16131,7 +16153,9 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrBitWiseOrList = []
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.L = None # Token
>
> self.ExpInfo = ExpInfo
>
>
>
> def bitwiseandTerm(self, i:int=None):
>
> @@ -16166,17 +16190,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2523
>
> + self.state = 2526
>
> self.bitwiseandTerm(ExpInfo)
>
> - self.state = 2528
>
> + self.state = 2531
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2524
>
> - self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2525
>
> + self.state = 2527
>
> + localctx.L = self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2528
>
> self.bitwiseandTerm(ExpInfo)
>
> - self.state = 2530
>
> + self.state = 2533
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16195,7 +16219,9 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrBitWiseAndList = []
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.L = None # Token
>
> self.ExpInfo = ExpInfo
>
>
>
> def equalTerm(self, i:int=None):
>
> @@ -16230,17 +16256,17 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2531
>
> + self.state = 2534
>
> self.equalTerm(ExpInfo)
>
> - self.state = 2536
>
> + self.state = 2539
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseAnd:
>
> - self.state = 2532
>
> - self.match(VfrSyntaxParser.BitWiseAnd)
>
> - self.state = 2533
>
> + self.state = 2535
>
> + localctx.L = self.match(VfrSyntaxParser.BitWiseAnd)
>
> + self.state = 2536
>
> self.equalTerm(ExpInfo)
>
> - self.state = 2538
>
> + self.state = 2541
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16259,8 +16285,8 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrEqualList = []
>
> - self.CIfrNotEqualList = []
>
> + self.Nodes = []
>
> + self.Line = None
>
> self.ExpInfo = ExpInfo
>
>
>
> def compareTerm(self):
>
> @@ -16293,15 +16319,15 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2539
>
> - self.compareTerm(localctx.ExpInfo)
>
> - self.state = 2543
>
> + self.state = 2542
>
> + self.compareTerm(ExpInfo)
>
> + self.state = 2546
>
> 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.state = 2543
>
> + self.equalTermSupplementary(ExpInfo)
>
> + self.state = 2548
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16316,14 +16342,11 @@ class VfrSyntaxParser ( Parser ):
>
>
> class EqualTermSupplementaryContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, CIfrEqualList=None, CIfrNotEqualList=None,
> ExpInfo=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
>
>
> @@ -16333,9 +16356,8 @@ class VfrSyntaxParser ( Parser ):
>
>
> def copyFrom(self, ctx:ParserRuleContext):
>
> super().copyFrom(ctx)
>
> - self.CIfrEqualList = ctx.CIfrEqualList
>
> - self.CIfrNotEqualList = ctx.CIfrNotEqualList
>
> self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
>
>
>
>
>
>
> @@ -16378,28 +16400,28 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def equalTermSupplementary(self, CIfrEqualList, CIfrNotEqualList, ExpInfo):
>
> + def equalTermSupplementary(self, ExpInfo):
>
>
>
> - localctx = VfrSyntaxParser.EqualTermSupplementaryContext(self,
> self._ctx, self.state, CIfrEqualList, CIfrNotEqualList, ExpInfo)
>
> + localctx = VfrSyntaxParser.EqualTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> self.enterRule(localctx, 302, self.RULE_equalTermSupplementary)
>
> try:
>
> - self.state = 2550
>
> + self.state = 2553
>
> 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.state = 2549
>
> self.match(VfrSyntaxParser.Equal)
>
> - self.state = 2547
>
> + self.state = 2550
>
> self.compareTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.NotEqual]:
>
> localctx = VfrSyntaxParser.EqualTermNotEqualRuleContext(self,
> localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2548
>
> + self.state = 2551
>
> self.match(VfrSyntaxParser.NotEqual)
>
> - self.state = 2549
>
> + self.state = 2552
>
> self.compareTerm(ExpInfo)
>
> pass
>
> else:
>
> @@ -16420,10 +16442,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrLessThanList = []
>
> - self.CIfrLessEqualList = []
>
> - self.CIfrGreaterThanList = []
>
> - self.CIfrGreaterEqualList = []
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def shiftTerm(self):
>
> @@ -16456,15 +16475,15 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2552
>
> + self.state = 2555
>
> self.shiftTerm(ExpInfo)
>
> - self.state = 2556
>
> + self.state = 2559
>
> 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.state = 2556
>
> + self.compareTermSupplementary(ExpInfo)
>
> + self.state = 2561
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16479,18 +16498,11 @@ class VfrSyntaxParser ( Parser ):
>
>
> class CompareTermSupplementaryContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, CIfrLessThanList=None, CIfrLessEqualList=None,
> CIfrGreaterThanList=None, CIfrGreaterEqualList=None, ExpInfo=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
>
>
> @@ -16500,11 +16512,8 @@ class VfrSyntaxParser ( Parser ):
>
>
> 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
>
> + self.Nodes = ctx.Nodes
>
>
>
>
>
>
>
> @@ -16585,44 +16594,44 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def compareTermSupplementary(self, CIfrLessThanList, CIfrLessEqualList,
> CIfrGreaterThanList, CIfrGreaterEqualList, ExpInfo):
>
> + def compareTermSupplementary(self, ExpInfo):
>
>
>
> - localctx = VfrSyntaxParser.CompareTermSupplementaryContext(self,
> self._ctx, self.state, CIfrLessThanList, CIfrLessEqualList, CIfrGreaterThanList,
> CIfrGreaterEqualList, ExpInfo)
>
> + localctx = VfrSyntaxParser.CompareTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> self.enterRule(localctx, 306, self.RULE_compareTermSupplementary)
>
> try:
>
> - self.state = 2567
>
> + self.state = 2570
>
> 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.state = 2562
>
> self.match(VfrSyntaxParser.Less)
>
> - self.state = 2560
>
> + self.state = 2563
>
> self.shiftTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.LessEqual]:
>
> localctx = VfrSyntaxParser.CompareTermLessEqualRuleContext(self,
> localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2561
>
> + self.state = 2564
>
> self.match(VfrSyntaxParser.LessEqual)
>
> - self.state = 2562
>
> + self.state = 2565
>
> self.shiftTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Greater]:
>
> localctx = VfrSyntaxParser.CompareTermGreaterRuleContext(self,
> localctx)
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2563
>
> + self.state = 2566
>
> self.match(VfrSyntaxParser.Greater)
>
> - self.state = 2564
>
> + self.state = 2567
>
> self.shiftTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.GreaterEqual]:
>
> localctx =
> VfrSyntaxParser.CompareTermGreaterEqualRuleContext(self, localctx)
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2565
>
> + self.state = 2568
>
> self.match(VfrSyntaxParser.GreaterEqual)
>
> - self.state = 2566
>
> + self.state = 2569
>
> self.shiftTerm(ExpInfo)
>
> pass
>
> else:
>
> @@ -16643,8 +16652,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrShiftLeftList = []
>
> - self.CIfrShiftRightList = []
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def addMinusTerm(self):
>
> @@ -16677,15 +16685,15 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2569
>
> + self.state = 2572
>
> self.addMinusTerm(ExpInfo)
>
> - self.state = 2573
>
> + self.state = 2576
>
> 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.state = 2573
>
> + self.shiftTermSupplementary(ExpInfo)
>
> + self.state = 2578
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16700,14 +16708,11 @@ class VfrSyntaxParser ( Parser ):
>
>
> class ShiftTermSupplementaryContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, CIfrShiftLeftList=None, CIfrShiftRightList=None,
> ExpInfo=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
>
>
> @@ -16717,9 +16722,8 @@ class VfrSyntaxParser ( Parser ):
>
>
> def copyFrom(self, ctx:ParserRuleContext):
>
> super().copyFrom(ctx)
>
> - self.CIfrShiftLeftList = ctx.CIfrShiftLeftList
>
> - self.CIfrShiftRightList = ctx.CIfrShiftRightList
>
> self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
>
>
>
>
>
>
> @@ -16758,28 +16762,28 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def shiftTermSupplementary(self, CIfrShiftLeftList, CIfrShiftRightList,
> ExpInfo):
>
> + def shiftTermSupplementary(self, ExpInfo):
>
>
>
> - localctx = VfrSyntaxParser.ShiftTermSupplementaryContext(self, self._ctx,
> self.state, CIfrShiftLeftList, CIfrShiftRightList, ExpInfo)
>
> + localctx = VfrSyntaxParser.ShiftTermSupplementaryContext(self, self._ctx,
> self.state, ExpInfo)
>
> self.enterRule(localctx, 310, self.RULE_shiftTermSupplementary)
>
> try:
>
> - self.state = 2580
>
> + self.state = 2583
>
> 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.state = 2579
>
> self.match(VfrSyntaxParser.T__9)
>
> - self.state = 2577
>
> + self.state = 2580
>
> self.addMinusTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.T__10]:
>
> localctx = VfrSyntaxParser.ShiftTermRightContext(self, localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2578
>
> + self.state = 2581
>
> self.match(VfrSyntaxParser.T__10)
>
> - self.state = 2579
>
> + self.state = 2582
>
> self.addMinusTerm(ExpInfo)
>
> pass
>
> else:
>
> @@ -16800,8 +16804,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrAddList = []
>
> - self.CIfrSubtractList = []
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def multdivmodTerm(self):
>
> @@ -16834,15 +16837,15 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2582
>
> + self.state = 2585
>
> self.multdivmodTerm(ExpInfo)
>
> - self.state = 2586
>
> + self.state = 2589
>
> 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.state = 2586
>
> + self.addMinusTermSupplementary(ExpInfo)
>
> + self.state = 2591
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -16857,14 +16860,11 @@ class VfrSyntaxParser ( Parser ):
>
>
> class AddMinusTermSupplementaryContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, CIfrAddList=None, CIfrSubtractList=None, ExpInfo=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
>
>
> @@ -16874,9 +16874,8 @@ class VfrSyntaxParser ( Parser ):
>
>
> def copyFrom(self, ctx:ParserRuleContext):
>
> super().copyFrom(ctx)
>
> - self.CIfrAddList = ctx.CIfrAddList
>
> - self.CIfrSubtractList = ctx.CIfrSubtractList
>
> self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
>
>
>
>
>
>
> @@ -16917,28 +16916,28 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def addMinusTermSupplementary(self, CIfrAddList, CIfrSubtractList,
> ExpInfo):
>
> + def addMinusTermSupplementary(self, ExpInfo):
>
>
>
> - localctx = VfrSyntaxParser.AddMinusTermSupplementaryContext(self,
> self._ctx, self.state, CIfrAddList, CIfrSubtractList, ExpInfo)
>
> + localctx = VfrSyntaxParser.AddMinusTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> self.enterRule(localctx, 314, self.RULE_addMinusTermSupplementary)
>
> try:
>
> - self.state = 2593
>
> + self.state = 2596
>
> 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.state = 2592
>
> self.match(VfrSyntaxParser.T__11)
>
> - self.state = 2590
>
> + self.state = 2593
>
> self.multdivmodTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Negative]:
>
> localctx = VfrSyntaxParser.AddMinusTermSubtractContext(self,
> localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2591
>
> + self.state = 2594
>
> self.match(VfrSyntaxParser.Negative)
>
> - self.state = 2592
>
> + self.state = 2595
>
> self.multdivmodTerm(ExpInfo)
>
> pass
>
> else:
>
> @@ -16959,9 +16958,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CIfrMultiplyList = []
>
> - self.CIfrDivideList = []
>
> - self.CIfrModuloList = []
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def castTerm(self):
>
> @@ -16994,15 +16991,15 @@ class VfrSyntaxParser ( Parser ):
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2595
>
> + self.state = 2598
>
> self.castTerm(ExpInfo)
>
> - self.state = 2599
>
> + self.state = 2602
>
> 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.state = 2599
>
> + self.multdivmodTermSupplementary(ExpInfo)
>
> + self.state = 2604
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -17017,16 +17014,11 @@ class VfrSyntaxParser ( Parser ):
>
>
> class MultdivmodTermSupplementaryContext(ParserRuleContext):
>
>
>
> - def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, CIfrMultiplyList=None, CIfrDivideList=None,
> CIfrModuloList=None, ExpInfo=None):
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
>
>
> @@ -17036,10 +17028,8 @@ class VfrSyntaxParser ( Parser ):
>
>
> def copyFrom(self, ctx:ParserRuleContext):
>
> super().copyFrom(ctx)
>
> - self.CIfrMultiplyList = ctx.CIfrMultiplyList
>
> - self.CIfrDivideList = ctx.CIfrDivideList
>
> - self.CIfrModuloList = ctx.CIfrModuloList
>
> self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
>
>
>
>
>
>
> @@ -17097,36 +17087,36 @@ class VfrSyntaxParser ( Parser ):
>
>
>
>
>
>
> - def multdivmodTermSupplementary(self, CIfrMultiplyList, CIfrDivideList,
> CIfrModuloList, ExpInfo):
>
> + def multdivmodTermSupplementary(self, ExpInfo):
>
>
>
> - localctx = VfrSyntaxParser.MultdivmodTermSupplementaryContext(self,
> self._ctx, self.state, CIfrMultiplyList, CIfrDivideList, CIfrModuloList, ExpInfo)
>
> + localctx = VfrSyntaxParser.MultdivmodTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> self.enterRule(localctx, 318, self.RULE_multdivmodTermSupplementary)
>
> try:
>
> - self.state = 2608
>
> + self.state = 2611
>
> 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.state = 2605
>
> self.match(VfrSyntaxParser.T__12)
>
> - self.state = 2603
>
> + self.state = 2606
>
> self.castTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Slash]:
>
> localctx = VfrSyntaxParser.MultdivmodTermDivContext(self, localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2604
>
> + self.state = 2607
>
> self.match(VfrSyntaxParser.Slash)
>
> - self.state = 2605
>
> + self.state = 2608
>
> self.castTerm(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.T__13]:
>
> localctx = VfrSyntaxParser.MultdivmodTermModuloContext(self,
> localctx)
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2606
>
> + self.state = 2609
>
> self.match(VfrSyntaxParser.T__13)
>
> - self.state = 2607
>
> + self.state = 2610
>
> self.castTerm(ExpInfo)
>
> pass
>
> else:
>
> @@ -17147,55 +17137,19 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TBObj = None
>
> - self.TUObj = None
>
> + self.Nodes = []
>
> 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):
>
> + def castTermSub(self, i:int=None):
>
> if i is None:
>
> - return self.getTokens(VfrSyntaxParser.Uint16)
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.CastTermSubContext)
>
> else:
>
> - return self.getToken(VfrSyntaxParser.Uint16, i)
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CastTermSubContext,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
>
> @@ -17213,30 +17167,20 @@ class VfrSyntaxParser ( Parser ):
>
>
> 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.state = 2616
>
> self._errHandler.sync(self)
>
> - _alt = self._interp.adaptivePredict(self._input,217,self._ctx)
>
> + _alt = self._interp.adaptivePredict(self._input,218,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.state = 2613
>
> + self.castTermSub()
>
> + self.state = 2618
>
> self._errHandler.sync(self)
>
> - _alt = self._interp.adaptivePredict(self._input,217,self._ctx)
>
> + _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
>
>
>
> - self.state = 2618
>
> + self.state = 2619
>
> self.atomTerm(ExpInfo)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17247,12 +17191,80 @@ class VfrSyntaxParser ( Parser ):
> return localctx
>
>
>
>
>
> + class CastTermSubContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.CastType = 0xFF
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Boolean(self):
>
> + return self.getToken(VfrSyntaxParser.Boolean, 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 getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_castTermSub
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCastTermSub" ):
>
> + return visitor.visitCastTermSub(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def castTermSub(self):
>
> +
>
> + localctx = VfrSyntaxParser.CastTermSubContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 322, self.RULE_castTermSub)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2621
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2622
>
> + _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 = 2623
>
> + 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 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.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def vfrExpressionCatenate(self):
>
> @@ -17313,79 +17325,65 @@ class VfrSyntaxParser ( Parser ):
> def atomTerm(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.AtomTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 322, self.RULE_atomTerm)
>
> + self.enterRule(localctx, 324, self.RULE_atomTerm)
>
> try:
>
> - self.state = 2632
>
> + self.state = 2636
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,218,self._ctx)
>
> - if la_ == 1:
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Catenate]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2620
>
> + self.state = 2625
>
> self.vfrExpressionCatenate(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 2:
>
> + elif token in [VfrSyntaxParser.Match]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2621
>
> + self.state = 2626
>
> self.vfrExpressionMatch(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 3:
>
> + elif token in [VfrSyntaxParser.Match2]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2622
>
> + self.state = 2627
>
> self.vfrExpressionMatch2(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 4:
>
> + elif token in [VfrSyntaxParser.OpenParen]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2623
>
> + self.state = 2628
>
> self.vfrExpressionParen(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 5:
>
> + elif token in [VfrSyntaxParser.Dup, VfrSyntaxParser.VarEqVal,
> VfrSyntaxParser.IdEqVal, VfrSyntaxParser.IdEqId, VfrSyntaxParser.IdEqValList,
> VfrSyntaxParser.QuestionRef, VfrSyntaxParser.RuleRef,
> VfrSyntaxParser.StringRef, VfrSyntaxParser.PushThis, VfrSyntaxParser.Security,
> VfrSyntaxParser.Get]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 2624
>
> + self.state = 2629
>
> self.vfrExpressionBuildInFunction(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 6:
>
> + elif token in [VfrSyntaxParser.TrueSymbol,
> VfrSyntaxParser.FalseSymbol, VfrSyntaxParser.One, VfrSyntaxParser.Ones,
> VfrSyntaxParser.Zero, VfrSyntaxParser.Undefined, VfrSyntaxParser.Version,
> VfrSyntaxParser.Number]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 2625
>
> + self.state = 2630
>
> self.vfrExpressionConstant(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 7:
>
> + elif token in [VfrSyntaxParser.Length, VfrSyntaxParser.Set,
> VfrSyntaxParser.BitWiseNot, VfrSyntaxParser.BoolVal,
> VfrSyntaxParser.StringVal, VfrSyntaxParser.UnIntVal, VfrSyntaxParser.ToUpper,
> VfrSyntaxParser.ToLower, VfrSyntaxParser.QuestionRefVal,
> VfrSyntaxParser.StringRefVal]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 2626
>
> + self.state = 2631
>
> self.vfrExpressionUnaryOp(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 8:
>
> + elif token in [VfrSyntaxParser.Cond, VfrSyntaxParser.Find,
> VfrSyntaxParser.Mid, VfrSyntaxParser.Tok, VfrSyntaxParser.Span]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 2627
>
> + self.state = 2632
>
> self.vfrExpressionTernaryOp(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 9:
>
> + elif token in [VfrSyntaxParser.Map]:
>
> self.enterOuterAlt(localctx, 9)
>
> - self.state = 2628
>
> + self.state = 2633
>
> self.vfrExpressionMap(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 10:
>
> + elif token in [VfrSyntaxParser.NOT]:
>
> self.enterOuterAlt(localctx, 10)
>
> - self.state = 2629
>
> + self.state = 2634
>
> self.match(VfrSyntaxParser.NOT)
>
> - self.state = 2630
>
> + self.state = 2635
>
> self.atomTerm(ExpInfo)
>
> pass
>
> -
>
> - elif la_ == 11:
>
> - self.enterOuterAlt(localctx, 11)
>
> - self.state = 2631
>
> - self.vfrExpressionMatch2(ExpInfo)
>
> - pass
>
> -
>
> + else:
>
> + raise NoViableAltException(self)
>
>
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17402,7 +17400,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Catenate(self):
>
> @@ -17439,20 +17437,20 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionCatenate(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionCatenateContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 324, self.RULE_vfrExpressionCatenate)
>
> + self.enterRule(localctx, 326, self.RULE_vfrExpressionCatenate)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2634
>
> + self.state = 2638
>
> self.match(VfrSyntaxParser.Catenate)
>
> - self.state = 2635
>
> + self.state = 2639
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2636
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2637
>
> + self.state = 2640
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2641
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2638
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2639
>
> + self.state = 2642
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2643
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17469,7 +17467,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.MObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Match(self):
>
> @@ -17506,20 +17504,20 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionMatch(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionMatchContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 326, self.RULE_vfrExpressionMatch)
>
> + self.enterRule(localctx, 328, self.RULE_vfrExpressionMatch)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2641
>
> + self.state = 2645
>
> self.match(VfrSyntaxParser.Match)
>
> - self.state = 2642
>
> + self.state = 2646
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2643
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2644
>
> + self.state = 2647
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2648
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2645
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2646
>
> + self.state = 2649
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2650
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17536,7 +17534,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.M2Obj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Match2(self):
>
> @@ -17580,24 +17578,24 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionMatch2(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionMatch2Context(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 328, self.RULE_vfrExpressionMatch2)
>
> + self.enterRule(localctx, 330, self.RULE_vfrExpressionMatch2)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2648
>
> + self.state = 2652
>
> self.match(VfrSyntaxParser.Match2)
>
> - self.state = 2649
>
> + self.state = 2653
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2650
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2651
>
> + self.state = 2654
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2655
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2652
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2653
>
> + self.state = 2656
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2657
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2654
>
> + self.state = 2658
>
> self.guidDefinition()
>
> - self.state = 2655
>
> + self.state = 2659
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17614,6 +17612,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def OpenParen(self):
>
> @@ -17641,14 +17640,14 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionParen(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionParenContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 330, self.RULE_vfrExpressionParen)
>
> + self.enterRule(localctx, 332, self.RULE_vfrExpressionParen)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2657
>
> + self.state = 2661
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2658
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2659
>
> + self.state = 2662
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2663
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17665,6 +17664,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = None
>
> self.ExpInfo = ExpInfo
>
>
>
> def dupExp(self):
>
> @@ -17726,64 +17726,64 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionBuildInFunction(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionBuildInFunctionContext(self,
> self._ctx, self.state, ExpInfo)
>
> - self.enterRule(localctx, 332, self.RULE_vfrExpressionBuildInFunction)
>
> + self.enterRule(localctx, 334, self.RULE_vfrExpressionBuildInFunction)
>
> try:
>
> - self.state = 2672
>
> + self.state = 2676
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Dup]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2661
>
> + self.state = 2665
>
> self.dupExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.VarEqVal]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2662
>
> + self.state = 2666
>
> self.vareqvalExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.IdEqVal]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2663
>
> + self.state = 2667
>
> self.ideqvalExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.IdEqId]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2664
>
> + self.state = 2668
>
> self.ideqidExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.IdEqValList]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 2665
>
> + self.state = 2669
>
> self.ideqvallistExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.QuestionRef]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 2666
>
> + self.state = 2670
>
> self.questionref1Exp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.RuleRef]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 2667
>
> + self.state = 2671
>
> self.rulerefExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.StringRef]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 2668
>
> + self.state = 2672
>
> self.stringref1Exp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.PushThis]:
>
> self.enterOuterAlt(localctx, 9)
>
> - self.state = 2669
>
> + self.state = 2673
>
> self.pushthisExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Security]:
>
> self.enterOuterAlt(localctx, 10)
>
> - self.state = 2670
>
> + self.state = 2674
>
> self.securityExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Get]:
>
> self.enterOuterAlt(localctx, 11)
>
> - self.state = 2671
>
> + self.state = 2675
>
> self.getExp(ExpInfo)
>
> pass
>
> else:
>
> @@ -17804,7 +17804,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.DObj = None
>
> + self.Node = IfrTreeNode(EFI_IFR_DUP_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def Dup(self):
>
> @@ -17825,10 +17825,10 @@ class VfrSyntaxParser ( Parser ):
> def dupExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.DupExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 334, self.RULE_dupExp)
>
> + self.enterRule(localctx, 336, self.RULE_dupExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2674
>
> + self.state = 2678
>
> self.match(VfrSyntaxParser.Dup)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -17845,6 +17845,8 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = None
>
> + self.VN = None # Token
>
> self.ExpInfo = ExpInfo
>
>
>
> def VarEqVal(self):
>
> @@ -17856,15 +17858,15 @@ class VfrSyntaxParser ( Parser ):
> def OpenParen(self):
>
> return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
>
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 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)
>
>
>
> @@ -17895,50 +17897,50 @@ class VfrSyntaxParser ( Parser ):
> def vareqvalExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VareqvalExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 336, self.RULE_vareqvalExp)
>
> + self.enterRule(localctx, 338, self.RULE_vareqvalExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2676
>
> + self.state = 2680
>
> self.match(VfrSyntaxParser.VarEqVal)
>
> - self.state = 2677
>
> + self.state = 2681
>
> self.match(VfrSyntaxParser.Var)
>
> - self.state = 2678
>
> + self.state = 2682
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2679
>
> - self.match(VfrSyntaxParser.Number)
>
> - self.state = 2680
>
> + self.state = 2683
>
> + localctx.VN = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2684
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2691
>
> + self.state = 2695
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Equal]:
>
> - self.state = 2681
>
> + self.state = 2685
>
> self.match(VfrSyntaxParser.Equal)
>
> - self.state = 2682
>
> + self.state = 2686
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.LessEqual]:
>
> - self.state = 2683
>
> + self.state = 2687
>
> self.match(VfrSyntaxParser.LessEqual)
>
> - self.state = 2684
>
> + self.state = 2688
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.Less]:
>
> - self.state = 2685
>
> + self.state = 2689
>
> self.match(VfrSyntaxParser.Less)
>
> - self.state = 2686
>
> + self.state = 2690
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.GreaterEqual]:
>
> - self.state = 2687
>
> + self.state = 2691
>
> self.match(VfrSyntaxParser.GreaterEqual)
>
> - self.state = 2688
>
> + self.state = 2692
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.Greater]:
>
> - self.state = 2689
>
> + self.state = 2693
>
> self.match(VfrSyntaxParser.Greater)
>
> - self.state = 2690
>
> + self.state = 2694
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> else:
>
> @@ -17959,6 +17961,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = None
>
> self.I = None # Token
>
> self.ExpInfo = ExpInfo
>
>
>
> @@ -18002,44 +18005,44 @@ class VfrSyntaxParser ( Parser ):
> def ideqvalExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.IdeqvalExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 338, self.RULE_ideqvalExp)
>
> + self.enterRule(localctx, 340, self.RULE_ideqvalExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2693
>
> + self.state = 2697
>
> localctx.I = self.match(VfrSyntaxParser.IdEqVal)
>
> - self.state = 2694
>
> + self.state = 2698
>
> self.vfrQuestionDataFieldName()
>
> - self.state = 2705
>
> + self.state = 2709
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Equal]:
>
> - self.state = 2695
>
> + self.state = 2699
>
> self.match(VfrSyntaxParser.Equal)
>
> - self.state = 2696
>
> + self.state = 2700
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.LessEqual]:
>
> - self.state = 2697
>
> + self.state = 2701
>
> self.match(VfrSyntaxParser.LessEqual)
>
> - self.state = 2698
>
> + self.state = 2702
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.Less]:
>
> - self.state = 2699
>
> + self.state = 2703
>
> self.match(VfrSyntaxParser.Less)
>
> - self.state = 2700
>
> + self.state = 2704
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.GreaterEqual]:
>
> - self.state = 2701
>
> + self.state = 2705
>
> self.match(VfrSyntaxParser.GreaterEqual)
>
> - self.state = 2702
>
> + self.state = 2706
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> elif token in [VfrSyntaxParser.Greater]:
>
> - self.state = 2703
>
> + self.state = 2707
>
> self.match(VfrSyntaxParser.Greater)
>
> - self.state = 2704
>
> + self.state = 2708
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> else:
>
> @@ -18060,6 +18063,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = None
>
> self.I = None # Token
>
> self.E = None # Token
>
> self.LE = None # Token
>
> @@ -18108,44 +18112,44 @@ class VfrSyntaxParser ( Parser ):
> def ideqidExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.IdeqidExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 340, self.RULE_ideqidExp)
>
> + self.enterRule(localctx, 342, self.RULE_ideqidExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2707
>
> + self.state = 2711
>
> localctx.I = self.match(VfrSyntaxParser.IdEqId)
>
> - self.state = 2708
>
> + self.state = 2712
>
> self.vfrQuestionDataFieldName()
>
> - self.state = 2719
>
> + self.state = 2723
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Equal]:
>
> - self.state = 2709
>
> + self.state = 2713
>
> localctx.E = self.match(VfrSyntaxParser.Equal)
>
> - self.state = 2710
>
> + self.state = 2714
>
> self.vfrQuestionDataFieldName()
>
> pass
>
> elif token in [VfrSyntaxParser.LessEqual]:
>
> - self.state = 2711
>
> + self.state = 2715
>
> localctx.LE = self.match(VfrSyntaxParser.LessEqual)
>
> - self.state = 2712
>
> + self.state = 2716
>
> self.vfrQuestionDataFieldName()
>
> pass
>
> elif token in [VfrSyntaxParser.Less]:
>
> - self.state = 2713
>
> + self.state = 2717
>
> localctx.L = self.match(VfrSyntaxParser.Less)
>
> - self.state = 2714
>
> + self.state = 2718
>
> self.vfrQuestionDataFieldName()
>
> pass
>
> elif token in [VfrSyntaxParser.GreaterEqual]:
>
> - self.state = 2715
>
> + self.state = 2719
>
> localctx.BE = self.match(VfrSyntaxParser.GreaterEqual)
>
> - self.state = 2716
>
> + self.state = 2720
>
> self.vfrQuestionDataFieldName()
>
> pass
>
> elif token in [VfrSyntaxParser.Greater]:
>
> - self.state = 2717
>
> + self.state = 2721
>
> localctx.B = self.match(VfrSyntaxParser.Greater)
>
> - self.state = 2718
>
> + self.state = 2722
>
> self.vfrQuestionDataFieldName()
>
> pass
>
> else:
>
> @@ -18166,6 +18170,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = None
>
> self.ExpInfo = ExpInfo
>
>
>
> def IdEqValList(self):
>
> @@ -18199,23 +18204,23 @@ class VfrSyntaxParser ( Parser ):
> def ideqvallistExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.IdeqvallistExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 342, self.RULE_ideqvallistExp)
>
> + self.enterRule(localctx, 344, self.RULE_ideqvallistExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2721
>
> + self.state = 2725
>
> self.match(VfrSyntaxParser.IdEqValList)
>
> - self.state = 2722
>
> + self.state = 2726
>
> self.vfrQuestionDataFieldName()
>
> - self.state = 2723
>
> + self.state = 2727
>
> self.match(VfrSyntaxParser.Equal)
>
> - self.state = 2725
>
> + self.state = 2729
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while True:
>
> - self.state = 2724
>
> + self.state = 2728
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2727
>
> + self.state = 2731
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if not (_la==VfrSyntaxParser.Number):
>
> @@ -18310,39 +18315,39 @@ class VfrSyntaxParser ( Parser ):
> def vfrQuestionDataFieldName(self):
>
>
>
> localctx = VfrSyntaxParser.VfrQuestionDataFieldNameContext(self,
> self._ctx, self.state)
>
> - self.enterRule(localctx, 344, self.RULE_vfrQuestionDataFieldName)
>
> + self.enterRule(localctx, 346, self.RULE_vfrQuestionDataFieldName)
>
> self._la = 0 # Token type
>
> try:
>
> - self.state = 2741
>
> + self.state = 2745
>
> self._errHandler.sync(self)
>
> - la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
>
> + la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
>
> if la_ == 1:
>
> localctx =
> VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context(self, localctx)
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2729
>
> + self.state = 2733
>
> localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 2730
>
> + self.state = 2734
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2731
>
> + self.state = 2735
>
> localctx.I = self.match(VfrSyntaxParser.Number)
>
> - self.state = 2732
>
> + self.state = 2736
>
> self.match(VfrSyntaxParser.CloseBracket)
>
> pass
>
>
>
> elif la_ == 2:
>
> localctx =
> VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context(self, localctx)
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2733
>
> + self.state = 2737
>
> localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 2738
>
> + self.state = 2742
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.Dot:
>
> - self.state = 2734
>
> + self.state = 2738
>
> self.match(VfrSyntaxParser.Dot)
>
> - self.state = 2735
>
> + self.state = 2739
>
> self.arrayName()
>
> - self.state = 2740
>
> + self.state = 2744
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> @@ -18394,21 +18399,21 @@ class VfrSyntaxParser ( Parser ):
> def arrayName(self):
>
>
>
> localctx = VfrSyntaxParser.ArrayNameContext(self, self._ctx, self.state)
>
> - self.enterRule(localctx, 346, self.RULE_arrayName)
>
> + self.enterRule(localctx, 348, self.RULE_arrayName)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2743
>
> - self.match(VfrSyntaxParser.StringIdentifier)
>
> self.state = 2747
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2751
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.OpenBracket:
>
> - self.state = 2744
>
> + self.state = 2748
>
> self.match(VfrSyntaxParser.OpenBracket)
>
> - self.state = 2745
>
> + self.state = 2749
>
> localctx.N = self.match(VfrSyntaxParser.Number)
>
> - self.state = 2746
>
> + self.state = 2750
>
> self.match(VfrSyntaxParser.CloseBracket)
>
>
>
>
>
> @@ -18427,6 +18432,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_QUESTION_REF1_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def QuestionRef(self):
>
> @@ -18459,22 +18465,22 @@ class VfrSyntaxParser ( Parser ):
> def questionref1Exp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.Questionref1ExpContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 348, self.RULE_questionref1Exp)
>
> + self.enterRule(localctx, 350, self.RULE_questionref1Exp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2749
>
> + self.state = 2753
>
> self.match(VfrSyntaxParser.QuestionRef)
>
> - self.state = 2750
>
> + self.state = 2754
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2751
>
> + self.state = 2755
>
> _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.state = 2756
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -18491,6 +18497,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_RULE_REF_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def RuleRef(self):
>
> @@ -18520,16 +18527,16 @@ class VfrSyntaxParser ( Parser ):
> def rulerefExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.RulerefExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 350, self.RULE_rulerefExp)
>
> + self.enterRule(localctx, 352, self.RULE_rulerefExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2754
>
> + self.state = 2758
>
> self.match(VfrSyntaxParser.RuleRef)
>
> - self.state = 2755
>
> + self.state = 2759
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2756
>
> + self.state = 2760
>
> self.match(VfrSyntaxParser.StringIdentifier)
>
> - self.state = 2757
>
> + self.state = 2761
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -18546,6 +18553,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_STRING_REF1_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def StringRef(self):
>
> @@ -18584,34 +18592,34 @@ class VfrSyntaxParser ( Parser ):
> def stringref1Exp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.Stringref1ExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 352, self.RULE_stringref1Exp)
>
> + self.enterRule(localctx, 354, self.RULE_stringref1Exp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2759
>
> + self.state = 2763
>
> self.match(VfrSyntaxParser.StringRef)
>
> - self.state = 2760
>
> + self.state = 2764
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2766
>
> + self.state = 2770
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.StringToken]:
>
> - self.state = 2761
>
> + self.state = 2765
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2762
>
> + self.state = 2766
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2763
>
> + self.state = 2767
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2764
>
> + self.state = 2768
>
> self.match(VfrSyntaxParser.CloseParen)
>
> pass
>
> elif token in [VfrSyntaxParser.Number]:
>
> - self.state = 2765
>
> + self.state = 2769
>
> self.match(VfrSyntaxParser.Number)
>
> pass
>
> else:
>
> raise NoViableAltException(self)
>
>
>
> - self.state = 2768
>
> + self.state = 2772
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -18628,6 +18636,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_THIS_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def PushThis(self):
>
> @@ -18648,10 +18657,10 @@ class VfrSyntaxParser ( Parser ):
> def pushthisExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.PushthisExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 354, self.RULE_pushthisExp)
>
> + self.enterRule(localctx, 356, self.RULE_pushthisExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2770
>
> + self.state = 2774
>
> self.match(VfrSyntaxParser.PushThis)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -18668,6 +18677,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_SECURITY_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def Security(self):
>
> @@ -18698,16 +18708,16 @@ class VfrSyntaxParser ( Parser ):
> def securityExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.SecurityExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 356, self.RULE_securityExp)
>
> + self.enterRule(localctx, 358, self.RULE_securityExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2772
>
> + self.state = 2776
>
> self.match(VfrSyntaxParser.Security)
>
> - self.state = 2773
>
> + self.state = 2777
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2774
>
> + self.state = 2778
>
> self.guidDefinition()
>
> - self.state = 2775
>
> + self.state = 2779
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -18752,11 +18762,11 @@ class VfrSyntaxParser ( Parser ):
> def numericVarStoreType(self):
>
>
>
> localctx = VfrSyntaxParser.NumericVarStoreTypeContext(self, self._ctx,
> self.state)
>
> - self.enterRule(localctx, 358, self.RULE_numericVarStoreType)
>
> + self.enterRule(localctx, 360, self.RULE_numericVarStoreType)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2777
>
> + self.state = 2781
>
> _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)
>
> @@ -18779,7 +18789,7 @@ class VfrSyntaxParser ( Parser ):
> self.parser = parser
>
> self.ExpInfo = None
>
> self.BaseInfo = EFI_VARSTORE_INFO()
>
> - self.GObj = None
>
> + self.Node = IfrTreeNode(EFI_IFR_GET_OP)
>
> self.ExpInfo = ExpInfo
>
>
>
> def Get(self):
>
> @@ -18820,31 +18830,31 @@ class VfrSyntaxParser ( Parser ):
> def getExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.GetExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 360, self.RULE_getExp)
>
> + self.enterRule(localctx, 362, self.RULE_getExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2779
>
> + self.state = 2783
>
> self.match(VfrSyntaxParser.Get)
>
> - self.state = 2780
>
> + self.state = 2784
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2781
>
> + self.state = 2785
>
> self.vfrStorageVarId(localctx.BaseInfo, False)
>
> - self.state = 2786
>
> + self.state = 2790
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2782
>
> + self.state = 2786
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2783
>
> + self.state = 2787
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2784
>
> + self.state = 2788
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2785
>
> + self.state = 2789
>
> self.numericVarStoreType()
>
>
>
>
>
> - self.state = 2788
>
> + self.state = 2792
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -18861,6 +18871,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Node = None
>
> self.ExpInfo = ExpInfo
>
>
>
> def TrueSymbol(self):
>
> @@ -18902,11 +18913,11 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionConstant(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionConstantContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 362, self.RULE_vfrExpressionConstant)
>
> + self.enterRule(localctx, 364, self.RULE_vfrExpressionConstant)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2790
>
> + self.state = 2794
>
> _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)
>
> @@ -18928,6 +18939,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Nodes = None
>
> self.ExpInfo = ExpInfo
>
>
>
> def lengthExp(self):
>
> @@ -18985,59 +18997,59 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionUnaryOp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionUnaryOpContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 364, self.RULE_vfrExpressionUnaryOp)
>
> + self.enterRule(localctx, 366, self.RULE_vfrExpressionUnaryOp)
>
> try:
>
> - self.state = 2802
>
> + self.state = 2806
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Length]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2792
>
> + self.state = 2796
>
> self.lengthExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.BitWiseNot]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2793
>
> + self.state = 2797
>
> self.bitwisenotExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.QuestionRefVal]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2794
>
> + self.state = 2798
>
> self.question23refExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.StringRefVal]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2795
>
> + self.state = 2799
>
> self.stringref2Exp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.BoolVal]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 2796
>
> + self.state = 2800
>
> self.toboolExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.StringVal]:
>
> self.enterOuterAlt(localctx, 6)
>
> - self.state = 2797
>
> + self.state = 2801
>
> self.tostringExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.UnIntVal]:
>
> self.enterOuterAlt(localctx, 7)
>
> - self.state = 2798
>
> + self.state = 2802
>
> self.unintExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.ToUpper]:
>
> self.enterOuterAlt(localctx, 8)
>
> - self.state = 2799
>
> + self.state = 2803
>
> self.toupperExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.ToLower]:
>
> self.enterOuterAlt(localctx, 9)
>
> - self.state = 2800
>
> + self.state = 2804
>
> self.tolwerExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Set]:
>
> self.enterOuterAlt(localctx, 10)
>
> - self.state = 2801
>
> + self.state = 2805
>
> self.setExp(ExpInfo)
>
> pass
>
> else:
>
> @@ -19058,7 +19070,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.LObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Length(self):
>
> @@ -19089,16 +19101,16 @@ class VfrSyntaxParser ( Parser ):
> def lengthExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.LengthExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 366, self.RULE_lengthExp)
>
> + self.enterRule(localctx, 368, self.RULE_lengthExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2804
>
> + self.state = 2808
>
> self.match(VfrSyntaxParser.Length)
>
> - self.state = 2805
>
> + self.state = 2809
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2806
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2807
>
> + self.state = 2810
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2811
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19115,7 +19127,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.BWNObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def BitWiseNot(self):
>
> @@ -19146,16 +19158,16 @@ class VfrSyntaxParser ( Parser ):
> def bitwisenotExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.BitwisenotExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 368, self.RULE_bitwisenotExp)
>
> + self.enterRule(localctx, 370, self.RULE_bitwisenotExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2809
>
> + self.state = 2813
>
> self.match(VfrSyntaxParser.BitWiseNot)
>
> - self.state = 2810
>
> + self.state = 2814
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2811
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2812
>
> + self.state = 2815
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2816
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19172,6 +19184,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def QuestionRefVal(self):
>
> @@ -19230,51 +19243,51 @@ class VfrSyntaxParser ( Parser ):
> def question23refExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.Question23refExpContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 370, self.RULE_question23refExp)
>
> + self.enterRule(localctx, 372, self.RULE_question23refExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2814
>
> + self.state = 2818
>
> self.match(VfrSyntaxParser.QuestionRefVal)
>
> - self.state = 2815
>
> + self.state = 2819
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2823
>
> + self.state = 2827
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.DevicePath:
>
> - self.state = 2816
>
> + self.state = 2820
>
> self.match(VfrSyntaxParser.DevicePath)
>
> - self.state = 2817
>
> + self.state = 2821
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2818
>
> + self.state = 2822
>
> self.match(VfrSyntaxParser.StringToken)
>
> - self.state = 2819
>
> + self.state = 2823
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2820
>
> + self.state = 2824
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2821
>
> + self.state = 2825
>
> self.match(VfrSyntaxParser.CloseParen)
>
> - self.state = 2822
>
> + self.state = 2826
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2830
>
> + self.state = 2834
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.Uuid:
>
> - self.state = 2825
>
> + self.state = 2829
>
> self.match(VfrSyntaxParser.Uuid)
>
> - self.state = 2826
>
> + self.state = 2830
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2827
>
> + self.state = 2831
>
> self.guidDefinition()
>
> - self.state = 2828
>
> + self.state = 2832
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2832
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2833
>
> + self.state = 2836
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2837
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19291,7 +19304,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.SR2Obj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def StringRefVal(self):
>
> @@ -19322,16 +19335,16 @@ class VfrSyntaxParser ( Parser ):
> def stringref2Exp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.Stringref2ExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 372, self.RULE_stringref2Exp)
>
> + self.enterRule(localctx, 374, self.RULE_stringref2Exp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2835
>
> + self.state = 2839
>
> self.match(VfrSyntaxParser.StringRefVal)
>
> - self.state = 2836
>
> + self.state = 2840
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2837
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2838
>
> + self.state = 2841
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2842
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19348,7 +19361,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TBObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def BoolVal(self):
>
> @@ -19379,16 +19392,16 @@ class VfrSyntaxParser ( Parser ):
> def toboolExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.ToboolExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 374, self.RULE_toboolExp)
>
> + self.enterRule(localctx, 376, self.RULE_toboolExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2840
>
> + self.state = 2844
>
> self.match(VfrSyntaxParser.BoolVal)
>
> - self.state = 2841
>
> + self.state = 2845
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2842
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2843
>
> + self.state = 2846
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2847
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19405,7 +19418,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TSObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def StringVal(self):
>
> @@ -19442,31 +19455,31 @@ class VfrSyntaxParser ( Parser ):
> def tostringExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.TostringExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 376, self.RULE_tostringExp)
>
> + self.enterRule(localctx, 378, self.RULE_tostringExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2845
>
> + self.state = 2849
>
> self.match(VfrSyntaxParser.StringVal)
>
> - self.state = 2850
>
> + self.state = 2854
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.T__14:
>
> - self.state = 2846
>
> + self.state = 2850
>
> self.match(VfrSyntaxParser.T__14)
>
> - self.state = 2847
>
> + self.state = 2851
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2848
>
> + self.state = 2852
>
> self.match(VfrSyntaxParser.Number)
>
> - self.state = 2849
>
> + self.state = 2853
>
> self.match(VfrSyntaxParser.Comma)
>
>
>
>
>
> - self.state = 2852
>
> + self.state = 2856
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2853
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2854
>
> + self.state = 2857
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2858
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19483,7 +19496,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TUObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def UnIntVal(self):
>
> @@ -19514,16 +19527,16 @@ class VfrSyntaxParser ( Parser ):
> def unintExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.UnintExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 378, self.RULE_unintExp)
>
> + self.enterRule(localctx, 380, self.RULE_unintExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2856
>
> + self.state = 2860
>
> self.match(VfrSyntaxParser.UnIntVal)
>
> - self.state = 2857
>
> + self.state = 2861
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2858
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2859
>
> + self.state = 2862
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2863
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19540,7 +19553,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TUObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def ToUpper(self):
>
> @@ -19571,16 +19584,16 @@ class VfrSyntaxParser ( Parser ):
> def toupperExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.ToupperExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 380, self.RULE_toupperExp)
>
> + self.enterRule(localctx, 382, self.RULE_toupperExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2861
>
> + self.state = 2865
>
> self.match(VfrSyntaxParser.ToUpper)
>
> - self.state = 2862
>
> + self.state = 2866
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2863
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2864
>
> + self.state = 2867
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2868
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19597,7 +19610,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TLObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def ToLower(self):
>
> @@ -19628,16 +19641,16 @@ class VfrSyntaxParser ( Parser ):
> def tolwerExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.TolwerExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 382, self.RULE_tolwerExp)
>
> + self.enterRule(localctx, 384, self.RULE_tolwerExp)
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2866
>
> + self.state = 2870
>
> self.match(VfrSyntaxParser.ToLower)
>
> - self.state = 2867
>
> + self.state = 2871
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2868
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2869
>
> + self.state = 2872
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2873
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19655,7 +19668,7 @@ class VfrSyntaxParser ( Parser ):
> self.parser = parser
>
> self.ExpInfo = None
>
> self.BaseInfo = EFI_VARSTORE_INFO()
>
> - self.TSObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Set(self):
>
> @@ -19703,35 +19716,35 @@ class VfrSyntaxParser ( Parser ):
> def setExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.SetExpContext(self, self._ctx, self.state, ExpInfo)
>
> - self.enterRule(localctx, 384, self.RULE_setExp)
>
> + self.enterRule(localctx, 386, self.RULE_setExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2871
>
> + self.state = 2875
>
> self.match(VfrSyntaxParser.Set)
>
> - self.state = 2872
>
> + self.state = 2876
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2873
>
> + self.state = 2877
>
> self.vfrStorageVarId(localctx.BaseInfo, False)
>
> - self.state = 2878
>
> + self.state = 2882
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> if _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2874
>
> + self.state = 2878
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2875
>
> + self.state = 2879
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2876
>
> + self.state = 2880
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2877
>
> + self.state = 2881
>
> self.numericVarStoreType()
>
>
>
>
>
> - self.state = 2880
>
> + self.state = 2884
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2881
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2882
>
> + self.state = 2885
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2886
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19748,6 +19761,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> + self.Nodes = None
>
> self.ExpInfo = ExpInfo
>
>
>
> def conditionalExp(self):
>
> @@ -19785,34 +19799,34 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionTernaryOp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionTernaryOpContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 386, self.RULE_vfrExpressionTernaryOp)
>
> + self.enterRule(localctx, 388, self.RULE_vfrExpressionTernaryOp)
>
> try:
>
> - self.state = 2889
>
> + self.state = 2893
>
> self._errHandler.sync(self)
>
> token = self._input.LA(1)
>
> if token in [VfrSyntaxParser.Cond]:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2884
>
> + self.state = 2888
>
> self.conditionalExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Find]:
>
> self.enterOuterAlt(localctx, 2)
>
> - self.state = 2885
>
> + self.state = 2889
>
> self.findExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Mid]:
>
> self.enterOuterAlt(localctx, 3)
>
> - self.state = 2886
>
> + self.state = 2890
>
> self.midExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Tok]:
>
> self.enterOuterAlt(localctx, 4)
>
> - self.state = 2887
>
> + self.state = 2891
>
> self.tokenExp(ExpInfo)
>
> pass
>
> elif token in [VfrSyntaxParser.Span]:
>
> self.enterOuterAlt(localctx, 5)
>
> - self.state = 2888
>
> + self.state = 2892
>
> self.spanExp(ExpInfo)
>
> pass
>
> else:
>
> @@ -19833,7 +19847,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.CObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Cond(self):
>
> @@ -19870,24 +19884,24 @@ class VfrSyntaxParser ( Parser ):
> def conditionalExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.ConditionalExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 388, self.RULE_conditionalExp)
>
> + self.enterRule(localctx, 390, 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.match(VfrSyntaxParser.Cond)
>
> self.state = 2896
>
> - self.match(VfrSyntaxParser.Colon)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2897
>
> - self.vfrStatementExpressionSub()
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> self.state = 2898
>
> + self.match(VfrSyntaxParser.T__15)
>
> + self.state = 2899
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2900
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 2901
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2902
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -19904,7 +19918,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.FObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Find(self):
>
> @@ -19957,41 +19971,41 @@ class VfrSyntaxParser ( Parser ):
> def findExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.FindExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 390, self.RULE_findExp)
>
> + self.enterRule(localctx, 392, self.RULE_findExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2900
>
> + self.state = 2904
>
> self.match(VfrSyntaxParser.Find)
>
> - self.state = 2901
>
> + self.state = 2905
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2902
>
> + self.state = 2906
>
> self.findFormat(ExpInfo)
>
> - self.state = 2907
>
> + self.state = 2911
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2903
>
> + self.state = 2907
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2904
>
> + self.state = 2908
>
> self.findFormat(ExpInfo)
>
> - self.state = 2909
>
> + self.state = 2913
>
> 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.vfrStatementExpressionSub(localctx.Nodes)
>
> self.state = 2916
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2917
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2918
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2919
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2920
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -20032,11 +20046,11 @@ class VfrSyntaxParser ( Parser ):
> def findFormat(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.FindFormatContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 392, self.RULE_findFormat)
>
> + self.enterRule(localctx, 394, self.RULE_findFormat)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2918
>
> + self.state = 2922
>
> _la = self._input.LA(1)
>
> if not(_la==VfrSyntaxParser.Insensitive or
> _la==VfrSyntaxParser.Sensitive):
>
> self._errHandler.recoverInline(self)
>
> @@ -20058,7 +20072,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.MObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Mid(self):
>
> @@ -20098,24 +20112,24 @@ class VfrSyntaxParser ( Parser ):
> def midExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.MidExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 394, self.RULE_midExp)
>
> + self.enterRule(localctx, 396, 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.match(VfrSyntaxParser.Mid)
>
> self.state = 2925
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2926
>
> - self.vfrStatementExpressionSub()
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> self.state = 2927
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2928
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2929
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2930
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2931
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -20132,7 +20146,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.TObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Tok(self):
>
> @@ -20172,24 +20186,24 @@ class VfrSyntaxParser ( Parser ):
> def tokenExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.TokenExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 396, self.RULE_tokenExp)
>
> + self.enterRule(localctx, 398, 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.match(VfrSyntaxParser.Tok)
>
> self.state = 2934
>
> - self.match(VfrSyntaxParser.Comma)
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> self.state = 2935
>
> - self.vfrStatementExpressionSub()
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> self.state = 2936
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2937
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2938
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2939
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2940
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -20206,7 +20220,7 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.SObj = None
>
> + self.Nodes = []
>
> self.ExpInfo = ExpInfo
>
>
>
> def Span(self):
>
> @@ -20262,45 +20276,45 @@ class VfrSyntaxParser ( Parser ):
> def spanExp(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.SpanExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> - self.enterRule(localctx, 398, self.RULE_spanExp)
>
> + self.enterRule(localctx, 400, self.RULE_spanExp)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2938
>
> + self.state = 2942
>
> self.match(VfrSyntaxParser.Span)
>
> - self.state = 2939
>
> + self.state = 2943
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2940
>
> + self.state = 2944
>
> self.match(VfrSyntaxParser.FLAGS)
>
> - self.state = 2941
>
> + self.state = 2945
>
> self.match(VfrSyntaxParser.T__5)
>
> - self.state = 2942
>
> + self.state = 2946
>
> self.spanFlags()
>
> - self.state = 2947
>
> + self.state = 2951
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
> while _la==VfrSyntaxParser.BitWiseOr:
>
> - self.state = 2943
>
> + self.state = 2947
>
> self.match(VfrSyntaxParser.BitWiseOr)
>
> - self.state = 2944
>
> + self.state = 2948
>
> self.spanFlags()
>
> - self.state = 2949
>
> + self.state = 2953
>
> 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.vfrStatementExpressionSub(localctx.Nodes)
>
> self.state = 2956
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2957
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2958
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2959
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2960
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> @@ -20342,11 +20356,11 @@ class VfrSyntaxParser ( Parser ):
> def spanFlags(self):
>
>
>
> localctx = VfrSyntaxParser.SpanFlagsContext(self, self._ctx, self.state)
>
> - self.enterRule(localctx, 400, self.RULE_spanFlags)
>
> + self.enterRule(localctx, 402, self.RULE_spanFlags)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2958
>
> + self.state = 2962
>
> _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)
>
> @@ -20368,7 +20382,8 @@ class VfrSyntaxParser ( Parser ):
> super().__init__(parent, invokingState)
>
> self.parser = parser
>
> self.ExpInfo = None
>
> - self.MObj = None
>
> + self.Nodes = []
>
> + self.Node = IfrTreeNode()
>
> self.ExpInfo = ExpInfo
>
>
>
> def Map(self):
>
> @@ -20421,35 +20436,35 @@ class VfrSyntaxParser ( Parser ):
> def vfrExpressionMap(self, ExpInfo):
>
>
>
> localctx = VfrSyntaxParser.VfrExpressionMapContext(self, self._ctx,
> self.state, ExpInfo)
>
> - self.enterRule(localctx, 402, self.RULE_vfrExpressionMap)
>
> + self.enterRule(localctx, 404, self.RULE_vfrExpressionMap)
>
> self._la = 0 # Token type
>
> try:
>
> self.enterOuterAlt(localctx, 1)
>
> - self.state = 2960
>
> + self.state = 2964
>
> self.match(VfrSyntaxParser.Map)
>
> - self.state = 2961
>
> + self.state = 2965
>
> self.match(VfrSyntaxParser.OpenParen)
>
> - self.state = 2962
>
> - self.vfrStatementExpressionSub()
>
> - self.state = 2963
>
> + self.state = 2966
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2967
>
> self.match(VfrSyntaxParser.Colon)
>
> - self.state = 2971
>
> + self.state = 2975
>
> 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.state = 2968
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2969
>
> self.match(VfrSyntaxParser.Comma)
>
> - self.state = 2966
>
> - self.vfrStatementExpression()
>
> - self.state = 2967
>
> + self.state = 2970
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2971
>
> self.match(VfrSyntaxParser.Semicolon)
>
> - self.state = 2973
>
> + self.state = 2977
>
> self._errHandler.sync(self)
>
> _la = self._input.LA(1)
>
>
>
> - self.state = 2974
>
> + self.state = 2978
>
> self.match(VfrSyntaxParser.CloseParen)
>
> except RecognitionException as re:
>
> localctx.exception = re
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> index 8d0e907a75..fd5905340c 100644
> --- a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> @@ -1,5106 +1,5504 @@
> -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.GetDefault
> Store(), 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_UNSUPPORT
> ED, 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(c
> tx.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(StoreNam
> e, 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.BaseInf
> o), 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.vfrOneOfOp
> tionFlags().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_D
> EFAULT_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_MANUFACTURIN
> G, ctx.F.line, ctx.F.text)
>
> -
> self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_D
> EFAULT_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_OPCO
> DE, ctx.A.line, ctx.A.text)
>
> - if ctx.LateCheckFlag() != None:
>
> - gCVfrErrorHandle.HandleWarning
> (EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, 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.Var
> Type)
>
> - 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.Var
> Type)
>
> - 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_STAN
> DARD,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_MANUFACTURIN
> G, ctx.F.line, ctx.F.text)
>
> - ReturnCode =
> gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_MAN
> UFACTURING, 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.Var
> Type)
>
> - 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.vfrNumeri
> cFlags().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.Var
> Type)
>
> - 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.Var
> Type)
>
> - 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.Var
> Type)
>
> - 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'%(pInfoNo
> de.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(hex(pInfoNode.Value.u8)))
>
> - if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_16:
>
> - f.write(' \"Value\":
> \"{}\"\n'.format(hex(pInfoNode.Value.u16)))
>
> - if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_32:
>
> - f.write(' \"Value\":
> \"{}\"\n'.format(hex(pInfoNode.Value.u32)))
>
> - if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_64:
>
> - f.write(' \"Value\":
> \"{}\"\n'.format(hex(pInfoNode.Value.u64)))
>
> - if pInfoNode.Type == EFI_IFR_TYPE_BOOLEAN:
>
> - f.write(' \"Value\":
> \"{}\"\n'.format(hex(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'%(MethodMa
> p.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.F
> ormSetGuid.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.F
> ormSetGuid.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.RefreshEve
> ntGroupId.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
> +## @file
> +# The file is defined to parse Vfr syntax
> +#
> +# Copyright (c) 2022-, Intel Corporation. All rights reserved.<BR>
> +# SPDX-License-Identifier: BSD-2-Clause-Patent
> +##
> +
> +from antlr4 import *
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrFormPkg import *
> +from VfrCompiler.IfrUtility import *
> +from VfrCompiler.IfrTree import *
> +from VfrCompiler.IfrError import *
> +from VfrCompiler.IfrPreProcess import *
> +
> +if __name__ is not None and "." in __name__:
> + from .VfrSyntaxParser import VfrSyntaxParser
> +else:
> + from VfrSyntaxParser import VfrSyntaxParser
> +
> +
> +# This class defines a complete generic visitor for a parse tree produced by
> VfrSyntaxParser.
> +class VfrSyntaxVisitor(ParseTreeVisitor):
> + def __init__(
> + self,
> + PreProcessDB: PreProcessDB = None,
> + Root=None,
> + OverrideClassGuid=None,
> + QuestionDB: VfrQuestionDB = None,
> + ):
> + self.Root = Root if Root != None else IfrTreeNode()
> + self.PreProcessDB = PreProcessDB
> + self.OverrideClassGuid = OverrideClassGuid
> + self.VfrQuestionDB = QuestionDB if QuestionDB != None else
> VfrQuestionDB()
> + self.ParserStatus = 0
> + self.Value = None
> + self.LastFormNode = None
> + self.IfrOpHdrIndex = 0
> + self.ConstantOnlyInExpression = False
> + self.IfrOpHdr = [None]
> + self.IfrOpHdrLineNo = [0]
> + self.UsedDefaultArray = []
> + self.VfrRulesDB = VfrRulesDB()
> + self.CurrQestVarInfo = EFI_VARSTORE_INFO()
> + self.CurrentQuestion = None
> + self.CurrentMinMaxData = None
> + self.IsStringOp = False
> + self.IsOrderedList = False
> + self.IsCheckBoxOp = False
> + self.NeedAdjustOpcode = False
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrProgram.
> + def visitVfrProgram(self, ctx: VfrSyntaxParser.VfrProgramContext):
> + return self.visitChildren(ctx)
> +
> + # Visit a parse tree produced by VfrSyntaxParser#pragmaPackShowDef.
> + def visitPragmaPackShowDef(self, ctx:
> VfrSyntaxParser.PragmaPackShowDefContext):
> + Line = ctx.start.line
> + gVfrVarDataTypeDB.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
> + gVfrVarDataTypeDB.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)
> +
> + gVfrVarDataTypeDB.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):
> + gVfrVarDataTypeDB.DeclareDataTypeBegin()
> +
> + if ctx.N1 != None:
> + ReturnCode = gVfrVarDataTypeDB.SetNewTypeName(ctx.N1.text)
> + self.ErrorHandler(ReturnCode, ctx.N1.line, ctx.N1.text)
> +
> + if ctx.N2 != None:
> + ReturnCode = gVfrVarDataTypeDB.SetNewTypeName(ctx.N2.text)
> + self.ErrorHandler(ReturnCode, ctx.N2.line, ctx.N2.text)
> +
> + self.visitChildren(ctx)
> +
> + gVfrVarDataTypeDB.DeclareDataTypeEnd()
> + return None
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrDataUnionDefinition.
> + def visitVfrDataUnionDefinition(self, ctx:
> VfrSyntaxParser.VfrDataUnionDefinitionContext):
> + gVfrVarDataTypeDB.DeclareDataTypeBegin()
> + if ctx.N1 != None:
> + ReturnCode = gVfrVarDataTypeDB.SetNewTypeName(ctx.N1.text)
> + self.ErrorHandler(ReturnCode, ctx.N1.line, ctx.N1.text)
> +
> + if ctx.N2 != None:
> + ReturnCode = gVfrVarDataTypeDB.SetNewTypeName(ctx.N2.text)
> + self.ErrorHandler(ReturnCode, ctx.N2.line, ctx.N2.text)
> +
> + self.visitChildren(ctx)
> +
> + gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.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 = gVfrVarDataTypeDB.DataTypeAddField(
> + ctx.N.text, ctx.T.text, ArrayNum, ctx.FieldInUnion
> + )
> + else:
> + ReturnCode = gVfrVarDataTypeDB.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(
> + gVfrVarDataTypeDB.DataTypeAddBitField(
> + ctx.N.text, "UINT64", Width, ctx.FieldInUnion
> + ),
> + ctx.N.line,
> + ctx.N.text,
> + )
> + else:
> + self.ErrorHandler(
> + gVfrVarDataTypeDB.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(
> + gVfrVarDataTypeDB.DataTypeAddBitField(
> + ctx.N.text, "UINT32", Width, ctx.FieldInUnion
> + ),
> + ctx.N.line,
> + ctx.N.text,
> + )
> + else:
> + self.ErrorHandler(
> + gVfrVarDataTypeDB.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(
> + gVfrVarDataTypeDB.DataTypeAddBitField(
> + ctx.N.text, "UINT16", Width, ctx.FieldInUnion
> + ),
> + ctx.N.line,
> + ctx.N.text,
> + )
> + else:
> + self.ErrorHandler(
> + gVfrVarDataTypeDB.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(
> + gVfrVarDataTypeDB.DataTypeAddBitField(ctx.N.text, "UINT8",
> Width, ctx.FieldInUnion),
> + ctx.N.line,
> + ctx.N.text,
> + )
> + else:
> + self.ErrorHandler(
> + gVfrVarDataTypeDB.DataTypeAddBitField(None, "UINT8", Width,
> ctx.FieldInUnion),
> + ctx.D.line,
> + ctx.D.text,
> + )
> + return self.visitChildren(ctx)
> +
> + def DeclareStandardDefaultStorage(self, LineNo):
> + DSObj = IfrDefaultStore("Standard Defaults")
> + gVfrDefaultStore.RegisterDefaultStore(
> + DSObj.DefaultStore,
> + "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)
> + DsNode = IfrTreeNode(
> + EFI_IFR_DEFAULTSTORE_OP, DSObj,
> gFormPkg.StructToStream(DSObj.GetInfo())
> + )
> +
> + DSObjMF = IfrDefaultStore("Standard ManuFacturing")
> + gVfrDefaultStore.RegisterDefaultStore(
> + DSObjMF.DefaultStore,
> + "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)
> + DsNodeMF = IfrTreeNode(
> + EFI_IFR_DEFAULTSTORE_OP, DSObjMF,
> gFormPkg.StructToStream(DSObjMF.GetInfo())
> + )
> +
> + return DsNode, DsNodeMF
> +
> + # 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())
> +
> + DsNode, DsNodeMF = self.DeclareStandardDefaultStorage(ctx.start.line)
> + ctx.Node.insertChild(DsNode)
> + ctx.Node.insertChild(DsNodeMF)
> +
> + 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,
> + ctx.start.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 = IfrFormSet(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 = IfrFormSet(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 = IfrFormSet(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 = IfrFormSet(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 = IfrFormSet(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(ctx.start.line)
> + FSObj.SetGuid(ctx.guidDefinition().Guid)
> + FSObj.SetFormSetTitle(self.TransNum(ctx.Number(0)))
> + FSObj.SetHelp(self.TransNum(ctx.Number(1)))
> + FSObj.SetClassGuidNum(len(GuidList))
> +
> + ctx.Node.Data = FSObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(FSObj.GetInfo())
> + if len(GuidList) == 0:
> + ctx.Node.Buffer += gFormPkg.StructToStream(DefaultClassGuid)
> + else:
> + for i in range(0, len(GuidList)):
> + ctx.Node.Buffer += gFormPkg.StructToStream(GuidList[i])
> +
> + # Declare undefined Question so that they can be used in expression.
> + InsertOpCodeList = None
> + if gFormPkg.HavePendingUnassigned():
> + InsertOpCodeList, ReturnCode = gFormPkg.DeclarePendingQuestion(
> + gVfrVarDataTypeDB, gVfrDataStorage, self.VfrQuestionDB,
> ctx.stop.line
> + )
> + Status = 0 if ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS
> else 1
> + self.ParserStatus += Status
> + self.NeedAdjustOpcode = True
> +
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + if self.NeedAdjustOpcode:
> + self.LastFormNode.Child.pop()
> + for InsertOpCode in InsertOpCodeList:
> + InsertNode = IfrTreeNode(
> + InsertOpCode.OpCode,
> + InsertOpCode.Data,
> + gFormPkg.StructToStream(InsertOpCode.Data.GetInfo()),
> + )
> + self.LastFormNode.insertChild(InsertNode)
> +
> + gFormPkg.BuildPkg(self.Root)
> + 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 = IfrClass()
> + self.visitChildren(ctx)
> + Class = 0
> + for ClassNameCtx in ctx.validClassNames():
> + Class |= ClassNameCtx.ClassName
> + Line = ctx.start.line
> + CObj.SetLineNo(Line)
> + CObj.SetClass(Class)
> + CObj.SetClassStr(self.ExtractOriginalText(ctx))
> + ctx.Node.Data = CObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(CObj.GetInfo())
> +
> + 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 = IfrSubClass()
> +
> + 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)
> + SubObj.SetSubClassStr(self.ExtractOriginalText(ctx))
> +
> + ctx.Node.Data = SubObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(SubObj.GetInfo())
> +
> + 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):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> +
> + RefName = ctx.N.text
> + DSObj = IfrDefaultStore(RefName)
> + DefaultStoreNameId = self.TransNum(ctx.S.text)
> + DefaultId = (
> + EFI_HII_DEFAULT_CLASS_STANDARD if ctx.Attribute() == None else
> self.TransNum(ctx.A.text)
> + )
> + if ctx.Attribute() != None:
> + DSObj.HasAttr = True
> +
> + if gVfrDefaultStore.DefaultIdRegistered(DefaultId) == False:
> + self.ErrorHandler(
> + gVfrDefaultStore.RegisterDefaultStore(
> + DSObj.DefaultStore, RefName, DefaultStoreNameId, DefaultId
> + ),
> + Line,
> + )
> + DSObj.SetDefaultName(DefaultStoreNameId)
> + DSObj.SetDefaultId(DefaultId)
> + DSObj.SetLineNo(Line)
> + ctx.Node.Data = DSObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(DSObj.GetInfo())
> + else:
> + pNode, ReturnCode = gVfrDefaultStore.ReRegisterDefaultStoreById(
> + DefaultId, RefName, DefaultStoreNameId
> + )
> + self.ErrorHandler(ReturnCode, Line)
> + ctx.Node.OpCode = EFI_IFR_SHOWN_DEFAULTSTORE_OP # For
> display in YAML
> + DSObj.SetDefaultId(DefaultId)
> + DSObj.SetDefaultName(DefaultStoreNameId)
> + ctx.Node.Data = DSObj
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementVarStoreLinear.
> + def visitVfrStatementVarStoreLinear(
> + self, ctx: VfrSyntaxParser.VfrStatementVarStoreLinearContext
> + ):
> + self.visitChildren(ctx)
> +
> + TypeName = str(ctx.getChild(1))
> + if TypeName == "CHAR16":
> + TypeName = "UINT16"
> +
> + IsBitVarStore = False
> + if ctx.TN != None:
> + IsBitVarStore = gVfrVarDataTypeDB.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
> + VSObj = IfrVarStore(TypeName, StoreName)
> + Line = ctx.start.line
> + VSObj.SetLineNo(Line)
> + VSObj.SetHasVarStoreId(ctx.VarId() != None)
> + Guid = ctx.guidDefinition().Guid
> + self.ErrorHandler(
> + gVfrDataStorage.DeclareBufferVarStore(
> + StoreName, Guid, gVfrVarDataTypeDB, TypeName, VarStoreId,
> IsBitVarStore
> + ),
> + Line,
> + )
> + VSObj.SetGuid(Guid)
> + VarStoreId, ReturnCode = gVfrDataStorage.GetVarStoreId(StoreName,
> Guid)
> + self.ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
> + VSObj.SetVarStoreId(VarStoreId)
> + Size, ReturnCode =
> gVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
> + self.ErrorHandler(ReturnCode, Line)
> + VSObj.SetSize(Size)
> + ctx.Node.Data = VSObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(VSObj.GetInfo())
> + ctx.Node.Buffer += bytes("\0", encoding="utf-8")
> +
> + return VSObj
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreEfi.
> + def visitVfrStatementVarStoreEfi(self, ctx:
> VfrSyntaxParser.VfrStatementVarStoreEfiContext):
> + self.visitChildren(ctx)
> + Line = ctx.start.line
> +
> + Guid = ctx.guidDefinition().Guid
> +
> + CustomizedName = False
> + IsBitVarStore = False
> + VarStoreId = EFI_VARSTORE_ID_INVALID
> + IsUEFI23EfiVarstore = True
> + ReturnCode = None
> + NameStringId = None
> + VarSize = None
> +
> + TypeName = str(ctx.getChild(1))
> +
> + if TypeName == "CHAR16":
> + TypeName = "UINT16"
> +
> + elif ctx.TN != None:
> + CustomizedName = True
> + IsBitVarStore = gVfrVarDataTypeDB.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
> + AttributesText = ""
> + for i in range(0, len(ctx.vfrVarStoreEfiAttr())):
> + Attributes |= ctx.vfrVarStoreEfiAttr(i).Attr
> +
> + if i != len(ctx.vfrVarStoreEfiAttr()) - 1:
> + AttributesText += f"{ctx.vfrVarStoreEfiAttr(i).Attr:#010x} | "
> + else:
> + AttributesText += f"{ctx.vfrVarStoreEfiAttr(i).Attr:#010x}"
> +
> + if ctx.SN != None:
> + StoreName = ctx.SN.text
> + else:
> + IsUEFI23EfiVarstore = False
> + NameStringId = self.TransNum(ctx.VN.text)
> + StoreName =
> gVfrStringDB.GetVarStoreNameFromStringId(NameStringId) #
> + if StoreName == None:
> + gVfrErrorHandle.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(
> + gVfrDataStorage.DeclareBufferVarStore(
> + StoreName,
> + Guid,
> + gVfrVarDataTypeDB,
> + TypeName,
> + VarStoreId,
> + IsBitVarStore,
> + Attributes,
> + ),
> + Line,
> + )
> + VarStoreId, ReturnCode = gVfrDataStorage.GetVarStoreId(StoreName,
> Guid)
> + self.ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
> + Size, ReturnCode =
> gVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
> + self.ErrorHandler(ReturnCode, Line)
> + else:
> + self.ErrorHandler(
> + gVfrDataStorage.DeclareBufferVarStore(
> + self.GetText(ctx.TN),
> + Guid,
> + gVfrVarDataTypeDB,
> + TypeName,
> + VarStoreId,
> + IsBitVarStore,
> + Attributes,
> + ),
> + Line,
> + ) #
> + VarStoreId, ReturnCode =
> gVfrDataStorage.GetVarStoreId(self.GetText(ctx.TN), Guid)
> + self.ErrorHandler(ReturnCode, ctx.VN.line, ctx.VN.text)
> + Size, ReturnCode =
> gVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
> + self.ErrorHandler(ReturnCode, ctx.N.line)
> +
> + VSEObj = IfrVarStoreEfi(TypeName, StoreName)
> + VSEObj.SetLineNo(Line)
> + VSEObj.SetHasVarStoreId(ctx.VarId() != None)
> + VSEObj.SetGuid(Guid)
> + VSEObj.SetVarStoreId(VarStoreId)
> + VSEObj.SetSize(Size)
> + VSEObj.SetAttributes(Attributes)
> + VSEObj.SetAttributesText(AttributesText)
> + VSEObj.SetNameStringId(NameStringId)
> + VSEObj.SetVarSize(VarSize)
> +
> + ctx.Node.Data = VSEObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(VSEObj.GetInfo())
> + ctx.Node.Buffer += bytes("\0", encoding="utf-8")
> +
> + 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
> + ):
> + StoreName = ctx.SN.text
> + VSNVObj = IfrVarStoreNameValue(StoreName)
> + 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"
> + )
> +
> + Created = False
> +
> + sIndex = 0 if HasVarStoreId == False else 1
> + eIndex = sIndex + len(ctx.Name())
> + for i in range(sIndex, eIndex):
> + if Created == False:
> + self.ErrorHandler(
> + gVfrDataStorage.DeclareNameVarStoreBegin(StoreName,
> VarStoreId),
> + ctx.SN.line,
> + ctx.SN.text,
> + )
> + Created = True
> + Item = self.TransNum(ctx.Number(i))
> + VSNVObj.SetNameItemList(Item)
> + gVfrDataStorage.NameTableAddItem(Item)
> +
> + gVfrDataStorage.DeclareNameVarStoreEnd(Guid)
> +
> + VSNVObj.SetLineNo(ctx.start.line)
> + VSNVObj.SetGuid(Guid)
> + VarstoreId, ReturnCode = gVfrDataStorage.GetVarStoreId(StoreName,
> Guid)
> + self.ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
> + VSNVObj.SetVarStoreId(VarstoreId)
> + VSNVObj.SetHasVarStoreId(HasVarStoreId)
> +
> + ctx.Node.Data = VSNVObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(VSNVObj.GetInfo())
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementDisableIfFormSet.
> + def visitVfrStatementDisableIfFormSet(
> + self, ctx: VfrSyntaxParser.VfrStatementDisableIfFormSetContext
> + ):
> + DIObj = IfrDisableIf()
> + DIObj.SetLineNo(ctx.start.line)
> + self.ConstantOnlyInExpression = True
> + ctx.Node.Data = DIObj
> + ctx.Node.Condition = (
> + "disableif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementSuppressIfFormSet.
> + def visitVfrStatementSuppressIfFormSet(
> + self, ctx: VfrSyntaxParser.VfrStatementSuppressIfFormSetContext
> + ):
> + SIObj = IfrSuppressIf()
> + SIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = SIObj
> + ctx.Node.Condition = (
> + "suppressif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + 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):
> + if ctx.Node.Data != None:
> + Prompt = self.TransNum(ctx.Number(0))
> + ctx.Node.Data.SetPrompt(Prompt)
> + Help = self.TransNum(ctx.Number(1))
> + ctx.Node.Data.SetHelp(Help)
> +
> + return self.visitChildren(ctx)
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionHeader.
> + def visitVfrQuestionHeader(self, ctx:
> VfrSyntaxParser.VfrQuestionHeaderContext):
> + return self.visitChildren(ctx)
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionBaseInfo.
> + def visitVfrQuestionBaseInfo(self, ctx:
> VfrSyntaxParser.VfrQuestionBaseInfoContext):
> + 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.UsedDefaultArray = []
> +
> + self.visitChildren(ctx)
> +
> + if ctx.Name() != None:
> + QName = ctx.QN.text
> + ReturnCode = self.VfrQuestionDB.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.VfrQuestionDB.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.VfrQuestionDB.RegisterQuestion(QName,
> VarIdStr, QId, gFormPkg)
> + self.ErrorHandler(ReturnCode, ctx.start.line)
> +
> + elif ctx.QType == EFI_QUESION_TYPE.QUESTION_DATE:
> + ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
> + QId, ReturnCode = self.VfrQuestionDB.RegisterNewDateQuestion(
> + QName, VarIdStr, QId, gFormPkg
> + )
> + self.ErrorHandler(ReturnCode, ctx.start.line)
> +
> + elif ctx.QType == EFI_QUESION_TYPE.QUESTION_TIME:
> + ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
> + QId, ReturnCode = self.VfrQuestionDB.RegisterNewTimeQuestion(
> + QName, VarIdStr, QId, gFormPkg
> + )
> + 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.VfrQuestionDB.RegisterRefQuestion(
> + QName, VarIdStr, QId, gFormPkg
> + )
> + self.ErrorHandler(ReturnCode, ctx.start.line)
> + else:
> + QId, ReturnCode = self.VfrQuestionDB.RegisterQuestion(QName,
> None, QId, gFormPkg)
> + self.ErrorHandler(ReturnCode, ctx.start.line)
> + else:
> + self.ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR,
> ctx.start.line)
> +
> + self.CurrQestVarInfo = ctx.BaseInfo
> +
> + if ctx.Node.OpCode == EFI_IFR_ONE_OF_OP:
> + # need to further update the VarType
> + ctx.Node.Data = IfrOneOf(EFI_IFR_TYPE_NUM_SIZE_64, QName,
> VarIdStr)
> + self.CurrentQuestion = ctx.Node.Data
> + self.CurrentMinMaxData = ctx.Node.Data
> +
> + elif ctx.Node.OpCode == EFI_IFR_NUMERIC_OP:
> + ctx.Node.Data = IfrNumeric(EFI_IFR_TYPE_NUM_SIZE_64, QName,
> VarIdStr)
> + self.CurrentQuestion = ctx.Node.Data
> + self.CurrentMinMaxData = ctx.Node.Data
> +
> + if ctx.Node.Data != None:
> + ctx.Node.Data.SetQName(QName)
> + ctx.Node.Data.SetVarIdStr(VarIdStr)
> + ctx.Node.Data.SetQuestionId(QId)
> + ctx.Node.Data.SetHasQuestionId(ctx.QuestionId() != None)
> + if ctx.BaseInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
> + ctx.Node.Data.SetVarStoreInfo(ctx.BaseInfo)
> +
> + return ctx.Node
> +
> + # 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:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, ctx.O.line, ctx.O.text
> + )
> +
> + elif ctx.NVAccessFlag() != None:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, ctx.N.line, ctx.N.text
> + )
> +
> + elif ctx.LateCheckFlag() != None:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, 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 =
> gVfrDataStorage.GetVarStoreId(SName)
> + if ctx.CheckFlag or ReturnCode ==
> VfrReturnCode.VFR_RETURN_SUCCESS:
> + self.ErrorHandler(ReturnCode, ctx.SN1.line, ctx.SN1.text)
> + self.ErrorHandler(
> + gVfrDataStorage.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 =
> gVfrDataStorage.GetVarStoreId(SName)
> + if ctx.CheckFlag or ReturnCode ==
> VfrReturnCode.VFR_RETURN_SUCCESS:
> + self.ErrorHandler(ReturnCode, ctx.SN2.line, ctx.SN2.text)
> + VarStoreType =
> gVfrDataStorage.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 =
> gVfrDataStorage.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(
> + gVfrDataStorage.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,
> + ) = gVfrVarDataTypeDB.GetDataFieldInfo(VarStr)
> + self.ErrorHandler(ReturnCode, ctx.SN2.line, VarStr)
> + VarGuid = gVfrDataStorage.GetVarStoreGuid(ctx.BaseInfo.VarStoreId)
> + self.ErrorHandler(gVfrBufferConfig.Register(SName, VarGuid),
> ctx.SN2.line)
> + ReturnCode = VfrReturnCode(
> + gVfrBufferConfig.Write(
> + "a",
> + SName,
> + VarGuid,
> + None,
> + ctx.BaseInfo.VarType,
> + ctx.BaseInfo.Info.VarOffset,
> + ctx.BaseInfo.VarTotalSize,
> + self.Value,
> + )
> + )
> + self.ErrorHandler(ReturnCode, ctx.SN2.line)
> + self.ErrorHandler(
> + gVfrDataStorage.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 = IfrNumeric(self.CurrentQuestion) #
> + IntDecStyle = (
> + True if (NumericQst.GetNumericFlags() & EFI_IFR_DISPLAY) == 0 else
> False
> + ) #
> +
> + if ctx.TrueSymbol() != None:
> + ctx.ValueList.append(1)
> +
> + elif ctx.FalseSymbol() != None:
> + ctx.ValueList.append(0)
> +
> + elif ctx.One() != None:
> + ctx.ValueList.append(int(ctx.getText()))
> +
> + elif ctx.Ones() != None:
> + ctx.ValueList.append(int(ctx.getText()))
> +
> + elif ctx.Zero() != None:
> + ctx.ValueList.append(int(ctx.getText()))
> +
> + elif ctx.Colon() != []:
> + Time = EFI_HII_TIME()
> + Time.Hour = self.TransNum(ctx.Number(0))
> + Time.Minute = self.TransNum(ctx.Number(1))
> + Time.Second = self.TransNum(ctx.Number(2))
> + ctx.ValueList.append(Time)
> +
> + elif ctx.Slash() != []:
> + Date = EFI_HII_DATE()
> + Date.Year = self.TransNum(ctx.Number(0))
> + Date.Month = self.TransNum(ctx.Number(1))
> + Date.Day = self.TransNum(ctx.Number(2))
> + ctx.ValueList.append(Date)
> +
> + elif ctx.Semicolon() != []:
> + Ref = EFI_HII_REF()
> + Ref.QuestionId = self.TransNum(ctx.Number(0))
> + Ref.FormId = self.TransNum(ctx.Number(1))
> + Ref.DevicePath = self.TransNum(ctx.Number(2))
> + Ref.FormSetGuid = ctx.guidDefinition().Guid
> + ctx.ValueList.append(Ref)
> +
> + elif ctx.StringToken() != None:
> + ctx.ValueList.append(self.TransNum(ctx.Number(0)))
> +
> + elif ctx.OpenBrace() != None:
> + ctx.ListType = True
> + Type = self.CurrQestVarInfo.VarType
> + for i in range(0, len(ctx.Number())):
> + ctx.ValueList.append(self.TransNum(ctx.Number(i)))
> +
> + 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.ValueList.append(self.TransNum(ctx.Number(0)))
> + else:
> + Type = self.CurrQestVarInfo.VarType
> + if Type == EFI_IFR_TYPE_NUM_SIZE_8:
> + Value = self.TransNum(ctx.Number(0))
> + if IntDecStyle:
> + if Negative:
> + if Value > 0x80:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT8 type can't big than 0x7F, small than -0x80",
> + )
> + else:
> + if Value > 0x7F:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT8 type can't big than 0x7F, small than -0x80",
> + )
> + if Negative:
> + Value = ~Value + 1
> + ctx.ValueList.append(Value)
> +
> + if Type == EFI_IFR_TYPE_NUM_SIZE_16:
> + Value = self.TransNum(ctx.Number(0))
> + if IntDecStyle:
> + if Negative:
> + if Value > 0x8000:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT16 type can't big than 0x7FFF, small than -0x8000",
> + )
> + else:
> + if Value > 0x7FFF:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT16 type can't big than 0x7FFF, small than -0x8000",
> + )
> + if Negative:
> + Value = ~Value + 1
> + ctx.ValueList.append(Value)
> +
> + if Type == EFI_IFR_TYPE_NUM_SIZE_32:
> + Value = self.TransNum(ctx.Number(0))
> + if IntDecStyle:
> + if Negative:
> + if Value > 0x80000000:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT32 type can't big than 0x7FFFFFFF, small than -
> 0x80000000",
> + )
> + else:
> + if Value > 0x7FFFFFFF:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT32 type can't big than 0x7FFFFFFF, small than -
> 0x80000000",
> + )
> + if Negative:
> + Value = ~Value + 1
> + ctx.ValueList.append(Value)
> +
> + if Type == EFI_IFR_TYPE_NUM_SIZE_64:
> + Value = self.TransNum(ctx.Number(0))
> + if IntDecStyle:
> + if Negative:
> + if Value > 0x8000000000000000:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small
> than -0x8000000000000000",
> + )
> + else:
> + if Value > 0x7FFFFFFFFFFFFFFF:
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + ctx.start.line,
> + "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small
> than -0x8000000000000000",
> + )
> + if Negative:
> + Value = ~Value + 1
> + ctx.ValueList.append(Value)
> +
> + else:
> + ctx.ValueList.append(self.TransNum(ctx.Number(0)))
> +
> + return ctx.ValueList
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrImageTag.
> + def visitVfrImageTag(self, ctx: VfrSyntaxParser.VfrImageTagContext):
> + IObj = IfrImage()
> + self.visitChildren(ctx)
> + IObj.SetLineNo(ctx.start.line)
> + IObj.SetImageId(self.TransNum(ctx.Number()))
> + ctx.Node.Data = IObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(IObj.GetInfo())
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrLockedTag.
> + def visitVfrLockedTag(self, ctx: VfrSyntaxParser.VfrLockedTagContext):
> + LObj = IfrLocked()
> + self.visitChildren(ctx)
> + LObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = LObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(LObj.GetInfo())
> + 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
> + elif ctx.vfrLockedTag() != None:
> + 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 = IfrForm()
> + 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)
> + ctx.Node.Buffer = gFormPkg.StructToStream(FObj.GetInfo())
> +
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + self.LastFormNode = ctx.Node
> +
> + 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 = IfrFormMap()
> + self.visitChildren(ctx)
> + FormMapMethodNumber = len(ctx.MapTitle())
> + Line = ctx.start.line
> + FMapObj.SetLineNo(Line)
> + self.ErrorHandler(FMapObj.SetFormId(self.TransNum(ctx.S1.text)),
> ctx.S1.line, ctx.S1.line)
> + 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
> + )
> + FormMap = FMapObj.GetInfo()
> + MethodMapList = FMapObj.GetMethodMapList()
> + for MethodMap in MethodMapList:
> + # Extend Header Size for MethodMapList
> + FormMap.Header.Length += sizeof(EFI_IFR_FORM_MAP_METHOD)
> +
> + ctx.Node.Data = FMapObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(FormMap)
> + for MethodMap in MethodMapList:
> + ctx.Node.Buffer += gFormPkg.StructToStream(MethodMap)
> + for Ctx in ctx.vfrForm():
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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 = IfrRule()
> + self.visitChildren(ctx)
> +
> + RObj.SetLineNo(ctx.start.line)
> + RuleName = self.TransId(ctx.StringIdentifier())
> + RObj.SetRuleName(RuleName)
> + self.VfrRulesDB.RegisterRule(RuleName)
> + RObj.SetRuleId(self.VfrRulesDB.GetRuleId(RuleName))
> + ctx.Node.Data = RObj
> + # expression
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + ctx.Node.Buffer = gFormPkg.StructToStream(RObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + 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 = IfrSubtitle()
> +
> + 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)
> + SObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrSubtitleFlags()))
> +
> + ctx.Node.Buffer = gFormPkg.StructToStream(SObj.GetInfo())
> + # sequence question
> + for Ctx in ctx.vfrStatementSubTitleComponent():
> + self.InsertChild(ctx.Node, Ctx)
> + ctx.Node.Data = SObj
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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
> + FlagsStream = ""
> + for i in range(0, len(ctx.staticTextFlagsField())):
> + TextFlags |= ctx.staticTextFlagsField(i).Flag
> + FlagsStream += self.ExtractOriginalText(ctx.staticTextFlagsField(i))
> + if i != len(ctx.staticTextFlagsField()) - 1:
> + FlagsStream += " | "
> +
> + if TextFlags & EFI_IFR_FLAG_CALLBACK:
> + if TxtTwo != EFI_STRING_ID_INVALID:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_ACTION_WITH_TEXT_TWO,
> ctx.S3.line, ctx.S3.text
> + )
> +
> + AObj = IfrAction()
> + QId, _ = self.VfrQuestionDB.RegisterQuestion(None, None, QId,
> gFormPkg)
> + AObj.SetLineNo(ctx.F.line)
> + AObj.SetQuestionId(QId)
> + AObj.SetHelp(Help)
> + AObj.SetPrompt(Prompt)
> + AObj.SetFlagsStream(FlagsStream)
> + self.ErrorHandler(AObj.SetFlags(TextFlags), ctx.F.line)
> + if ctx.Key() != None:
> + AObj.SetHasKey(True)
> + Key = self.TransNum(ctx.S4.text)
> + self.AssignQuestionKey(AObj, Key)
> + ctx.Node.Data = AObj
> + ctx.Node.OpCode = EFI_IFR_TEXT_OP #
> + ctx.Node.Buffer = gFormPkg.StructToStream(AObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + else:
> + TObj = IfrText()
> + Line = ctx.start.line
> + TObj.SetLineNo(Line)
> + TObj.SetHelp(Help)
> + TObj.SetPrompt(Prompt)
> + if TxtTwo != EFI_STRING_ID_INVALID:
> + TObj.SetTextTwo(TxtTwo)
> + TObj.SetHasTextTwo(True)
> + ctx.Node.Data = TObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(TObj.GetInfo())
> +
> + 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 = IfrRef5()
> + R5Obj.SetLineNo(Line)
> + GObj = 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 = IfrRef4()
> + R4Obj.SetLineNo(Line)
> + R4Obj.SetDevicePath(DevPath)
> + R4Obj.SetFormId(FId)
> + R4Obj.SetQId(QId)
> + GObj = R4Obj
> +
> + elif ctx.FormSetGuid() != None:
> + RefType = 3
> + FId = self.TransNum(ctx.Number(0))
> + QId = self.TransNum(ctx.Number(1))
> + R3Obj = IfrRef3()
> + R3Obj.SetLineNo(Line)
> + R3Obj.SetFormId(FId)
> + R3Obj.SetQId(QId)
> + GObj = R3Obj
> +
> + elif ctx.Question() != None:
> + FId = self.TransNum(ctx.Number(0))
> + RefType = 2
> + if ctx.QN != None:
> + Name = ctx.QN.text
> + QId, BitMask, _ = self.VfrQuestionDB.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 = IfrRef2()
> + R2Obj.SetLineNo(Line)
> + R2Obj.SetFormId(FId)
> + R2Obj.SetQId(QId)
> + GObj = R2Obj
> +
> + elif ctx.N != None:
> + RefType = 1
> + FId = self.TransNum(ctx.Number(0))
> + RObj = IfrRef()
> + RObj.SetLineNo(Line)
> + RObj.SetFormId(FId)
> + GObj = RObj
> +
> + ctx.Node.Data = GObj
> +
> + self.visitChildren(ctx)
> +
> + if self.CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
> + self.CurrQestVarInfo.VarType == EFI_IFR_TYPE_REF
> +
> + if RefType == 4 or RefType == 3:
> + GObj.SetFormSetId(ctx.guidDefinition().Guid)
> +
> + if ctx.FLAGS() != None:
> + GObj.SetFlags(ctx.vfrGotoFlags().GotoFlags)
> +
> + if ctx.Key() != None:
> + index = int(len(ctx.Number())) - 1
> + Key = self.TransNum(ctx.Number(index))
> + self.AssignQuestionKey(GObj, Key)
> + GObj.SetHasKey(True)
> +
> + if ctx.vfrStatementQuestionOptionList() != None:
> + GObj.SetScope(1)
> + self.InsertEndNode(ctx.Node, ctx.E.line)
> + ctx.Node.Buffer = gFormPkg.StructToStream(GObj.GetInfo())
> + 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):
> + Defaultstore = ctx.N.text
> + RBObj = IfrResetButton(Defaultstore)
> + ctx.Node.Data = RBObj
> + self.visitChildren(ctx)
> + Line = ctx.start.line
> + RBObj.SetLineNo(Line)
> + DefaultId, ReturnCode = gVfrDefaultStore.GetDefaultId(Defaultstore)
> + self.ErrorHandler(ReturnCode, ctx.N.line)
> + RBObj.SetDefaultId(DefaultId)
> +
> + ctx.Node.Buffer = gFormPkg.StructToStream(RBObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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 = IfrInconsistentIf2()
> + self.visitChildren(ctx)
> +
> + IIObj.SetLineNo(ctx.start.line)
> + IIObj.SetError(self.TransNum(ctx.Number()))
> +
> + if ctx.FLAGS() != None:
> + Flags = ""
> + for i in range(0, len(ctx.flagsField())):
> + Flags += self.ExtractOriginalText(ctx.flagsField(i))
> + if i != len(ctx.flagsField()) - 1:
> + Flags += " | "
> + IIObj.SetFlagsStream(Flags)
> +
> + ctx.Node.Data = IIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(IIObj.GetInfo())
> + ctx.Node.Condition = (
> + "inconsistentif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrStatementNoSubmitIf.
> + def visitVfrStatementNoSubmitIf(self, ctx:
> VfrSyntaxParser.VfrStatementNoSubmitIfContext):
> + NSIObj = IfrNoSubmitIf()
> + self.visitChildren(ctx)
> +
> + NSIObj.SetLineNo(ctx.start.line)
> + NSIObj.SetError(self.TransNum(ctx.Number()))
> + if ctx.FLAGS() != None:
> + Flags = ""
> + for i in range(0, len(ctx.flagsField())):
> + Flags += self.ExtractOriginalText(ctx.flagsField(i))
> + if i != len(ctx.flagsField()) - 1:
> + Flags += " | "
> + NSIObj.SetFlagsStream(Flags)
> +
> + ctx.Node.Data = NSIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(NSIObj.GetInfo())
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementDisableIfQuest.
> + def visitVfrStatementDisableIfQuest(
> + self, ctx: VfrSyntaxParser.VfrStatementDisableIfQuestContext
> + ):
> + DIObj = IfrDisableIf()
> + self.visitChildren(ctx)
> +
> + DIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = DIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(DIObj.GetInfo())
> + ctx.Node.Condition = (
> + "disableif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRefresh.
> + def visitVfrStatementRefresh(self, ctx:
> VfrSyntaxParser.VfrStatementRefreshContext):
> + RObj = IfrRefresh()
> + self.visitChildren(ctx)
> +
> + RObj.SetLineNo(ctx.start.line)
> + RObj.SetRefreshInterval(self.TransNum(ctx.Number()))
> + ctx.Node.Data = RObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(RObj.GetInfo())
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementVarstoreDevice.
> + def visitVfrStatementVarstoreDevice(
> + self, ctx: VfrSyntaxParser.VfrStatementVarstoreDeviceContext
> + ):
> + VDObj = IfrVarStoreDevice()
> + self.visitChildren(ctx)
> +
> + VDObj.SetLineNo(ctx.start.line)
> + VDObj.SetDevicePath(self.TransNum(ctx.Number()))
> + ctx.Node.Data = VDObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(VDObj.GetInfo())
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementRefreshEvent.
> + def visitVfrStatementRefreshEvent(self, ctx:
> VfrSyntaxParser.VfrStatementRefreshEventContext):
> + RiObj = IfrRefreshId()
> + self.visitChildren(ctx)
> +
> + RiObj.SetLineNo(ctx.start.line)
> + RiObj.SetRefreshEventGroutId(ctx.guidDefinition().Guid)
> + ctx.Node.Data = RiObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(RiObj.GetInfo())
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrStatementWarningIf.
> + def visitVfrStatementWarningIf(self, ctx:
> VfrSyntaxParser.VfrStatementWarningIfContext):
> + WIObj = IfrWarningIf()
> + self.visitChildren(ctx)
> +
> + WIObj.SetLineNo(ctx.start.line)
> + WIObj.SetWarning(self.TransNum(ctx.Number(0)))
> + if ctx.Timeout() != None:
> + WIObj.SetTimeOut(self.TransNum(ctx.Number(1)))
> + WIObj.SetHasHasTimeOut(True)
> + ctx.Node.Data = WIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(WIObj.GetInfo())
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + 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 = IfrSuppressIf()
> + SIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = SIObj
> + ctx.Node.Condition = (
> + "suppressif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + ctx.Node.Buffer = gFormPkg.StructToStream(SIObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementGrayOutIfQuest.
> + def visitVfrStatementGrayOutIfQuest(
> + self, ctx: VfrSyntaxParser.VfrStatementGrayOutIfQuestContext
> + ):
> + GOIObj = IfrGrayOutIf()
> + GOIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = GOIObj
> + ctx.Node.Condition = (
> + "grayoutif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + ctx.Node.Buffer = gFormPkg.StructToStream(GOIObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#flagsField.
> + def visitFlagsField(self, ctx: VfrSyntaxParser.FlagsFieldContext):
> + if ctx.N != None:
> + VfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, ctx.N.line, ctx.N.text
> + )
> + if ctx.L != None:
> + VfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, 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:
> + ValueList = ctx.vfrConstantValueField().ValueList
> + Value = ValueList[0]
> + Type = self.CurrQestVarInfo.VarType
> +
> + if self.CurrentMinMaxData != None and
> self.CurrentMinMaxData.IsNumericOpcode():
> + # check default value is valid for Numeric Opcode
> + for i in range(0, len(ValueList)):
> + Value = ValueList[i]
> + if type(Value) == int:
> + if (
> + Value < self.CurrentMinMaxData.GetMinData()
> + or Value > self.CurrentMinMaxData.GetMaxData()
> + ):
> + 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."
> + )
> + for i in range(0, len(ValueList)):
> + if type(ValueList[i]) == int:
> + if Type == EFI_IFR_TYPE_TIME:
> + ValueList[i] = EFI_HII_TIME()
> +
> + if Type == EFI_IFR_TYPE_DATE:
> + ValueList[i] = EFI_HII_DATE()
> +
> + if Type == EFI_IFR_TYPE_REF:
> + ValueList[i] = EFI_HII_REF()
> + DObj = IfrDefault(Type, ValueList)
> + DObj.SetLineNo(Line)
> +
> DObj.SetValueStream(self.ExtractOriginalText(ctx.vfrConstantValueField()))
> + if not ctx.vfrConstantValueField().ListType:
> + 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.SetType(EFI_IFR_TYPE_BUFFER)
> +
> + else:
> + IsExp = True
> + DObj = IfrDefault2()
> + DObj.SetLineNo(Line)
> + DObj.SetScope(1)
> + self.InsertChild(ctx.Node, ctx.vfrStatementValue())
> + self.InsertEndNode(ctx.Node, Line)
> +
> + if ctx.DefaultStore() != None:
> + DefaultId, ReturnCode = gVfrDefaultStore.GetDefaultId(ctx.SN.text)
> + self.ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
> + DObj.SetDefaultId(DefaultId)
> + DObj.SetDefaultStore(ctx.SN.text)
> +
> + self.CheckDuplicateDefaultValue(DefaultId, ctx.D.line, ctx.D.text)
> + if self.CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
> + VarStoreName, ReturnCode = gVfrDataStorage.GetVarStoreName(
> + self.CurrQestVarInfo.VarStoreId
> + )
> + self.ErrorHandler(ReturnCode, Line)
> + VarGuid =
> gVfrDataStorage.GetVarStoreGuid(self.CurrQestVarInfo.VarStoreId)
> + VarStoreType =
> gVfrDataStorage.GetVarStoreType(self.CurrQestVarInfo.VarStoreId)
> + if (IsExp == False) and (VarStoreType ==
> EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER):
> + self.ErrorHandler(
> + gVfrDefaultStore.BufferVarStoreAltConfigAdd(
> + DefaultId,
> + self.CurrQestVarInfo,
> + VarStoreName,
> + VarGuid,
> + self.CurrQestVarInfo.VarType,
> + Value,
> + ),
> + Line,
> + )
> + ctx.Node.Data = DObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(DObj.GetInfo())
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrStatementValue.
> + def visitVfrStatementValue(self, ctx:
> VfrSyntaxParser.VfrStatementValueContext):
> + VObj = IfrValue()
> + self.visitChildren(ctx)
> +
> + VObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = VObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(VObj.GetInfo())
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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)
> +
> + ValueList = ctx.vfrConstantValueField().ValueList
> + Value = ValueList[0]
> + Type = self.CurrQestVarInfo.VarType
> + if self.CurrentMinMaxData != None:
> + # set min/max value for oneof opcode
> + Step = self.CurrentMinMaxData.GetStepData()
> + self.CurrentMinMaxData.SetMinMaxStepData(Value, Value, Step)
> +
> + if self.CurrQestVarInfo.IsBitVar:
> + Type = EFI_IFR_TYPE_NUM_SIZE_32
> + OOOObj = IfrOneOfOption(Type, ValueList)
> +
> + if not ctx.vfrConstantValueField().ListType:
> + OOOObj.SetType(Type)
> + else:
> + OOOObj.SetType(EFI_IFR_TYPE_BUFFER)
> +
> + OOOObj.SetLineNo(Line)
> + OOOObj.SetOption(self.TransNum(ctx.Number(0)))
> +
> OOOObj.SetValueStream(self.ExtractOriginalText(ctx.vfrConstantValueField()))
> +
> OOOObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrOneOfOptionFlags()))
> + 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 = gVfrDataStorage.GetVarStoreName(
> + self.CurrQestVarInfo.VarStoreId
> + )
> + self.ErrorHandler(ReturnCode, Line)
> + VarStoreGuid =
> gVfrDataStorage.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(
> + gVfrDefaultStore.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(
> + gVfrDefaultStore.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
> + OOOObj.SetIfrOptionKey(self.TransNum(ctx.KN.text))
> + gIfrOptionKey = IfrOptionKey(
> + self.CurrentQuestion.GetQuestionId(), Type, Value,
> self.TransNum(ctx.KN.text)
> + )
> + Node = IfrTreeNode(
> + EFI_IFR_GUID_OP, gIfrOptionKey,
> gFormPkg.StructToStream(gIfrOptionKey.GetInfo())
> + )
> + gIfrOptionKey.SetLineNo()
> + ctx.Node.insertChild(Node)
> +
> + for Ctx in ctx.vfrImageTag():
> + OOOObj.SetScope(1)
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.T.line)
> +
> + ctx.Node.Data = OOOObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(OOOObj.GetInfo())
> +
> + 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:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, ctx.A.line, ctx.A.text
> + )
> + if ctx.LateCheckFlag() != None:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCO
> DE, 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 = IfrRead()
> + self.visitChildren(ctx)
> +
> + RObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = RObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(RObj.GetInfo())
> + 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 = IfrWrite()
> + self.visitChildren(ctx)
> +
> + WObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = WObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(WObj.GetInfo())
> + 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:
> + if self.CurrQestVarInfo.IsBitVar:
> + ctx.Node = ctx.vfrStatementCheckBox().GuidNode
> + else:
> + 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 = IfrCheckBox()
> + ctx.Node.Data = CBObj
> + Line = ctx.start.line
> + CBObj.SetLineNo(Line)
> + self.CurrentQuestion = CBObj
> + 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 = IfrGuid(0)
> + GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
> + GuidObj.SetLineNo(Line)
> + GuidObj.SetScope(1)
> + ctx.GuidNode.Data = GuidObj
> + ctx.GuidNode.Buffer = gFormPkg.StructToStream(GuidObj.GetInfo())
> + ctx.GuidNode.insertChild(ctx.Node)
> + self.InsertEndNode(ctx.GuidNode, ctx.stop.line)
> +
> + # 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 = gVfrVarDataTypeDB.GetDataTypeSizeByDataType(
> + self.CurrQestVarInfo.VarType
> + )
> + self.ErrorHandler(ReturnCode, Line, "CheckBox varid is not the valid
> data type")
> + if (
> +
> gVfrDataStorage.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 =
> gVfrVarDataTypeDB.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 gVfrDataStorage.GetVarStoreType(
> + self.CurrQestVarInfo.VarStoreId
> + ) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER and
> self.CurrQestVarInfo.VarTotalSize != sizeof(
> + c_bool
> + ):
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + Line,
> + "CheckBox varid only support BOOLEAN data type",
> + )
> +
> + if ctx.FLAGS() != None:
> +
> CBObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrCheckBoxFlags()))
> + CBObj.SetFlags(ctx.vfrCheckBoxFlags().HFlags,
> ctx.vfrCheckBoxFlags().LFlags)
> + if self.CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
> + VarStoreName, ReturnCode = gVfrDataStorage.GetVarStoreName(
> + self.CurrQestVarInfo.VarStoreId
> + )
> + self.CompareErrorHandler(
> + ReturnCode,
> + VfrReturnCode.VFR_RETURN_SUCCESS,
> + Line,
> + ctx.L.text,
> + "Failed to retrieve varstore name",
> + )
> +
> + VarStoreGuid =
> gVfrDataStorage.GetVarStoreGuid(self.CurrQestVarInfo.VarStoreId)
> + self.Value = True
> + if CBObj.GetFlags() & 0x01:
> + self.CheckDuplicateDefaultValue(
> + EFI_HII_DEFAULT_CLASS_STANDARD, ctx.F.line, ctx.F.text
> + )
> + ReturnCode = gVfrDefaultStore.BufferVarStoreAltConfigAdd(
> + EFI_HII_DEFAULT_CLASS_STANDARD,
> + self.CurrQestVarInfo,
> + VarStoreName,
> + VarStoreGuid,
> + self.CurrQestVarInfo.VarType,
> + self.Value,
> + )
> + 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 = gVfrDefaultStore.BufferVarStoreAltConfigAdd(
> + EFI_HII_DEFAULT_CLASS_MANUFACTURING,
> + self.CurrQestVarInfo,
> + VarStoreName,
> + VarStoreGuid,
> + self.CurrQestVarInfo.VarType,
> + self.Value,
> + )
> + 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.Buffer = gFormPkg.StructToStream(CBObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + 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):
> + AObj = IfrAction()
> + ctx.Node.Data = AObj
> + self.visitChildren(ctx)
> + AObj.SetLineNo(ctx.start.line)
> + AObj.SetQuestionConfig(self.TransNum(ctx.Number()))
> + if ctx.FLAGS() != None:
> + AObj.SetFlags(ctx.vfrActionFlags().HFlags)
> + ctx.Node.Buffer = gFormPkg.StructToStream(AObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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:
> + if self.CurrQestVarInfo.IsBitVar:
> + ctx.Node = ctx.vfrStatementNumeric().GuidNode
> + else:
> + ctx.Node = ctx.vfrStatementNumeric().Node
> + elif ctx.vfrStatementOneOf() != None:
> + if self.CurrQestVarInfo.IsBitVar:
> + ctx.Node = ctx.vfrStatementOneOf().GuidNode
> + else:
> + 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.Node.Data
> +
> + NObj.SetLineNo(ctx.start.line)
> + Line = ctx.start.line
> + UpdateVarType = False
> +
> + # Create a GUID opcode to wrap the numeric opcode, if it refer to bit
> varstore.
> + if self.CurrQestVarInfo.IsBitVar:
> + GuidObj = IfrGuid(0)
> + GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
> + GuidObj.SetLineNo(Line)
> + GuidObj.SetScope(1) # pos
> + ctx.GuidNode.Data = GuidObj
> + ctx.GuidNode.Buffer = gFormPkg.StructToStream(GuidObj.GetInfo())
> + ctx.GuidNode.insertChild(ctx.Node)
> + self.InsertEndNode(ctx.GuidNode, ctx.stop.line)
> +
> + # 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.GetQFlags(),
> LFlags), Line)
> + else:
> + DataTypeSize, ReturnCode =
> gVfrVarDataTypeDB.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.GetQFlags(), self.CurrQestVarInfo.VarType),
> Line
> + )
> +
> + if ctx.FLAGS() != None:
> + UpdateVarType = ctx.vfrNumericFlags().UpdateVarType
> + 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,
> + )
> + NObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrNumericFlags()))
> +
> + if ctx.Key() != None:
> + Key = self.TransNum(ctx.Number())
> + self.AssignQuestionKey(NObj, Key)
> + NObj.SetHasKey(True)
> +
> + NObj.SetHasStep(ctx.vfrSetMinMaxStep().Step() != None)
> +
> + if (self.CurrQestVarInfo.IsBitVar == False) and (
> + self.CurrQestVarInfo.VarType not in BasicTypes
> + ):
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + Line,
> + "Numeric question only support UINT8, UINT16, UINT32 and
> UINT64 data type.",
> + )
> +
> + # modify the data for namevalue
> + if self.CurrQestVarInfo.VarType != EFI_IFR_TYPE_NUM_SIZE_64:
> + if self.CurrQestVarInfo.IsBitVar:
> + UpdatedNObj = IfrNumeric(EFI_IFR_TYPE_NUM_SIZE_32)
> + else:
> + UpdatedNObj = IfrNumeric(self.CurrQestVarInfo.VarType)
> + UpdatedNObj.QName = NObj.QName
> + UpdatedNObj.VarIdStr = NObj.VarIdStr
> + UpdatedNObj.HasQuestionId = NObj.HasQuestionId
> + UpdatedNObj.FlagsStream = NObj.FlagsStream
> + UpdatedNObj.HasKey = NObj.HasKey
> + UpdatedNObj.HasStep = NObj.HasStep
> + UpdatedNObj.LineNo = NObj.LineNo
> + UpdatedNObj.GetInfo().Question = NObj.GetInfo().Question
> + UpdatedNObj.GetInfo().Flags = NObj.GetInfo().Flags
> + UpdatedNObj.GetInfo().Data.MinValue =
> NObj.GetInfo().Data.MinValue
> + UpdatedNObj.GetInfo().Data.MaxValue =
> NObj.GetInfo().Data.MaxValue
> + UpdatedNObj.GetInfo().Data.Step = NObj.GetInfo().Data.Step
> + NObj = UpdatedNObj
> +
> + ctx.Node.Data = NObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(NObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + self.CurrentMinMaxData = None
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrSetMinMaxStep.
> + def visitVfrSetMinMaxStep(self, ctx:
> VfrSyntaxParser.VfrSetMinMaxStepContext):
> + IntDecStyle = False
> + OpObj = ctx.Node.Data
> + if (
> + (self.CurrQestVarInfo.IsBitVar)
> + and (OpObj.GetOpCode() == EFI_IFR_NUMERIC_OP)
> + and ((OpObj.GetNumericFlags() & EDKII_IFR_DISPLAY_BIT) == 0)
> + ) or (
> + (self.CurrQestVarInfo.IsBitVar == False)
> + and (OpObj.GetOpCode() == EFI_IFR_NUMERIC_OP)
> + and ((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",
> + )
> +
> + OpObj.SetMinMaxStepData(Min, Max, Step)
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrNumericFlags.
> + def visitVfrNumericFlags(self, ctx:
> VfrSyntaxParser.VfrNumericFlagsContext):
> + # check data type flag
> + ctx.LFlags = self.CurrQestVarInfo.VarType & EFI_IFR_NUMERIC_SIZE
> + VarStoreType =
> gVfrDataStorage.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.DisPlayUIntDec() != 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
> +
> + VarType = self.CurrQestVarInfo.VarType
> + 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, _ = gVfrVarDataTypeDB.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
> +
> + if VarType != self.CurrQestVarInfo.VarType:
> + ctx.UpdateVarType = True
> +
> + 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.DisPlayUIntDec() != 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):
> + self.visitChildren(ctx)
> + UpdateVarType = False
> + OObj = ctx.Node.Data
> + Line = ctx.start.line
> + if self.CurrQestVarInfo.IsBitVar:
> + GuidObj = IfrGuid(0)
> + GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
> + GuidObj.SetLineNo(ctx.start.line)
> + GuidObj.SetScope(1) # pos
> + ctx.GuidNode.Data = GuidObj
> + ctx.GuidNode.Buffer = gFormPkg.StructToStream(GuidObj.GetInfo())
> + ctx.GuidNode.insertChild(ctx.Node)
> + self.InsertEndNode(ctx.GuidNode, ctx.stop.line)
> +
> + # 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.GetQFlags(),
> LFlags), Line)
> + else:
> + DataTypeSize, ReturnCode =
> gVfrVarDataTypeDB.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.GetQFlags(), self.CurrQestVarInfo.VarType),
> Line
> + )
> + if ctx.FLAGS() != None:
> + UpdateVarType = ctx.vfrOneofFlagsField().UpdateVarType
> + 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,
> + )
> +
> + if (self.CurrQestVarInfo.IsBitVar == False) and (
> + self.CurrQestVarInfo.VarType not in BasicTypes
> + ):
> + self.ErrorHandler(
> + VfrReturnCode.VFR_RETURN_INVALID_PARAMETER,
> + Line,
> + "OneOf question only support UINT8, UINT16, UINT32 and UINT64
> data type.",
> + )
> +
> + # modify the data Vartype for NameValue
> + if self.CurrQestVarInfo.VarType != EFI_IFR_TYPE_NUM_SIZE_64:
> + if self.CurrQestVarInfo.IsBitVar:
> + UpdatedOObj = IfrOneOf(EFI_IFR_TYPE_NUM_SIZE_32)
> + else:
> + UpdatedOObj = IfrOneOf(self.CurrQestVarInfo.VarType)
> + UpdatedOObj.QName = OObj.QName
> + UpdatedOObj.VarIdStr = OObj.VarIdStr
> + UpdatedOObj.HasQuestionId = OObj.HasQuestionId
> + UpdatedOObj.GetInfo().Question = OObj.GetInfo().Question
> + UpdatedOObj.GetInfo().Flags = OObj.GetInfo().Flags
> + UpdatedOObj.GetInfo().Data.MinValue =
> OObj.GetInfo().Data.MinValue
> + UpdatedOObj.GetInfo().Data.MaxValue =
> OObj.GetInfo().Data.MaxValue
> + UpdatedOObj.GetInfo().Data.Step = OObj.GetInfo().Data.Step
> + OObj = UpdatedOObj
> +
> + OObj.SetLineNo(ctx.start.line)
> + if ctx.FLAGS() != None:
> +
> OObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrOneofFlagsField()))
> +
> + if ctx.vfrSetMinMaxStep() != None:
> + OObj.SetHasMinMax(True)
> + if ctx.vfrSetMinMaxStep().Step() != None:
> + OObj.SetHasStep(True)
> +
> + ctx.Node.Data = OObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(OObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + self.CurrentMinMaxData = None
> +
> + 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 =
> gVfrDataStorage.GetVarStoreType(self.CurrQestVarInfo.VarStoreId)
> + Line = ctx.start.line
> + IsSetType = False
> + self.visitChildren(ctx)
> +
> + for FlagsFieldCtx in ctx.numericFlagsField():
> + ctx.HFlags |= FlagsFieldCtx.HFlag
> + 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.DisPlayUIntDec() != 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
> +
> + VarType = self.CurrQestVarInfo.VarType
> + 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, _ = gVfrVarDataTypeDB.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
> +
> + if VarType != self.CurrQestVarInfo.VarType:
> + ctx.UpdateVarType = True
> +
> + 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
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrStatementString.
> + def visitVfrStatementString(self, ctx:
> VfrSyntaxParser.VfrStatementStringContext):
> + self.IsStringOp = True
> + SObj = IfrString()
> + ctx.Node.Data = SObj
> + SObj.SetLineNo(ctx.start.line)
> + self.CurrentQuestion = SObj
> +
> + self.visitChildren(ctx)
> +
> + if ctx.FLAGS() != None:
> + HFlags = ctx.vfrStringFlagsField().HFlags
> + LFlags = ctx.vfrStringFlagsField().LFlags
> + self.ErrorHandler(SObj.SetFlags(HFlags, LFlags), ctx.F.line)
> + SObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrStringFlagsField()))
> +
> + if ctx.Key() != None:
> + Key = self.TransNum(ctx.Number(0))
> + self.AssignQuestionKey(SObj, Key)
> + SObj.SetHasKey(True)
> + 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.GetCurArraySize()
> + 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.Buffer = gFormPkg.StructToStream(SObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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 = IfrPassword()
> + ctx.Node.Data = PObj
> + PObj.SetLineNo(ctx.start.line)
> + self.CurrentQuestion = PObj
> +
> + 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))
> + PObj.SetHasKey(True)
> + 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)
> +
> PObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrPasswordFlagsField()))
> +
> + VarArraySize = self.GetCurArraySize()
> + 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.Buffer = gFormPkg.StructToStream(PObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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 = IfrOrderedList()
> + ctx.Node.Data = OLObj
> + OLObj.SetLineNo(ctx.start.line)
> + self.CurrentQuestion = OLObj
> + self.IsOrderedList = True
> +
> + self.visitChildren(ctx)
> +
> + VarArraySize = self.GetCurArraySize()
> + 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)
> + OLObj.SetHasMaxContainers(True)
> +
> + if ctx.FLAGS() != None:
> + HFlags = ctx.vfrOrderedListFlags().HFlags
> + LFlags = ctx.vfrOrderedListFlags().LFlags
> + self.ErrorHandler(OLObj.SetFlags(HFlags, LFlags), ctx.F.line)
> +
> OLObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrOrderedListFlags()))
> +
> + ctx.Node.Buffer = gFormPkg.StructToStream(OLObj.GetInfo())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + 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 = IfrDate()
> + ctx.Node.Data = DObj
> + Line = ctx.start.line
> + DObj.SetLineNo(Line)
> + self.Value = ctx.Val
> + 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:
> + DObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrDateFlags()))
> + 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))
> +
> + DObj.Year = Year
> +
> + Month = self.TransId(ctx.StringIdentifier(2))
> + Month += "."
> + Month += self.TransId(ctx.StringIdentifier(3))
> +
> + DObj.Month = Month
> +
> + Day = self.TransId(ctx.StringIdentifier(4))
> + Day += "."
> + Day += self.TransId(ctx.StringIdentifier(5))
> +
> + DObj.Day = Day
> +
> + if ctx.FLAGS() != None:
> + DObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrDateFlags()))
> + self.ErrorHandler(
> + DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT,
> ctx.vfrDateFlags().LFlags),
> + ctx.F2.line,
> + )
> +
> + QId, _ = self.VfrQuestionDB.RegisterOldDateQuestion(
> + Year, Month, Day, EFI_QUESTION_ID_INVALID, gFormPkg
> + )
> + 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)))
> +
> + DefaultObj = IfrDefault(
> + EFI_IFR_TYPE_DATE, [ctx.Val], EFI_HII_DEFAULT_CLASS_STANDARD,
> EFI_IFR_TYPE_DATE
> + )
> + DefaultObj.SetLineNo(Line)
> + DefaultNode = IfrTreeNode(
> + EFI_IFR_DEFAULT_OP, DefaultObj,
> gFormPkg.StructToStream(DefaultObj.GetInfo())
> + )
> + ctx.Node.insertChild(DefaultNode)
> +
> + ctx.Node.Buffer = gFormPkg.StructToStream(DObj.GetInfo())
> + for Ctx in ctx.vfrStatementInconsistentIf():
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#minMaxDateStepDefault.
> + def visitMinMaxDateStepDefault(self, ctx:
> VfrSyntaxParser.MinMaxDateStepDefaultContext):
> + Minimum = self.TransNum(ctx.Number(0))
> + ctx.Node.Data.Min = Minimum
> + Maximum = self.TransNum(ctx.Number(1))
> + ctx.Node.Data.Max = Maximum
> + if ctx.Step() != None:
> + ctx.Node.Data.Step = self.TransNum(ctx.Number(2))
> + if ctx.Default() != None:
> + if ctx.KeyValue == 0:
> + ctx.Date.Year = self.TransNum(ctx.N.text)
> + ctx.Node.Data.D_Year = ctx.Date.Year
> + 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)
> + ctx.Node.Data.D_Month = ctx.Date.Month
> + 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)
> + ctx.Node.Data.D_Day = ctx.Date.Day
> + 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 = IfrTime()
> + ctx.Node.Data = TObj
> + Line = ctx.start.line
> + TObj.SetLineNo(Line)
> + self.Value = ctx.Val
> + 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:
> + TObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrTimeFlags()))
> + 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))
> +
> + TObj.SetHour(Hour)
> +
> + Minute = self.TransId(ctx.StringIdentifier(2))
> + Minute += "."
> + Minute += self.TransId(ctx.StringIdentifier(3))
> +
> + TObj.SetMinute(Minute)
> +
> + Second = self.TransId(ctx.StringIdentifier(4))
> + Second += "."
> + Second += self.TransId(ctx.StringIdentifier(5))
> +
> + TObj.SetSecond(Second)
> +
> + if ctx.FLAGS() != None:
> + TObj.SetFlagsStream(self.ExtractOriginalText(ctx.vfrTimeFlags()))
> + self.ErrorHandler(
> + TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT,
> ctx.vfrTimeFlags().LFlags),
> + ctx.F2.line,
> + )
> +
> + QId, _ = self.VfrQuestionDB.RegisterOldTimeQuestion(
> + Hour, Minute, Second, EFI_QUESTION_ID_INVALID, gFormPkg
> + )
> + 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)))
> +
> + DefaultObj = IfrDefault(
> + EFI_IFR_TYPE_TIME, [ctx.Val], EFI_HII_DEFAULT_CLASS_STANDARD,
> EFI_IFR_TYPE_TIME
> + )
> + DefaultObj.SetLineNo(Line)
> + DefaultNode = IfrTreeNode(
> + EFI_IFR_DEFAULT_OP, DefaultObj,
> gFormPkg.StructToStream(DefaultObj.GetInfo())
> + )
> + ctx.Node.insertChild(DefaultNode)
> +
> + ctx.Node.Buffer = gFormPkg.StructToStream(TObj.GetInfo())
> + for Ctx in ctx.vfrStatementInconsistentIf():
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#minMaxTimeStepDefault.
> + def visitMinMaxTimeStepDefault(self, ctx:
> VfrSyntaxParser.MinMaxTimeStepDefaultContext):
> + ctx.Node.Data.Min = self.TransNum(ctx.Number(0))
> + ctx.Node.Data.Max = self.TransNum(ctx.Number(1))
> + if ctx.Step() != None:
> + ctx.Node.Data.Step = self.TransNum(ctx.Number(2))
> + if ctx.Default() != None:
> + if ctx.KeyValue == 0:
> + ctx.Time.Hour = self.TransNum(ctx.Number(len(ctx.Number()) - 1))
> + ctx.Node.Data.D_Hour = ctx.Time.Hour
> + 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))
> + ctx.Node.Data.D_Minute = ctx.Time.Minute
> + 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))
> + ctx.Node.Data.D_Second = ctx.Time.Second
> + 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 = IfrDisableIf()
> + DIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = DIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(DIObj.GetInfo())
> + ctx.Node.Condition = (
> + "disableif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + for Ctx in ctx.vfrStatementStatList():
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementSuppressIfStatNew.
> + def visitVfrStatementSuppressIfStatNew(
> + self, ctx: VfrSyntaxParser.VfrStatementSuppressIfStatNewContext
> + ):
> + SIObj = IfrSuppressIf()
> + SIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = SIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(SIObj.GetInfo())
> + ctx.Node.Condition = (
> + "suppressif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + for Ctx in ctx.vfrStatementStatList():
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementGrayOutIfStatNew.
> + def visitVfrStatementGrayOutIfStatNew(
> + self, ctx: VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext
> + ):
> + GOIObj = IfrGrayOutIf()
> + GOIObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = GOIObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(GOIObj.GetInfo())
> + ctx.Node.Condition = (
> + "grayoutif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.visitChildren(ctx)
> + for Ctx in ctx.vfrStatementStatList():
> + self.InsertChild(ctx.Node, Ctx)
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatementInconsistentIfStat.
> + def visitVfrStatementInconsistentIfStat(
> + self, ctx: VfrSyntaxParser.VfrStatementInconsistentIfStatContext
> + ):
> + IIObj = IfrInconsistentIf()
> + 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.Buffer = gFormPkg.StructToStream(IIObj.GetInfo())
> + ctx.Node.Condition = (
> + "inconsistentif" + " " +
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + )
> + ctx.Node.Expression =
> self.ExtractOriginalText(ctx.vfrStatementExpression())
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> +
> + 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 = IfrLabel()
> + self.visitChildren(ctx)
> + LObj.SetLineNo(ctx.start.line)
> + LObj.SetNumber(self.TransNum(ctx.Number()))
> + ctx.Node.Data = LObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(LObj.GetInfo())
> + return ctx.Node
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrStatemex.BObjntBanner.
> + def visitVfrStatementBanner(self, ctx:
> VfrSyntaxParser.VfrStatementBannerContext):
> + self.visitChildren(ctx)
> + BObj = IfrBanner()
> + BObj.SetLineNo(ctx.start.line)
> + BObj.SetTitle(self.TransNum(ctx.Number(0)))
> +
> + if ctx.Line() != None:
> + BObj.SetLine(self.TransNum(ctx.Number(1)))
> + if ctx.Left() != None:
> + ctx.Node.Dict["align"] = KV("left", 0)
> + BObj.SetAlign(0)
> + if ctx.Center() != None:
> + ctx.Node.Dict["align"] = KV("center", 1)
> + BObj.SetAlign(1)
> + if ctx.Right() != None:
> + ctx.Node.Dict["align"] = KV("right", 2)
> + BObj.SetAlign(2)
> +
> + ctx.Node.Data = BObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(BObj.GetInfo())
> +
> + if ctx.Timeout() != None:
> + TObj = IfrTimeout()
> + TObj.SetLineNo(ctx.start.line)
> + TObj.SetTimeout(self.TransNum(ctx.Number(2)))
> + Node = IfrTreeNode(EFI_IFR_GUID_OP, TObj,
> gFormPkg.StructToStream(TObj.GetInfo()))
> + ctx.Node.insertChild(Node)
> + BObj.SetHasTimeOut(True)
> + BObj.SetTimeOut(self.TransNum(ctx.Number(2)))
> +
> + 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 =
> gVfrVarDataTypeDB.GetDataTypeSizeByTypeName(ctx.TypeName)
> + self.ErrorHandler(ReturnCode, ctx.D.line)
> + ctx.Size = ctx.TypeSize * ctx.ArrayNum if ctx.ArrayNum > 0 else
> ctx.TypeSize
> + ctx.Buffer = bytearray(ctx.Size)
> +
> + self.visitChildren(ctx)
> + Line = ctx.start.line
> + GuidObj = IfrExtensionGuid(ctx.Size, ctx.TypeName, ctx.ArrayNum)
> + for Ctx in ctx.vfrExtensionData():
> + GuidObj.SetFieldList(Ctx.FName, Ctx.TFValue)
> +
> + GuidObj.SetLineNo(Line)
> + GuidObj.SetGuid(ctx.guidDefinition().Guid)
> + if ctx.TypeName != "":
> + GuidObj.SetData(ctx.Buffer)
> + GuidObj.SetScope(1)
> + ctx.Node.Data = GuidObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(GuidObj.GetInfo())
> + if ctx.DataType() != None:
> + Buffer = bytearray(ctx.Size)
> + for i in range(0, len(Buffer)):
> + Buffer[i] = ctx.Buffer[i]
> + ctx.Node.Buffer += Buffer
> +
> + for Ctx in ctx.vfrStatementExtension():
> + self.InsertChild(ctx.Node, Ctx)
> +
> + self.InsertEndNode(ctx.Node, ctx.stop.line)
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrExtensionData.
> + def visitVfrExtensionData(self, ctx:
> VfrSyntaxParser.VfrExtensionDataContext):
> + IsArray = False if ctx.I == None else True
> + if IsArray:
> + Index = self.TransNum(ctx.I.text)
> + else:
> + Index = 0
> + IsStruct = ctx.parentCtx.IsStruct
> + self.visitChildren(ctx)
> + ctx.TFValue = self.TransNum(ctx.N.text)
> + Data = self.TransNum(ctx.N.text)
> + if IsArray:
> + ctx.FName += "data" + "[" + ctx.I.text + "]"
> + else:
> + ctx.FName += "data"
> + ctx.TFName = ctx.parentCtx.TypeName
> + if IsStruct:
> + ctx.TFName += ctx.parentCtx.TypeName
> + for i in range(0, len(ctx.arrayName())):
> + ctx.TFName += "."
> + ctx.TFName += ctx.arrayName(i).SubStrZ
> + ctx.FName += "."
> + ctx.FName += ctx.arrayName(i).SubStrZ
> +
> + Buffer = ctx.parentCtx.Buffer
> + FieldOffset, FieldType, FieldSize, BitField, _ =
> gVfrVarDataTypeDB.GetDataFieldInfo(
> + ctx.TFName
> + )
> + ByteOffset = ctx.parentCtx.TypeSize * Index
> + if not BitField:
> + Offset = ByteOffset + FieldOffset
> + Buffer[Offset : Offset + FieldSize] = ctx.TFValue.to_bytes(FieldSize,
> "little")
> + else:
> + Mask = (1 << FieldSize) - 1
> + Offset = FieldOffset // 8
> + PreBits = FieldOffset % 8
> + Mask <<= PreBits
> + Value = int.from_bytes(
> + Buffer[ByteOffset + Offset : ByteOffset + Offset + FieldSize], "little"
> + )
> + Data <<= PreBits
> + Value = (Value & (~Mask)) | Data
> + Buffer[ByteOffset + Offset : ByteOffset + Offset + FieldSize] =
> Value.to_bytes(
> + FieldSize, "little"
> + )
> +
> + return Buffer
> +
> + # 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 = IfrModal()
> + self.visitChildren(ctx)
> + MObj.SetLineNo(ctx.start.line)
> + ctx.Node.Data = MObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(MObj.GetInfo())
> +
> + return ctx.Node
> +
> + def SaveOpHdrCond(self, OpHdr, Cond, LineNo=0):
> + if Cond == True:
> + if self.IfrOpHdr[self.IfrOpHdrIndex] != None:
> + return
> + self.IfrOpHdr[self.IfrOpHdrIndex] = OpHdr
> + self.IfrOpHdrLineNo[self.IfrOpHdrIndex] = LineNo
> +
> + def InitOpHdrCond(self):
> + self.IfrOpHdr.append(None)
> + self.IfrOpHdrLineNo.append(0)
> +
> + def SetSavedOpHdrScope(self):
> + if self.IfrOpHdr[self.IfrOpHdrIndex] != None:
> + self.IfrOpHdr[self.IfrOpHdrIndex].Scope = 1
> + return True
> + return False
> +
> + def ClearSavedOPHdr(self):
> + self.IfrOpHdr[self.IfrOpHdrIndex] = 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.IfrOpHdrIndex += 1
> + if self.IfrOpHdrIndex >= 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)
> +
> + for i in range(0, len(ctx.andTerm())):
> + ctx.Nodes.extend(ctx.andTerm(i).Nodes)
> + if i != 0:
> + ctx.ExpInfo.ExpOpCount += 1
> + OObj = IfrOr(ctx.andTerm(i).Line)
> + Node = IfrTreeNode(EFI_IFR_OR_OP, OObj,
> gFormPkg.StructToStream(OObj.GetInfo()))
> + ctx.Nodes.append(Node)
> +
> + # Extend OpCode Scope only for the root expression.
> + if ctx.ExpInfo.ExpOpCount > 1 and ctx.ExpInfo.RootLevel == 0:
> + if self.SetSavedOpHdrScope():
> + EObj = IfrEnd()
> + if self.IfrOpHdrLineNo[self.IfrOpHdrIndex] != 0:
> + EObj.SetLineNo(self.IfrOpHdrLineNo[self.IfrOpHdrIndex])
> + else:
> + EObj.SetLineNo(ctx.stop.line)
> + Node = IfrTreeNode(EFI_IFR_END_OP, EObj,
> gFormPkg.StructToStream(EObj.GetInfo()))
> + ctx.Nodes.append(Node)
> +
> + if ctx.ExpInfo.RootLevel == 0:
> + self.ClearSavedOPHdr()
> + self.IfrOpHdrIndex = self.IfrOpHdrIndex - 1
> +
> + for Node in ctx.Nodes:
> + if ctx.ParentNode != None:
> + ctx.ParentNode.insertChild(Node)
> +
> + self.ConstantOnlyInExpression = False
> +
> + return ctx.Nodes
> +
> + # 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)
> +
> + for i in range(0, len(ctx.andTerm())):
> + ctx.Nodes.extend(ctx.andTerm(i).Nodes)
> + if i != 0:
> + ctx.ExpInfo.ExpOpCount += 1
> + OObj = IfrOr(ctx.andTerm(i).Line)
> + Node = IfrTreeNode(EFI_IFR_OR_OP, OObj,
> gFormPkg.StructToStream(OObj.GetInfo()))
> + ctx.Nodes.append(Node)
> +
> + ctx.ParentNodes.extend(ctx.Nodes) ######
> +
> + ctx.parentCtx.ExpInfo.ExpOpCount = ctx.ExpInfo.ExpOpCount
> ##########
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#andTerm.
> + def visitAndTerm(self, ctx: VfrSyntaxParser.AndTermContext):
> + ctx.Line = ctx.start.line
> + self.visitChildren(ctx)
> + for i in range(0, len(ctx.bitwiseorTerm())):
> + ctx.Nodes.extend(ctx.bitwiseorTerm(i).Nodes)
> + if i != 0:
> + ctx.ExpInfo.ExpOpCount += 1
> + AObj = IfrAnd(ctx.bitwiseorTerm(i).Line)
> + Node = IfrTreeNode(EFI_IFR_AND_OP, AObj,
> gFormPkg.StructToStream(AObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#bitwiseorTerm.
> + def visitBitwiseorTerm(self, ctx: VfrSyntaxParser.BitwiseorTermContext):
> + ctx.Line = ctx.start.line
> + self.visitChildren(ctx)
> + for i in range(0, len(ctx.bitwiseandTerm())):
> + ctx.Nodes.extend(ctx.bitwiseandTerm(i).Nodes)
> + if i != 0:
> + ctx.ExpInfo.ExpOpCount += 1
> + BWOObj = IfrBitWiseOr(ctx.bitwiseandTerm(i).Line)
> + Node = IfrTreeNode(
> + EFI_IFR_BITWISE_OR_OP, BWOObj,
> gFormPkg.StructToStream(BWOObj.GetInfo())
> + )
> + ctx.Nodes.append(Node)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#bitwiseandTerm.
> + def visitBitwiseandTerm(self, ctx:
> VfrSyntaxParser.BitwiseandTermContext):
> + ctx.Line = ctx.start.line
> + self.visitChildren(ctx)
> + for i in range(0, len(ctx.equalTerm())):
> + ctx.Nodes.extend(ctx.equalTerm(i).Nodes)
> + if i != 0:
> + ctx.ExpInfo.ExpOpCount += 1
> + BWAObj = IfrBitWiseAnd(ctx.equalTerm(i).Line)
> + Node = IfrTreeNode(
> + EFI_IFR_BITWISE_AND_OP, BWAObj,
> gFormPkg.StructToStream(BWAObj.GetInfo())
> + )
> + ctx.Nodes.append(Node)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#equalTerm.
> + def visitEqualTerm(self, ctx: VfrSyntaxParser.EqualTermContext):
> + ctx.Line = ctx.start.line
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.compareTerm().Nodes)
> +
> + for ChildCtx in ctx.equalTermSupplementary():
> + ctx.ExpInfo.ExpOpCount += 1
> + ctx.Nodes.extend(ChildCtx.Nodes)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#equalTermEqualRule.
> + def visitEqualTermEqualRule(self, ctx:
> VfrSyntaxParser.EqualTermEqualRuleContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.compareTerm().Nodes)
> + EObj = IfrEqual(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_EQUAL_OP, EObj,
> gFormPkg.StructToStream(EObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#equalTermNotEqualRule.
> + def visitEqualTermNotEqualRule(self, ctx:
> VfrSyntaxParser.EqualTermNotEqualRuleContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.compareTerm().Nodes)
> + NEObj = IfrNotEqual(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_NOT_EQUAL_OP, NEObj,
> gFormPkg.StructToStream(NEObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#compareTerm.
> + def visitCompareTerm(self, ctx: VfrSyntaxParser.CompareTermContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.shiftTerm().Nodes)
> +
> + for ChildCtx in ctx.compareTermSupplementary():
> + ctx.ExpInfo.ExpOpCount += 1
> + ctx.Nodes.extend(ChildCtx.Nodes)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#compareTermLessRule.
> + def visitCompareTermLessRule(self, ctx:
> VfrSyntaxParser.CompareTermLessRuleContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.shiftTerm().Nodes)
> + LTObj = IfrLessThan(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_LESS_THAN_OP, LTObj,
> gFormPkg.StructToStream(LTObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#compareTermLessEqualRule.
> + def visitCompareTermLessEqualRule(self, ctx:
> VfrSyntaxParser.CompareTermLessEqualRuleContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.shiftTerm().Nodes)
> + LEObj = IfrLessEqual(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_LESS_EQUAL_OP, LEObj,
> gFormPkg.StructToStream(LEObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#compareTermGreaterRule.
> + def visitCompareTermGreaterRule(self, ctx:
> VfrSyntaxParser.CompareTermGreaterRuleContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.shiftTerm().Nodes)
> + GTObj = IfrGreaterThan(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_GREATER_THAN_OP, GTObj,
> gFormPkg.StructToStream(GTObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#compareTermGreaterEqualRule.
> + def visitCompareTermGreaterEqualRule(
> + self, ctx: VfrSyntaxParser.CompareTermGreaterEqualRuleContext
> + ):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.shiftTerm().Nodes)
> + GEObj = IfrGreaterEqual(ctx.start.line)
> + Node = IfrTreeNode(
> + EFI_IFR_GREATER_EQUAL_OP, GEObj,
> gFormPkg.StructToStream(GEObj.GetInfo())
> + )
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#shiftTerm.
> + def visitShiftTerm(self, ctx: VfrSyntaxParser.ShiftTermContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.addMinusTerm().Nodes)
> +
> + for ChildCtx in ctx.shiftTermSupplementary():
> + ctx.ExpInfo.ExpOpCount += 1
> + ctx.Nodes.extend(ChildCtx.Nodes)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#shiftTermLeft.
> + def visitShiftTermLeft(self, ctx: VfrSyntaxParser.ShiftTermLeftContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.addMinusTerm().Nodes)
> + SLObj = IfrShiftLeft(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_SHIFT_LEFT_OP, SLObj,
> gFormPkg.StructToStream(SLObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#shiftTermRight.
> + def visitShiftTermRight(self, ctx: VfrSyntaxParser.ShiftTermRightContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.addMinusTerm().Nodes)
> + SRObj = IfrShiftRight(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_SHIFT_RIGHT_OP, SRObj,
> gFormPkg.StructToStream(SRObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#addMinusTerm.
> + def visitAddMinusTerm(self, ctx: VfrSyntaxParser.AddMinusTermContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.multdivmodTerm().Nodes)
> +
> + for ChildCtx in ctx.addMinusTermSupplementary():
> + ctx.ExpInfo.ExpOpCount += 1
> + ctx.Nodes.extend(ChildCtx.Nodes)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#addMinusTermpAdd.
> + def visitAddMinusTermpAdd(self, ctx:
> VfrSyntaxParser.AddMinusTermpAddContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.multdivmodTerm().Nodes)
> + AObj = IfrAdd(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_ADD_OP, AObj,
> gFormPkg.StructToStream(AObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#addMinusTermSubtract.
> + def visitAddMinusTermSubtract(self, ctx:
> VfrSyntaxParser.AddMinusTermSubtractContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.multdivmodTerm().Nodes)
> + SObj = IfrSubtract(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_SUBTRACT_OP, SObj,
> gFormPkg.StructToStream(SObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#multdivmodTerm.
> + def visitMultdivmodTerm(self, ctx:
> VfrSyntaxParser.MultdivmodTermContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.castTerm().Nodes)
> + for ChildCtx in ctx.multdivmodTermSupplementary():
> + ctx.ExpInfo.ExpOpCount += 1
> + ctx.Nodes.extend(ChildCtx.Nodes)
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermMul.
> + def visitMultdivmodTermMul(self, ctx:
> VfrSyntaxParser.MultdivmodTermMulContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.castTerm().Nodes)
> + MObj = IfrMultiply(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_MULTIPLY_OP, MObj,
> gFormPkg.StructToStream(MObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermDiv.
> + def visitMultdivmodTermDiv(self, ctx:
> VfrSyntaxParser.MultdivmodTermDivContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.castTerm().Nodes)
> + DObj = IfrDivide(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_DIVIDE_OP, DObj,
> gFormPkg.StructToStream(DObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermRound.
> + def visitMultdivmodTermModulo(self, ctx:
> VfrSyntaxParser.MultdivmodTermModuloContext):
> + self.visitChildren(ctx)
> + ctx.Nodes.extend(ctx.castTerm().Nodes)
> + MObj = IfrModulo(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_MODULO_OP, MObj,
> gFormPkg.StructToStream(MObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#castTerm.
> + def visitCastTerm(self, ctx: VfrSyntaxParser.CastTermContext):
> + self.visitChildren(ctx)
> + CastType = 0xFF
> + for ChildCtx in ctx.castTermSub():
> + CastType = ChildCtx.CastType
> +
> + ctx.Nodes.extend(ctx.atomTerm().Nodes)
> + if CastType == 0:
> + TBObj = IfrToBoolean(ctx.start.line)
> + Node = IfrTreeNode(
> + EFI_IFR_TO_BOOLEAN_OP, TBObj,
> gFormPkg.StructToStream(TBObj.GetInfo())
> + )
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + elif CastType == 1:
> + TUObj = IfrToUint(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_TO_UINT_OP, TUObj,
> gFormPkg.StructToStream(TUObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#castTermSub.
> + def visitCastTermSub(self, ctx: VfrSyntaxParser.CastTermSubContext):
> + self.visitChildren(ctx)
> + if ctx.Boolean() != None:
> + ctx.CastType = 0
> + elif ctx.Uint32() != None:
> + ctx.CastType = 1
> + elif ctx.Uint16() != None:
> + ctx.CastType = 1
> + elif ctx.Uint8() != None:
> + ctx.CastType = 1
> + return ctx.CastType
> +
> + # Visit a parse tree produced by VfrSyntaxParser#atomTerm.
> + def visitAtomTerm(self, ctx: VfrSyntaxParser.AtomTermContext):
> + self.visitChildren(ctx)
> + if ctx.vfrExpressionCatenate() != None:
> + ctx.Nodes = ctx.vfrExpressionCatenate().Nodes
> + if ctx.vfrExpressionMatch() != None:
> + ctx.Nodes = ctx.vfrExpressionMatch().Nodes
> + if ctx.vfrExpressionMatch2() != None:
> + ctx.Nodes = ctx.vfrExpressionMatch2().Nodes
> + if ctx.vfrExpressionParen() != None:
> + ctx.Nodes = ctx.vfrExpressionParen().Nodes
> + if ctx.vfrExpressionBuildInFunction() != None:
> + ctx.Nodes.append(ctx.vfrExpressionBuildInFunction().Node)
> + if ctx.vfrExpressionConstant() != None:
> + ctx.Nodes.append(ctx.vfrExpressionConstant().Node)
> + if ctx.vfrExpressionUnaryOp() != None:
> + ctx.Nodes = ctx.vfrExpressionUnaryOp().Nodes
> + if ctx.vfrExpressionTernaryOp() != None:
> + ctx.Nodes = ctx.vfrExpressionTernaryOp().Nodes
> + if ctx.vfrExpressionMap() != None:
> + ctx.Nodes = ctx.vfrExpressionMap().Nodes
> + if ctx.atomTerm() != None:
> + ctx.Nodes = ctx.atomTerm().Nodes
> + NObj = IfrNot(ctx.start.line)
> + Node = IfrTreeNode(EFI_IFR_NOT_OP, NObj,
> gFormPkg.StructToStream(NObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # 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
> + CObj = IfrCatenate(Line)
> + Node = IfrTreeNode(EFI_IFR_CATENATE_OP, CObj,
> gFormPkg.StructToStream(CObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Nodes
> +
> + # 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
> + MObj = IfrMatch(Line)
> + Node = IfrTreeNode(EFI_IFR_MATCH_OP, MObj,
> gFormPkg.StructToStream(MObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Nodes
> +
> + # 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
> + M2Obj = IfrMatch2(Line, Guid)
> + Node = IfrTreeNode(EFI_IFR_MATCH2_OP, M2Obj,
> gFormPkg.StructToStream(M2Obj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionParen.
> + def visitVfrExpressionParen(self, ctx:
> VfrSyntaxParser.VfrExpressionParenContext):
> + self.visitChildren(ctx)
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by
> VfrSyntaxParser#vfrExpressionBuildInFunction.
> + def visitVfrExpressionBuildInFunction(
> + self, ctx: VfrSyntaxParser.VfrExpressionBuildInFunctionContext
> + ):
> + self.visitChildren(ctx)
> + if ctx.dupExp() != None:
> + ctx.Node = ctx.dupExp().Node
> + if ctx.vareqvalExp() != None:
> + ctx.Node = ctx.vareqvalExp().Node
> + if ctx.ideqvalExp() != None:
> + ctx.Node = ctx.ideqvalExp().Node
> + if ctx.ideqidExp() != None:
> + ctx.Node = ctx.ideqidExp().Node
> + if ctx.ideqvallistExp() != None:
> + ctx.Node = ctx.ideqvallistExp().Node
> + if ctx.questionref1Exp() != None:
> + ctx.Node = ctx.questionref1Exp().Node
> + if ctx.rulerefExp() != None:
> + ctx.Node = ctx.rulerefExp().Node
> + if ctx.stringref1Exp() != None:
> + ctx.Node = ctx.stringref1Exp().Node
> + if ctx.pushthisExp() != None:
> + ctx.Node = ctx.pushthisExp().Node
> + if ctx.securityExp() != None:
> + ctx.Node = ctx.securityExp().Node
> + if ctx.getExp() != None:
> + ctx.Node = ctx.getExp().Node
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#dupExp.
> + def visitDupExp(self, ctx: VfrSyntaxParser.DupExpContext):
> + self.visitChildren(ctx)
> + Line = ctx.start.line
> + DObj = IfrDup(Line)
> + ctx.Node.Data = DObj
> + ctx.Node.Buffer = gFormPkg.StructToStream(DObj.GetInfo())
> + self.SaveOpHdrCond(DObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0),
> Line) #
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # 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 += ctx.VN.text
> + VarStoreId, ReturnCode = gVfrDataStorage.GetVarStoreId(VarIdStr)
> + if ReturnCode == VfrReturnCode.VFR_RETURN_UNDEFINED:
> + pass #########
> + else:
> + self.ErrorHandler(ReturnCode, ctx.VN.line)
> + QId, Mask, _ = self.VfrQuestionDB.GetQuestionId(None, VarIdStr)
> + ConstVal = self.TransNum(ctx.Number(1))
> + if ctx.Equal() != None:
> + if Mask == 0:
> + EIVObj = IfrEqIdVal(Line)
> + self.SaveOpHdrCond(EIVObj.GetHeader(), (ctx.ExpInfo.ExpOpCount
> == 0), Line)
> + EIVObj.SetQuestionId(QId, VarIdStr, ctx.VN.line)
> + EIVObj.SetValue(ConstVal)
> + ctx.Node = IfrTreeNode(EFI_IFR_EQ_ID_VAL_OP, EIVObj)
> + ctx.ExpInfo.ExpOpCount += 1
> + else:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.EQUAL
> + )
> + elif ctx.LessEqual() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.LESS_EQUAL
> + )
> +
> + elif ctx.Less() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.LESS_THAN
> + )
> +
> + elif ctx.GreaterEqual() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.GREATER_EQUAL
> + )
> +
> + elif ctx.Greater() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.GREATER_THAN
> + )
> +
> + return ctx.Node
> +
> + def ConvertIdExpr(self, ExpInfo, LineNo, QId, VarIdStr, BitMask):
> + QR1Obj = IfrQuestionRef1(LineNo)
> + QR1Obj.SetQuestionId(QId, VarIdStr, LineNo)
> + Node = IfrTreeNode(EFI_IFR_QUESTION_REF1_OP, QR1Obj)
> + self.SaveOpHdrCond(QR1Obj.GetHeader(), (ExpInfo.ExpOpCount == 0))
> + if BitMask != 0:
> + U32Obj = IfrUint32(LineNo)
> + U32Obj.SetValue(BitMask)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_UINT32_OP, U32Obj,
> gFormPkg.StructToStream(U32Obj.GetInfo()))
> + )
> +
> + BWAObj = IfrBitWiseAnd(LineNo)
> + Node.insertChild(
> + IfrTreeNode(
> + EFI_IFR_BITWISE_AND_OP, BWAObj,
> gFormPkg.StructToStream(BWAObj.GetInfo())
> + )
> + )
> +
> + U8Obj = IfrUint8(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)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_UINT8_OP, U8Obj,
> gFormPkg.StructToStream(U8Obj.GetInfo()))
> + )
> +
> + SRObj = IfrShiftRight(LineNo)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_SHIFT_RIGHT_OP, SRObj,
> gFormPkg.StructToStream(SRObj.GetInfo()))
> + )
> +
> + ExpInfo.ExpOpCount += 4
> + return Node
> +
> + def IdEqValDoSpecial(self, ExpInfo, LineNo, QId, VarIdStr, BitMask,
> ConstVal, CompareType):
> + Node = self.ConvertIdExpr(ExpInfo, LineNo, QId, VarIdStr, BitMask)
> + if ConstVal > 0xFF:
> + U16Obj = IfrUint16(LineNo)
> + U16Obj.SetValue(ConstVal)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_UINT16_OP, U16Obj,
> gFormPkg.StructToStream(U16Obj.GetInfo()))
> + )
> + else:
> + U8Obj = IfrUint8(LineNo)
> + U8Obj.SetValue(ConstVal)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_UINT8_OP, U8Obj,
> gFormPkg.StructToStream(U8Obj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.EQUAL:
> + EObj = IfrEqual(LineNo)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_EQUAL_OP, EObj,
> gFormPkg.StructToStream(EObj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.LESS_EQUAL:
> + LEObj = IfrLessEqual(LineNo)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_LESS_EQUAL_OP, LEObj,
> gFormPkg.StructToStream(LEObj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.LESS_THAN:
> + LTObj = IfrLessThan(LineNo)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_LESS_THAN_OP, LTObj,
> gFormPkg.StructToStream(LTObj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.GREATER_EQUAL:
> + GEObj = IfrGreaterEqual(LineNo)
> + Node.insertChild(
> + IfrTreeNode(
> + EFI_IFR_GREATER_EQUAL_OP, GEObj,
> gFormPkg.StructToStream(GEObj.GetInfo())
> + )
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.GREATER_THAN:
> + GTObj = IfrGreaterThan(LineNo)
> + Node.insertChild(
> + IfrTreeNode(
> + EFI_IFR_GREATER_THAN_OP, GTObj,
> gFormPkg.StructToStream(GTObj.GetInfo())
> + )
> + )
> +
> + ExpInfo.ExpOpCount += 2
> + return Node
> +
> + # 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 = IfrEqIdVal(Line)
> + self.SaveOpHdrCond(EIVObj.GetHeader(), (ctx.ExpInfo.ExpOpCount
> == 0), Line)
> + EIVObj.SetQuestionId(QId, VarIdStr, LineNo)
> + EIVObj.SetValue(ConstVal)
> + ctx.Node = IfrTreeNode(EFI_IFR_EQ_ID_VAL_OP, EIVObj)
> + ctx.ExpInfo.ExpOpCount += 1
> + else:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.EQUAL
> + )
> +
> + elif ctx.LessEqual() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.LESS_EQUAL
> + )
> +
> + elif ctx.Less() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.LESS_THAN
> + )
> +
> + elif ctx.GreaterEqual() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.GREATER_EQUAL
> + )
> +
> + elif ctx.Greater() != None:
> + ctx.Node = self.IdEqValDoSpecial(
> + ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal,
> EFI_COMPARE_TYPE.GREATER_THAN
> + )
> +
> + return ctx.Node
> +
> + def IdEqIdDoSpecial(
> + self, ExpInfo, LineNo, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2,
> CompareType
> + ):
> + Node1 = self.ConvertIdExpr(ExpInfo, LineNo, QId1, VarIdStr1, Mask1)
> + Node2 = self.ConvertIdExpr(ExpInfo, LineNo, QId2, VarIdStr2, Mask2)
> + Node1.insertChild(Node2)
> +
> + if CompareType == EFI_COMPARE_TYPE.EQUAL:
> + EObj = IfrEqual(LineNo)
> + Node1.insertChild(
> + IfrTreeNode(EFI_IFR_EQUAL_OP, EObj,
> gFormPkg.StructToStream(EObj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.LESS_EQUAL:
> + LEObj = IfrLessEqual(LineNo)
> + Node1.insertChild(
> + IfrTreeNode(EFI_IFR_LESS_EQUAL_OP, LEObj,
> gFormPkg.StructToStream(LEObj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.LESS_THAN:
> + LTObj = IfrLessThan(LineNo)
> + Node1.insertChild(
> + IfrTreeNode(EFI_IFR_LESS_THAN_OP, LTObj,
> gFormPkg.StructToStream(LTObj.GetInfo()))
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.GREATER_EQUAL:
> + GEObj = IfrGreaterEqual(LineNo)
> + Node1.insertChild(
> + IfrTreeNode(
> + EFI_IFR_GREATER_EQUAL_OP, GEObj,
> gFormPkg.StructToStream(GEObj.GetInfo())
> + )
> + )
> +
> + if CompareType == EFI_COMPARE_TYPE.GREATER_THAN:
> + GTObj = IfrGreaterThan(LineNo)
> + Node1.insertChild(
> + IfrTreeNode(
> + EFI_IFR_GREATER_THAN_OP, GTObj,
> gFormPkg.StructToStream(GTObj.GetInfo())
> + )
> + )
> +
> + ExpInfo.ExpOpCount += 1
> + return Node1
> +
> + # 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:
> + ctx.Node = self.IdEqIdDoSpecial(
> + ctx.ExpInfo,
> + Line,
> + QId1,
> + VarIdStr1,
> + Mask1,
> + QId2,
> + VarIdStr2,
> + Mask2,
> + EFI_COMPARE_TYPE.EQUAL,
> + )
> + else:
> + EIIObj = IfrEqIdId(Line)
> + self.SaveOpHdrCond(EIIObj.GetHeader(), (ctx.ExpInfo.ExpOpCount
> == 0), Line)
> + EIIObj.SetQuestionId1(QId1, VarIdStr1, LineNo1)
> + EIIObj.SetQuestionId2(QId2, VarIdStr2, LineNo2)
> + ctx.Node = IfrTreeNode(EFI_IFR_EQ_ID_ID_OP, EIIObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + elif ctx.LessEqual() != None:
> + ctx.Node = self.IdEqIdDoSpecial(
> + ctx.ExpInfo,
> + Line,
> + QId1,
> + VarIdStr1,
> + Mask1,
> + QId2,
> + VarIdStr2,
> + Mask2,
> + EFI_COMPARE_TYPE.LESS_EQUAL,
> + )
> +
> + elif ctx.Less() != None:
> + ctx.Node = self.IdEqIdDoSpecial(
> + ctx.ExpInfo,
> + Line,
> + QId1,
> + VarIdStr1,
> + Mask1,
> + QId2,
> + VarIdStr2,
> + Mask2,
> + EFI_COMPARE_TYPE.LESS_THAN,
> + )
> +
> + elif ctx.GreaterEqual() != None:
> + ctx.Node = self.IdEqIdDoSpecial(
> + ctx.ExpInfo,
> + Line,
> + QId1,
> + VarIdStr1,
> + Mask1,
> + QId2,
> + VarIdStr2,
> + Mask2,
> + EFI_COMPARE_TYPE.GREATER_EQUAL,
> + )
> +
> + elif ctx.Greater() != None:
> + ctx.Node = self.IdEqIdDoSpecial(
> + ctx.ExpInfo,
> + Line,
> + QId1,
> + VarIdStr1,
> + Mask1,
> + QId2,
> + VarIdStr2,
> + Mask2,
> + EFI_COMPARE_TYPE.GREATER_THAN,
> + )
> + return ctx.Node
> +
> + def IdEqListDoSpecial(self, ExpInfo, LineNo, QId, VarIdStr, Mask, ListLen,
> ValueList):
> + if ListLen == 0:
> + return None
> +
> + Node = self.IdEqValDoSpecial(
> + ExpInfo, LineNo, QId, VarIdStr, Mask, ValueList[0],
> EFI_COMPARE_TYPE.EQUAL
> + )
> + for i in range(1, ListLen):
> + Node.insertChild(
> + self.IdEqValDoSpecial(
> + ExpInfo, LineNo, QId, VarIdStr, Mask, ValueList[i],
> EFI_COMPARE_TYPE.EQUAL
> + )
> + )
> + OObj = IfrOr(LineNo)
> + Node.insertChild(
> + IfrTreeNode(EFI_IFR_OR_OP, OObj,
> gFormPkg.StructToStream(OObj.GetInfo()))
> + )
> + ExpInfo.ExpOpCount += 1
> +
> + return Node
> +
> + # 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:
> + ctx.Node = self.IdEqListDoSpecial(
> + ctx.ExpInfo, LineNo, QId, VarIdStr, Mask, ListLen, ValueList
> + )
> + else:
> + EILObj = IfrEqIdList(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.Node = IfrTreeNode(EFI_IFR_EQ_ID_VAL_LIST_OP, EILObj)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Node
> +
> + # 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.VfrQuestionDB.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.VfrQuestionDB.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.VfrQuestionDB.GetQuestionId(QName)
> +
> + elif ctx.Number() != None:
> + QId = self.TransNum(ctx.Number())
> +
> + QR1Obj = IfrQuestionRef1(Line)
> + self.SaveOpHdrCond(QR1Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> +
> + QR1Obj.SetQuestionId(QId, QName, Line)
> + ctx.Node.Data = QR1Obj
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#rulerefExp.
> + def visitRulerefExp(self, ctx: VfrSyntaxParser.RulerefExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + RRObj = IfrRuleRef(Line)
> + self.SaveOpHdrCond(RRObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + RuleId = self.VfrRulesDB.GetRuleId(self.TransId(ctx.StringIdentifier()))
> + RRObj.SetRuleId(RuleId)
> + ctx.Node.Data = RRObj
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # 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 = IfrStringRef1(Line)
> + self.SaveOpHdrCond(SR1Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + SR1Obj.SetStringId(RefStringId)
> + ctx.Node.Data = SR1Obj
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#pushthisExp.
> + def visitPushthisExp(self, ctx: VfrSyntaxParser.PushthisExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TObj = IfrThis(Line)
> + self.SaveOpHdrCond(TObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0),
> Line)
> + ctx.Node.Data = TObj
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#securityExp.
> + def visitSecurityExp(self, ctx: VfrSyntaxParser.SecurityExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + SObj = IfrSecurity(Line)
> + self.SaveOpHdrCond(SObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0),
> Line)
> + SObj.SetPermissions(ctx.guidDefinition().Guid)
> + ctx.Node.Data = SObj
> + 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.VfrQuestionDB.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 (
> + gVfrDataStorage.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 =
> gVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
> + self.ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var
> type size")
> + ctx.BaseInfo.VarTotalSize = Size
> +
> + Size, ReturnCode =
> gVfrVarDataTypeDB.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",
> + )
> +
> + GObj = IfrGet(Line)
> + self.SaveOpHdrCond(GObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0),
> Line)
> + GObj.SetVarInfo(ctx.BaseInfo)
> + ctx.Node.Data = GObj
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # 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 = IfrTrue(Line)
> + self.SaveOpHdrCond(TObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_TRUE_OP, TObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.FalseSymbol() != None:
> + FObj = IfrFalse(Line)
> + self.SaveOpHdrCond(FObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_FALSE_OP, FObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.One() != None:
> + OObj = IfrOne(Line)
> + self.SaveOpHdrCond(OObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_ONE_OP, OObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.Ones() != None:
> + OObj = IfrOnes(Line)
> + self.SaveOpHdrCond(OObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_ONES_OP, OObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.Zero() != None:
> + ZObj = IfrZero(Line)
> + self.SaveOpHdrCond(ZObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_ZERO_OP, ZObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.Undefined() != None:
> + UObj = IfrUndefined(Line)
> + self.SaveOpHdrCond(UObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_UNDEFINED_OP, UObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.Version() != None:
> + VObj = IfrVersion(Line)
> + self.SaveOpHdrCond(VObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_VERSION_OP, VObj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + if ctx.Number() != None:
> + U64Obj = IfrUint64(Line)
> + U64Obj.SetValue(self.TransNum(ctx.Number()))
> + self.SaveOpHdrCond(U64Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount
> == 0), Line)
> + ctx.Node = IfrTreeNode(EFI_IFR_UINT64_OP, U64Obj)
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Node
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionUnaryOp.
> + def visitVfrExpressionUnaryOp(self, ctx:
> VfrSyntaxParser.VfrExpressionUnaryOpContext):
> + self.visitChildren(ctx)
> + if ctx.lengthExp() != None:
> + ctx.Nodes = ctx.lengthExp().Nodes
> + if ctx.bitwisenotExp() != None:
> + ctx.Nodes = ctx.bitwisenotExp().Nodes
> + if ctx.question23refExp() != None:
> + ctx.Nodes = ctx.question23refExp().Nodes
> + if ctx.stringref2Exp() != None:
> + ctx.Nodes = ctx.stringref2Exp().Nodes
> + if ctx.toboolExp() != None:
> + ctx.Nodes = ctx.toboolExp().Nodes
> + if ctx.tostringExp() != None:
> + ctx.Nodes = ctx.tostringExp().Nodes
> + if ctx.unintExp() != None:
> + ctx.Nodes = ctx.unintExp().Nodes
> + if ctx.toupperExp() != None:
> + ctx.Nodes = ctx.toupperExp().Nodes
> + if ctx.tolwerExp() != None:
> + ctx.Nodes = ctx.tolwerExp().Nodes
> + if ctx.setExp() != None:
> + ctx.Nodes = ctx.setExp().Nodes
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#lengthExp.
> + def visitLengthExp(self, ctx: VfrSyntaxParser.LengthExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + LObj = IfrLength(Line)
> + Node = IfrTreeNode(EFI_IFR_LENGTH_OP, LObj,
> gFormPkg.StructToStream(LObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#bitwisenotExp.
> + def visitBitwisenotExp(self, ctx: VfrSyntaxParser.BitwisenotExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + BWNObj = IfrBitWiseNot(Line)
> + Node = IfrTreeNode(
> + EFI_IFR_BITWISE_NOT_OP, BWNObj,
> gFormPkg.StructToStream(BWNObj.GetInfo())
> + )
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # 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 = IfrQuestionRef2(Line)
> + self.SaveOpHdrCond(QR2Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount
> == 0), Line)
> + Node = IfrTreeNode(EFI_IFR_QUESTION_REF2_OP, QR2Obj)
> + ctx.Nodes.append(Node)
> +
> + if Type == 0x2:
> + QR3_2Obj = IfrQuestionRef3_2(Line)
> + self.SaveOpHdrCond(QR3_2Obj.GetHeader(),
> (ctx.ExpInfo.ExpOpCount == 0), Line)
> + QR3_2Obj.SetDevicePath(DevicePath)
> + Node = IfrTreeNode(EFI_IFR_QUESTION_REF3_OP, QR3_2Obj)
> + ctx.Nodes.append(Node)
> +
> + if Type == 0x3:
> + QR3_3Obj = IfrQuestionRef3_3(Line)
> + self.SaveOpHdrCond(QR3_3Obj.GetHeader(),
> (ctx.ExpInfo.ExpOpCount == 0), Line)
> + QR3_3Obj.SetDevicePath(DevicePath)
> + QR3_3Obj.SetGuid(ctx.guidDefinition().Guid)
> + Node = IfrTreeNode(EFI_IFR_QUESTION_REF3_OP, QR3_3Obj)
> + ctx.Nodes.append(Node)
> +
> + ctx.ExpInfo.ExpOpCount += 1
> +
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#stringref2Exp.
> + def visitStringref2Exp(self, ctx: VfrSyntaxParser.Stringref2ExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + SR2Obj = IfrStringRef2(Line)
> + Node = IfrTreeNode(
> + EFI_IFR_STRING_REF2_OP, SR2Obj,
> gFormPkg.StructToStream(SR2Obj.GetInfo())
> + )
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#toboolExp.
> + def visitToboolExp(self, ctx: VfrSyntaxParser.ToboolExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TBObj = IfrToBoolean(Line)
> + Node = IfrTreeNode(EFI_IFR_TO_BOOLEAN_OP, TBObj,
> gFormPkg.StructToStream(TBObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#tostringExp.
> + def visitTostringExp(self, ctx: VfrSyntaxParser.TostringExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TSObj = IfrToString(Line)
> + Fmt = self.TransNum(ctx.Number())
> + TSObj.SetFormat(Fmt)
> + Node = IfrTreeNode(EFI_IFR_TO_STRING_OP, TSObj,
> gFormPkg.StructToStream(TSObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#unintExp.
> + def visitUnintExp(self, ctx: VfrSyntaxParser.UnintExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TUObj = IfrToUint(Line)
> + Node = IfrTreeNode(EFI_IFR_TO_UINT_OP, TUObj,
> gFormPkg.StructToStream(TUObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#toupperExp.
> + def visitToupperExp(self, ctx: VfrSyntaxParser.ToupperExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TUObj = IfrToUpper(Line)
> + Node = IfrTreeNode(EFI_IFR_TO_UPPER_OP, TUObj,
> gFormPkg.StructToStream(TUObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#tolwerExp.
> + def visitTolwerExp(self, ctx: VfrSyntaxParser.TolwerExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TLObj = IfrToLower(Line)
> + Node = IfrTreeNode(EFI_IFR_TO_LOWER_OP, TLObj,
> gFormPkg.StructToStream(TLObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # 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.VfrQuestionDB.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 (
> + gVfrDataStorage.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 =
> gVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
> + self.ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var
> type size")
> + ctx.BaseInfo.VarTotalSize = Size
> +
> + Size, ReturnCode =
> gVfrVarDataTypeDB.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",
> + )
> +
> + TSObj = IfrSet(Line)
> + self.SaveOpHdrCond(TSObj.GetHeader(), (ctx.ExpInfo.ExpOpCount ==
> 0), Line)
> + TSObj.SetVarInfo(ctx.BaseInfo)
> + Node = IfrTreeNode(EFI_IFR_SET_OP, TSObj)
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionTernaryOp.
> + def visitVfrExpressionTernaryOp(self, ctx:
> VfrSyntaxParser.VfrExpressionTernaryOpContext):
> + self.visitChildren(ctx)
> + if ctx.conditionalExp() != None:
> + ctx.Nodes = ctx.conditionalExp().Nodes
> + if ctx.findExp() != None:
> + ctx.Nodes = ctx.findExp().Nodes
> + if ctx.midExp() != None:
> + ctx.Nodes = ctx.midExp().Nodes
> + if ctx.tokenExp() != None:
> + ctx.Nodes = ctx.tokenExp().Nodes
> + if ctx.spanExp() != None:
> + ctx.Nodes = ctx.spanExp().Nodes
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#conditionalExp.
> + def visitConditionalExp(self, ctx: VfrSyntaxParser.ConditionalExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + CObj = IfrConditional(Line)
> + Node = IfrTreeNode(EFI_IFR_CONDITIONAL_OP, CObj,
> gFormPkg.StructToStream(CObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#findExp.
> + def visitFindExp(self, ctx: VfrSyntaxParser.FindExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + FObj = IfrFind(Line)
> + for i in range(0, len(ctx.findFormat())):
> + Format = ctx.findFormat(i).Format
> + FObj.SetFormat(Format)
> + Node = IfrTreeNode(EFI_IFR_FIND_OP, FObj,
> gFormPkg.StructToStream(FObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # 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)
> + MObj = IfrMid(Line)
> + Node = IfrTreeNode(EFI_IFR_MID_OP, MObj,
> gFormPkg.StructToStream(MObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # Visit a parse tree produced by VfrSyntaxParser#tokenExp.
> + def visitTokenExp(self, ctx: VfrSyntaxParser.TokenExpContext):
> + Line = ctx.start.line
> + self.visitChildren(ctx)
> + TObj = IfrToken(Line)
> + Node = IfrTreeNode(EFI_IFR_TOKEN_OP, TObj,
> gFormPkg.StructToStream(TObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # 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
> + SObj = IfrSpan(Line)
> + SObj.SetFlags(Flags)
> + Node = IfrTreeNode(EFI_IFR_SPAN_OP, SObj,
> gFormPkg.StructToStream(SObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + # 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)
> + MObj = IfrMap(Line)
> + Node = IfrTreeNode(EFI_IFR_MAP_OP, MObj,
> gFormPkg.StructToStream(MObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + for Node in ctx.Node.Child:
> + ctx.Nodes.append(Node)
> + EObj = IfrEnd()
> + EObj.SetLineNo(ctx.stop.line)
> + Node = IfrTreeNode(EFI_IFR_END_OP, EObj,
> gFormPkg.StructToStream(EObj.GetInfo()))
> + ctx.Nodes.append(Node)
> + ctx.ExpInfo.ExpOpCount += 1
> + return ctx.Nodes
> +
> + 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 StrToken.startswith("0x") or StrToken.startswith("0X"):
> + NumberToken = int(StrToken, 16)
> + else:
> + NumberToken = int(StrToken)
> + return NumberToken
> +
> + def AssignQuestionKey(self, OpObj, Key):
> + if Key == None:
> + return
> +
> + if OpObj.GetQFlags() & EFI_IFR_FLAG_CALLBACK:
> + # if the question is not CALLBACK ignore the key.
> + self.VfrQuestionDB.UpdateQuestionId(OpObj.GetQuestionId(), Key,
> gFormPkg)
> + 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("\r", "").replace("\n", "").replace(" ", " ")
> +
> + def CheckDuplicateDefaultValue(self, DefaultId, Line, TokenValue):
> + for i in range(0, len(self.UsedDefaultArray)):
> + if self.UsedDefaultArray[i] == DefaultId:
> + gVfrErrorHandle.HandleWarning(
> +
> EFI_VFR_WARNING_CODE.VFR_WARNING_DEFAULT_VALUE_REDEFINED, Line,
> TokenValue
> + )
> +
> + if len(self.UsedDefaultArray) >= EFI_IFR_MAX_DEFAULT_TYPE - 1:
> +
> gVfrErrorHandle.HandleError(VfrReturnCode.VFR_RETURN_FATAL_ERROR,
> Line, TokenValue)
> +
> + self.UsedDefaultArray.append(DefaultId)
> +
> + def ErrorHandler(self, ReturnCode, LineNum, TokenValue=None):
> + self.ParserStatus += gVfrErrorHandle.HandleError(ReturnCode,
> LineNum, TokenValue)
> +
> + def CompareErrorHandler(
> + self, ReturnCode, ExpectedCode, LineNum, TokenValue=None,
> ErrorMsg=None
> + ):
> + if ReturnCode != ExpectedCode:
> + self.ParserStatus += 1
> + gVfrErrorHandle.PrintMsg(LineNum, "Error", ErrorMsg, TokenValue)
> +
> + def InsertChild(self, ParentNode: IfrTreeNode, ChildCtx):
> + if ChildCtx != None and ChildCtx.Node != None:
> + ParentNode.insertChild(ChildCtx.Node)
> +
> + def InsertEndNode(self, ParentNode, Line):
> + EObj = IfrEnd()
> + EObj.SetLineNo(Line)
> + ENode = IfrTreeNode(EFI_IFR_END_OP, EObj,
> gFormPkg.StructToStream(EObj.GetInfo()))
> + ParentNode.insertChild(ENode)
> +
> + def GetCurArraySize(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)
> +
> + def GetQuestionDB(self):
> + return self.VfrQuestionDB
> +
> +
> +del VfrSyntaxParser
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrTree.py
> b/BaseTools/Source/Python/VfrCompiler/VfrTree.py
> deleted file mode 100644
> index c78d2dd846..0000000000
> --- a/BaseTools/Source/Python/VfrCompiler/VfrTree.py
> +++ /dev/null
> @@ -1,88 +0,0 @@
> -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/BaseTools/Source/Python/VfrCompiler/VfrUtility.py
> b/BaseTools/Source/Python/VfrCompiler/VfrUtility.py
> deleted file mode 100644
> index b753dd1e1d..0000000000
> --- a/BaseTools/Source/Python/VfrCompiler/VfrUtility.py
> +++ /dev/null
> @@ -1,1991 +0,0 @@
> -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/BaseTools/Source/Python/VfrCompiler/__init__.py
> b/BaseTools/Source/Python/VfrCompiler/__init__.py
> new file mode 100644
> index 0000000000..36b2dfb9b2
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/__init__.py
> @@ -0,0 +1 @@
> +__all__ = ["VfrCompiler"]
> diff --git a/BaseTools/Source/Python/VfrCompiler/main.py
> b/BaseTools/Source/Python/VfrCompiler/main.py
> deleted file mode 100644
> index 624cfe3aa8..0000000000
> --- a/BaseTools/Source/Python/VfrCompiler/main.py
> +++ /dev/null
> @@ -1,27 +0,0 @@
> -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.26.2.windows.1
>
>
>
>
>
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#116825): https://edk2.groups.io/g/devel/message/116825
Mute This Topic: https://groups.io/mt/104944032/7686176
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [rebecca@openfw.io]
-=-=-=-=-=-=-=-=-=-=-=-
prev parent reply other threads:[~2024-03-18 0:37 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-03-15 9:20 [edk2-devel] [Patch V2] [edk2-staging]BaseTools: Python VfrCompiler Tool Yuting Yang
2024-03-18 0:36 ` Yuwei Chen [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=PH7PR11MB5915BA5E7FD92A6F7F009943962D2@PH7PR11MB5915.namprd11.prod.outlook.com \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox