* [edk2-devel] [PATCH] BaseTools: Python VfrCompiler implementation
@ 2023-11-08 12:45 Yuting Yang
2023-11-08 13:45 ` Yuwei Chen
[not found] ` <1795A9DEEBB01830.6123@groups.io>
0 siblings, 2 replies; 4+ messages in thread
From: Yuting Yang @ 2023-11-08 12:45 UTC (permalink / raw)
To: devel; +Cc: Rebecca Cran, Liming Gao, Bob Feng, Yuwei Chen
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/VfrCompile.
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>
Signed-off-by: Yuwei Chen <yuwei.chen@intel.com>
---
.../Source/Python/VfrCompiler/IfrCommon.py | 100 +
.../Source/Python/VfrCompiler/IfrCompiler.py | 586 +
.../Source/Python/VfrCompiler/IfrCtypes.py | 1811 ++
.../Source/Python/VfrCompiler/IfrError.py | 153 +
.../Source/Python/VfrCompiler/IfrFormPkg.py | 2937 +++
.../Python/VfrCompiler/IfrPreProcess.py | 245 +
.../Source/Python/VfrCompiler/IfrTree.py | 1132 +
.../Source/Python/VfrCompiler/IfrUtility.py | 2226 ++
BaseTools/Source/Python/VfrCompiler/Readme.md | 68 +
.../Source/Python/VfrCompiler/VfrSyntax.g4 | 1921 ++
.../Python/VfrCompiler/VfrSyntaxLexer.py | 1708 ++
.../Python/VfrCompiler/VfrSyntaxParser.py | 20475 ++++++++++++++++
.../Python/VfrCompiler/VfrSyntaxVisitor.py | 5504 +++++
.../Source/Python/VfrCompiler/__init__.py | 1 +
14 files changed, 38867 insertions(+)
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCommon.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrError.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrTree.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrUtility.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/Readme.md
create mode 100644 BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
create mode 100644 BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/__init__.py
diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCommon.py b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
new file mode 100644
index 0000000000..7425abe9a9
--- /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..15bf3d59ba
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
@@ -0,0 +1,586 @@
+## @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.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..a7f7a32a27
--- /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..c50288e9e5
--- /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_OPCODE: ": 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..35f50b0cef
--- /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..ed454cdcf3
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
@@ -0,0 +1,245 @@
+## @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 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._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)
+ return UniDict
+
+ 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..faa2e4677d
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/IfrTree.py
@@ -0,0 +1,1132 @@
+## @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.FormSetGuid.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()
+ 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 _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
diff --git a/BaseTools/Source/Python/VfrCompiler/IfrUtility.py b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
new file mode 100644
index 0000000000..3c5cec25ce
--- /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
new file mode 100644
index 0000000000..7bdc85023a
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/Readme.md
@@ -0,0 +1,68 @@
+# 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/VfrCompile.
+
+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;%BASE_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/VfrSyntax.g4 b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
new file mode 100644
index 0000000000..2895377b74
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
@@ -0,0 +1,1921 @@
+//// @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(EFI_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
new file mode 100644
index 0000000000..0e165a0446
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
@@ -0,0 +1,1708 @@
+# Generated from VfrSyntax.g4 by ANTLR 4.7.2
+
+import sys
+from antlr4 import *
+from io import StringIO
+from typing import TextIO
+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\2\u0102")
+ buf.write("\u0ab7\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+ buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
+ buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
+ buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
+ buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
+ buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
+ buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
+ buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
+ buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
+ buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
+ buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\t")
+ buf.write("L\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\t")
+ buf.write("U\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4")
+ buf.write("^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4")
+ buf.write("g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4")
+ buf.write("p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4")
+ buf.write("y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080")
+ buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083")
+ buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087")
+ buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a")
+ buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e")
+ buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091")
+ buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095")
+ buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098")
+ buf.write("\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c")
+ buf.write("\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f")
+ buf.write("\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3")
+ buf.write("\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6")
+ buf.write("\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa")
+ buf.write("\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad")
+ buf.write("\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1")
+ buf.write("\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4")
+ buf.write("\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8")
+ buf.write("\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb")
+ buf.write("\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf")
+ buf.write("\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2")
+ buf.write("\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6")
+ buf.write("\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9")
+ buf.write("\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd")
+ buf.write("\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0")
+ buf.write("\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4")
+ buf.write("\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7")
+ buf.write("\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db")
+ buf.write("\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de")
+ buf.write("\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2")
+ buf.write("\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5")
+ buf.write("\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9")
+ buf.write("\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec")
+ buf.write("\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0")
+ buf.write("\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3")
+ buf.write("\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7")
+ buf.write("\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa")
+ buf.write("\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe")
+ buf.write("\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101")
+ buf.write("\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3")
+ buf.write("\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6")
+ buf.write("\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
+ buf.write("\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n")
+ buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3")
+ buf.write("\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20")
+ buf.write("\3\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\3\22")
+ buf.write("\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
+ buf.write("\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
+ buf.write("\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30\3\31")
+ buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36")
+ buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3")
+ buf.write("%\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3")
+ buf.write(")\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3")
+ buf.write("+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3")
+ buf.write("-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60")
+ buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61")
+ buf.write("\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
+ buf.write("\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63")
+ buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64")
+ buf.write("\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
+ buf.write("\3\65\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67")
+ buf.write("\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\39\39\39\3")
+ buf.write("9\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\3")
+ buf.write(";\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3")
+ buf.write(">\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3")
+ buf.write("A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3")
+ buf.write("C\3D\3D\3D\3D\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3")
+ buf.write("G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3")
+ buf.write("I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3L\3")
+ buf.write("L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3")
+ buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3")
+ buf.write("O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3")
+ buf.write("Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3")
+ buf.write("T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3")
+ buf.write("V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3")
+ buf.write("W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3")
+ buf.write("Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3")
+ buf.write("[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
+ buf.write("\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3")
+ buf.write("^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3")
+ buf.write("`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3")
+ buf.write("c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3")
+ buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3")
+ buf.write("g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3")
+ buf.write("i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3k\3k\3")
+ buf.write("k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3")
+ buf.write("m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3")
+ buf.write("o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3")
+ buf.write("p\3p\3p\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3")
+ buf.write("r\3r\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3u\3u\3u\3u\3")
+ buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3")
+ buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3")
+ buf.write("w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3")
+ buf.write("x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3z\3z\3")
+ buf.write("z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3")
+ buf.write("{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3")
+ buf.write("|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3")
+ buf.write("~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3")
+ buf.write("\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080")
+ buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081")
+ buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081")
+ buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082")
+ buf.write("\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083")
+ buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084")
+ buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085")
+ buf.write("\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086")
+ buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087")
+ buf.write("\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088")
+ buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089")
+ buf.write("\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
+ buf.write("\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
+ buf.write("\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d")
+ buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e")
+ buf.write("\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f")
+ buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090")
+ buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090")
+ buf.write("\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091")
+ buf.write("\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092")
+ buf.write("\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094")
+ buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094")
+ buf.write("\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096")
+ buf.write("\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097")
+ buf.write("\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098")
+ buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098")
+ buf.write("\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
+ buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
+ buf.write("\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
+ buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
+ buf.write("\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b")
+ buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c")
+ buf.write("\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d")
+ buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d")
+ buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e")
+ buf.write("\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
+ buf.write("\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0")
+ buf.write("\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1")
+ buf.write("\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2")
+ buf.write("\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3")
+ buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a4")
+ buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
+ buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
+ buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
+ buf.write("\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
+ buf.write("\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
+ buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8")
+ buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
+ buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa")
+ buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab")
+ buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
+ buf.write("\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
+ buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad")
+ buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad")
+ buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae")
+ buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
+ buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af")
+ buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af")
+ buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0")
+ buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
+ buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1")
+ buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1")
+ buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
+ buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
+ buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
+ buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
+ buf.write("\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4")
+ buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5")
+ buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5")
+ buf.write("\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
+ buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
+ buf.write("\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
+ buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
+ buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
+ buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
+ buf.write("\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
+ buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
+ buf.write("\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
+ buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
+ buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb")
+ buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc")
+ buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
+ buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
+ buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd")
+ buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be")
+ buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
+ buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
+ buf.write("\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf")
+ buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0")
+ buf.write("\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2")
+ buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3")
+ buf.write("\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
+ buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6")
+ buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
+ buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8")
+ buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
+ buf.write("\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca")
+ buf.write("\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
+ buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
+ buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc")
+ buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd")
+ buf.write("\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce")
+ buf.write("\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce")
+ buf.write("\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf")
+ buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0")
+ buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1")
+ buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2")
+ buf.write("\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3")
+ buf.write("\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5")
+ buf.write("\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6")
+ buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7")
+ buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8")
+ buf.write("\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9")
+ buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da")
+ buf.write("\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc")
+ buf.write("\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de")
+ buf.write("\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df")
+ buf.write("\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0")
+ buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1")
+ buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2")
+ buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2")
+ buf.write("\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3")
+ buf.write("\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4")
+ buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5")
+ buf.write("\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6")
+ buf.write("\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
+ buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
+ buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
+ buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
+ buf.write("\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea")
+ buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea")
+ buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb")
+ buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb")
+ buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
+ buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
+ buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed")
+ buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
+ buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
+ buf.write("\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
+ buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
+ buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
+ buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
+ buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0")
+ buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0")
+ buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1")
+ buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1")
+ buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2")
+ buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
+ buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
+ buf.write("\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
+ buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
+ buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4")
+ buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
+ buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
+ buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5")
+ buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6")
+ buf.write("\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6")
+ buf.write("\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
+ buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
+ buf.write("\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
+ buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
+ buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9")
+ buf.write("\3\u00f9\6\u00f9\u0a44\n\u00f9\r\u00f9\16\u00f9\u0a45")
+ buf.write("\3\u00f9\6\u00f9\u0a49\n\u00f9\r\u00f9\16\u00f9\u0a4a")
+ buf.write("\5\u00f9\u0a4d\n\u00f9\3\u00fa\3\u00fa\7\u00fa\u0a51\n")
+ buf.write("\u00fa\f\u00fa\16\u00fa\u0a54\13\u00fa\3\u00fb\3\u00fb")
+ buf.write("\5\u00fb\u0a58\n\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fb")
+ buf.write("\3\u00fb\3\u00fb\3\u00fb\3\u00fb\7\u00fb\u0a62\n\u00fb")
+ buf.write("\f\u00fb\16\u00fb\u0a65\13\u00fb\3\u00fb\3\u00fb\3\u00fc")
+ buf.write("\3\u00fc\5\u00fc\u0a6b\n\u00fc\3\u00fc\3\u00fc\3\u00fc")
+ buf.write("\3\u00fc\3\u00fc\3\u00fc\7\u00fc\u0a73\n\u00fc\f\u00fc")
+ buf.write("\16\u00fc\u0a76\13\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd")
+ buf.write("\5\u00fd\u0a7c\n\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd")
+ buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\7\u00fd\u0a87")
+ buf.write("\n\u00fd\f\u00fd\16\u00fd\u0a8a\13\u00fd\3\u00fd\3\u00fd")
+ buf.write("\3\u00fe\6\u00fe\u0a8f\n\u00fe\r\u00fe\16\u00fe\u0a90")
+ buf.write("\3\u00fe\3\u00fe\3\u00ff\3\u00ff\5\u00ff\u0a97\n\u00ff")
+ buf.write("\3\u00ff\5\u00ff\u0a9a\n\u00ff\3\u00ff\3\u00ff\3\u0100")
+ buf.write("\3\u0100\3\u0100\3\u0100\7\u0100\u0aa2\n\u0100\f\u0100")
+ buf.write("\16\u0100\u0aa5\13\u0100\3\u0100\3\u0100\3\u0101\3\u0101")
+ buf.write("\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\7\u0101")
+ buf.write("\u0ab1\n\u0101\f\u0101\16\u0101\u0ab4\13\u0101\3\u0101")
+ buf.write("\3\u0101\2\2\u0102\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n")
+ buf.write("\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'")
+ buf.write("\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ")
+ buf.write("?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g")
+ buf.write("\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085")
+ buf.write("D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095")
+ buf.write("L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5")
+ buf.write("T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5")
+ buf.write("\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5")
+ buf.write("d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5")
+ buf.write("l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5")
+ buf.write("t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1z\u00f3{\u00f5")
+ buf.write("|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff\u0081\u0101")
+ buf.write("\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086")
+ buf.write("\u010b\u0087\u010d\u0088\u010f\u0089\u0111\u008a\u0113")
+ buf.write("\u008b\u0115\u008c\u0117\u008d\u0119\u008e\u011b\u008f")
+ buf.write("\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125")
+ buf.write("\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098")
+ buf.write("\u012f\u0099\u0131\u009a\u0133\u009b\u0135\u009c\u0137")
+ buf.write("\u009d\u0139\u009e\u013b\u009f\u013d\u00a0\u013f\u00a1")
+ buf.write("\u0141\u00a2\u0143\u00a3\u0145\u00a4\u0147\u00a5\u0149")
+ buf.write("\u00a6\u014b\u00a7\u014d\u00a8\u014f\u00a9\u0151\u00aa")
+ buf.write("\u0153\u00ab\u0155\u00ac\u0157\u00ad\u0159\u00ae\u015b")
+ buf.write("\u00af\u015d\u00b0\u015f\u00b1\u0161\u00b2\u0163\u00b3")
+ buf.write("\u0165\u00b4\u0167\u00b5\u0169\u00b6\u016b\u00b7\u016d")
+ buf.write("\u00b8\u016f\u00b9\u0171\u00ba\u0173\u00bb\u0175\u00bc")
+ buf.write("\u0177\u00bd\u0179\u00be\u017b\u00bf\u017d\u00c0\u017f")
+ buf.write("\u00c1\u0181\u00c2\u0183\u00c3\u0185\u00c4\u0187\u00c5")
+ buf.write("\u0189\u00c6\u018b\u00c7\u018d\u00c8\u018f\u00c9\u0191")
+ buf.write("\u00ca\u0193\u00cb\u0195\u00cc\u0197\u00cd\u0199\u00ce")
+ buf.write("\u019b\u00cf\u019d\u00d0\u019f\u00d1\u01a1\u00d2\u01a3")
+ buf.write("\u00d3\u01a5\u00d4\u01a7\u00d5\u01a9\u00d6\u01ab\u00d7")
+ buf.write("\u01ad\u00d8\u01af\u00d9\u01b1\u00da\u01b3\u00db\u01b5")
+ buf.write("\u00dc\u01b7\u00dd\u01b9\u00de\u01bb\u00df\u01bd\u00e0")
+ buf.write("\u01bf\u00e1\u01c1\u00e2\u01c3\u00e3\u01c5\u00e4\u01c7")
+ buf.write("\u00e5\u01c9\u00e6\u01cb\u00e7\u01cd\u00e8\u01cf\u00e9")
+ buf.write("\u01d1\u00ea\u01d3\u00eb\u01d5\u00ec\u01d7\u00ed\u01d9")
+ buf.write("\u00ee\u01db\u00ef\u01dd\u00f0\u01df\u00f1\u01e1\u00f2")
+ buf.write("\u01e3\u00f3\u01e5\u00f4\u01e7\u00f5\u01e9\u00f6\u01eb")
+ buf.write("\u00f7\u01ed\u00f8\u01ef\u00f9\u01f1\u00fa\u01f3\u00fb")
+ buf.write("\u01f5\u00fc\u01f7\u00fd\u01f9\u00fe\u01fb\u00ff\u01fd")
+ buf.write("\u0100\u01ff\u0101\u0201\u0102\3\2\t\5\2\62;CHch\3\2\62")
+ buf.write(";\5\2C\\aac|\6\2\62;C\\aac|\5\2\f\f\17\17%%\4\2\13\13")
+ buf.write("\"\"\4\2\f\f\17\17\2\u0ac5\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
+ buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
+ buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
+ buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
+ buf.write("\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2")
+ buf.write("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
+ buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
+ buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2")
+ buf.write("\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3")
+ buf.write("\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y")
+ buf.write("\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2")
+ buf.write("c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2")
+ buf.write("\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2")
+ buf.write("\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3")
+ buf.write("\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2")
+ buf.write("\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d")
+ buf.write("\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2")
+ buf.write("\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b")
+ buf.write("\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2")
+ buf.write("\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9")
+ buf.write("\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2")
+ buf.write("\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7")
+ buf.write("\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2")
+ buf.write("\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5")
+ buf.write("\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2")
+ buf.write("\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3")
+ buf.write("\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2")
+ buf.write("\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1")
+ buf.write("\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2")
+ buf.write("\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef")
+ buf.write("\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2")
+ buf.write("\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd")
+ buf.write("\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2")
+ buf.write("\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b")
+ buf.write("\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2")
+ buf.write("\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119")
+ buf.write("\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2")
+ buf.write("\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u0127")
+ buf.write("\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2")
+ buf.write("\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\2\u0135")
+ buf.write("\3\2\2\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2")
+ buf.write("\2\2\u013d\3\2\2\2\2\u013f\3\2\2\2\2\u0141\3\2\2\2\2\u0143")
+ buf.write("\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2")
+ buf.write("\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151")
+ buf.write("\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2")
+ buf.write("\2\2\u0159\3\2\2\2\2\u015b\3\2\2\2\2\u015d\3\2\2\2\2\u015f")
+ buf.write("\3\2\2\2\2\u0161\3\2\2\2\2\u0163\3\2\2\2\2\u0165\3\2\2")
+ buf.write("\2\2\u0167\3\2\2\2\2\u0169\3\2\2\2\2\u016b\3\2\2\2\2\u016d")
+ buf.write("\3\2\2\2\2\u016f\3\2\2\2\2\u0171\3\2\2\2\2\u0173\3\2\2")
+ buf.write("\2\2\u0175\3\2\2\2\2\u0177\3\2\2\2\2\u0179\3\2\2\2\2\u017b")
+ buf.write("\3\2\2\2\2\u017d\3\2\2\2\2\u017f\3\2\2\2\2\u0181\3\2\2")
+ buf.write("\2\2\u0183\3\2\2\2\2\u0185\3\2\2\2\2\u0187\3\2\2\2\2\u0189")
+ buf.write("\3\2\2\2\2\u018b\3\2\2\2\2\u018d\3\2\2\2\2\u018f\3\2\2")
+ buf.write("\2\2\u0191\3\2\2\2\2\u0193\3\2\2\2\2\u0195\3\2\2\2\2\u0197")
+ buf.write("\3\2\2\2\2\u0199\3\2\2\2\2\u019b\3\2\2\2\2\u019d\3\2\2")
+ buf.write("\2\2\u019f\3\2\2\2\2\u01a1\3\2\2\2\2\u01a3\3\2\2\2\2\u01a5")
+ buf.write("\3\2\2\2\2\u01a7\3\2\2\2\2\u01a9\3\2\2\2\2\u01ab\3\2\2")
+ buf.write("\2\2\u01ad\3\2\2\2\2\u01af\3\2\2\2\2\u01b1\3\2\2\2\2\u01b3")
+ buf.write("\3\2\2\2\2\u01b5\3\2\2\2\2\u01b7\3\2\2\2\2\u01b9\3\2\2")
+ buf.write("\2\2\u01bb\3\2\2\2\2\u01bd\3\2\2\2\2\u01bf\3\2\2\2\2\u01c1")
+ buf.write("\3\2\2\2\2\u01c3\3\2\2\2\2\u01c5\3\2\2\2\2\u01c7\3\2\2")
+ buf.write("\2\2\u01c9\3\2\2\2\2\u01cb\3\2\2\2\2\u01cd\3\2\2\2\2\u01cf")
+ buf.write("\3\2\2\2\2\u01d1\3\2\2\2\2\u01d3\3\2\2\2\2\u01d5\3\2\2")
+ buf.write("\2\2\u01d7\3\2\2\2\2\u01d9\3\2\2\2\2\u01db\3\2\2\2\2\u01dd")
+ buf.write("\3\2\2\2\2\u01df\3\2\2\2\2\u01e1\3\2\2\2\2\u01e3\3\2\2")
+ buf.write("\2\2\u01e5\3\2\2\2\2\u01e7\3\2\2\2\2\u01e9\3\2\2\2\2\u01eb")
+ buf.write("\3\2\2\2\2\u01ed\3\2\2\2\2\u01ef\3\2\2\2\2\u01f1\3\2\2")
+ buf.write("\2\2\u01f3\3\2\2\2\2\u01f5\3\2\2\2\2\u01f7\3\2\2\2\2\u01f9")
+ buf.write("\3\2\2\2\2\u01fb\3\2\2\2\2\u01fd\3\2\2\2\2\u01ff\3\2\2")
+ buf.write("\2\2\u0201\3\2\2\2\3\u0203\3\2\2\2\5\u0208\3\2\2\2\7\u020d")
+ buf.write("\3\2\2\2\t\u0211\3\2\2\2\13\u0219\3\2\2\2\r\u021e\3\2")
+ buf.write("\2\2\17\u0220\3\2\2\2\21\u022c\3\2\2\2\23\u0237\3\2\2")
+ buf.write("\2\25\u0242\3\2\2\2\27\u0245\3\2\2\2\31\u0248\3\2\2\2")
+ buf.write("\33\u024a\3\2\2\2\35\u024c\3\2\2\2\37\u024e\3\2\2\2!\u0255")
+ buf.write("\3\2\2\2#\u0257\3\2\2\2%\u025f\3\2\2\2\'\u0268\3\2\2\2")
+ buf.write(")\u0274\3\2\2\2+\u0276\3\2\2\2-\u0278\3\2\2\2/\u027a\3")
+ buf.write("\2\2\2\61\u027c\3\2\2\2\63\u027e\3\2\2\2\65\u0280\3\2")
+ buf.write("\2\2\67\u0282\3\2\2\29\u0284\3\2\2\2;\u0286\3\2\2\2=\u0288")
+ buf.write("\3\2\2\2?\u028a\3\2\2\2A\u028c\3\2\2\2C\u028f\3\2\2\2")
+ buf.write("E\u0292\3\2\2\2G\u0295\3\2\2\2I\u0297\3\2\2\2K\u029a\3")
+ buf.write("\2\2\2M\u029c\3\2\2\2O\u029e\3\2\2\2Q\u02a0\3\2\2\2S\u02ab")
+ buf.write("\3\2\2\2U\u02b3\3\2\2\2W\u02bd\3\2\2\2Y\u02c8\3\2\2\2")
+ buf.write("[\u02ce\3\2\2\2]\u02d5\3\2\2\2_\u02db\3\2\2\2a\u02e4\3")
+ buf.write("\2\2\2c\u02eb\3\2\2\2e\u02f7\3\2\2\2g\u0305\3\2\2\2i\u030d")
+ buf.write("\3\2\2\2k\u0315\3\2\2\2m\u031a\3\2\2\2o\u0322\3\2\2\2")
+ buf.write("q\u032b\3\2\2\2s\u0333\3\2\2\2u\u033c\3\2\2\2w\u0348\3")
+ buf.write("\2\2\2y\u034d\3\2\2\2{\u0352\3\2\2\2}\u0359\3\2\2\2\177")
+ buf.write("\u035f\3\2\2\2\u0081\u0364\3\2\2\2\u0083\u036c\3\2\2\2")
+ buf.write("\u0085\u0371\3\2\2\2\u0087\u0377\3\2\2\2\u0089\u037b\3")
+ buf.write("\2\2\2\u008b\u0380\3\2\2\2\u008d\u0388\3\2\2\2\u008f\u038d")
+ buf.write("\3\2\2\2\u0091\u0394\3\2\2\2\u0093\u039b\3\2\2\2\u0095")
+ buf.write("\u03a5\3\2\2\2\u0097\u03ab\3\2\2\2\u0099\u03b3\3\2\2\2")
+ buf.write("\u009b\u03bd\3\2\2\2\u009d\u03ce\3\2\2\2\u009f\u03d5\3")
+ buf.write("\2\2\2\u00a1\u03db\3\2\2\2\u00a3\u03e3\3\2\2\2\u00a5\u03ea")
+ buf.write("\3\2\2\2\u00a7\u03f1\3\2\2\2\u00a9\u03f8\3\2\2\2\u00ab")
+ buf.write("\u03fe\3\2\2\2\u00ad\u040c\3\2\2\2\u00af\u0419\3\2\2\2")
+ buf.write("\u00b1\u0426\3\2\2\2\u00b3\u0432\3\2\2\2\u00b5\u0437\3")
+ buf.write("\2\2\2\u00b7\u0440\3\2\2\2\u00b9\u044c\3\2\2\2\u00bb\u0454")
+ buf.write("\3\2\2\2\u00bd\u045f\3\2\2\2\u00bf\u0467\3\2\2\2\u00c1")
+ buf.write("\u046f\3\2\2\2\u00c3\u0474\3\2\2\2\u00c5\u047c\3\2\2\2")
+ buf.write("\u00c7\u0485\3\2\2\2\u00c9\u0491\3\2\2\2\u00cb\u0498\3")
+ buf.write("\2\2\2\u00cd\u04a2\3\2\2\2\u00cf\u04aa\3\2\2\2\u00d1\u04b2")
+ buf.write("\3\2\2\2\u00d3\u04bb\3\2\2\2\u00d5\u04c6\3\2\2\2\u00d7")
+ buf.write("\u04d0\3\2\2\2\u00d9\u04d7\3\2\2\2\u00db\u04dc\3\2\2\2")
+ buf.write("\u00dd\u04e8\3\2\2\2\u00df\u04f7\3\2\2\2\u00e1\u0501\3")
+ buf.write("\2\2\2\u00e3\u050c\3\2\2\2\u00e5\u0512\3\2\2\2\u00e7\u0516")
+ buf.write("\3\2\2\2\u00e9\u051e\3\2\2\2\u00eb\u052c\3\2\2\2\u00ed")
+ buf.write("\u053d\3\2\2\2\u00ef\u0552\3\2\2\2\u00f1\u055e\3\2\2\2")
+ buf.write("\u00f3\u0568\3\2\2\2\u00f5\u0577\3\2\2\2\u00f7\u058a\3")
+ buf.write("\2\2\2\u00f9\u0595\3\2\2\2\u00fb\u059f\3\2\2\2\u00fd\u05ac")
+ buf.write("\3\2\2\2\u00ff\u05b7\3\2\2\2\u0101\u05bd\3\2\2\2\u0103")
+ buf.write("\u05c6\3\2\2\2\u0105\u05d0\3\2\2\2\u0107\u05d8\3\2\2\2")
+ buf.write("\u0109\u05e0\3\2\2\2\u010b\u05e5\3\2\2\2\u010d\u05ee\3")
+ buf.write("\2\2\2\u010f\u05f5\3\2\2\2\u0111\u05fb\3\2\2\2\u0113\u0600")
+ buf.write("\3\2\2\2\u0115\u0606\3\2\2\2\u0117\u060d\3\2\2\2\u0119")
+ buf.write("\u0612\3\2\2\2\u011b\u0617\3\2\2\2\u011d\u061d\3\2\2\2")
+ buf.write("\u011f\u0626\3\2\2\2\u0121\u0631\3\2\2\2\u0123\u0637\3")
+ buf.write("\2\2\2\u0125\u063e\3\2\2\2\u0127\u0643\3\2\2\2\u0129\u064b")
+ buf.write("\3\2\2\2\u012b\u0651\3\2\2\2\u012d\u0656\3\2\2\2\u012f")
+ buf.write("\u065c\3\2\2\2\u0131\u0668\3\2\2\2\u0133\u0677\3\2\2\2")
+ buf.write("\u0135\u0684\3\2\2\2\u0137\u068e\3\2\2\2\u0139\u0697\3")
+ buf.write("\2\2\2\u013b\u06a3\3\2\2\2\u013d\u06ab\3\2\2\2\u013f\u06bd")
+ buf.write("\3\2\2\2\u0141\u06c4\3\2\2\2\u0143\u06cb\3\2\2\2\u0145")
+ buf.write("\u06d5\3\2\2\2\u0147\u06dd\3\2\2\2\u0149\u06e6\3\2\2\2")
+ buf.write("\u014b\u06f5\3\2\2\2\u014d\u06fc\3\2\2\2\u014f\u0706\3")
+ buf.write("\2\2\2\u0151\u070f\3\2\2\2\u0153\u0714\3\2\2\2\u0155\u071a")
+ buf.write("\3\2\2\2\u0157\u0725\3\2\2\2\u0159\u0731\3\2\2\2\u015b")
+ buf.write("\u073e\3\2\2\2\u015d\u074d\3\2\2\2\u015f\u075a\3\2\2\2")
+ buf.write("\u0161\u0769\3\2\2\2\u0163\u0776\3\2\2\2\u0165\u0788\3")
+ buf.write("\2\2\2\u0167\u079c\3\2\2\2\u0169\u07a7\3\2\2\2\u016b\u07b2")
+ buf.write("\3\2\2\2\u016d\u07c0\3\2\2\2\u016f\u07cf\3\2\2\2\u0171")
+ buf.write("\u07dc\3\2\2\2\u0173\u07ea\3\2\2\2\u0175\u07fa\3\2\2\2")
+ buf.write("\u0177\u080a\3\2\2\2\u0179\u0819\3\2\2\2\u017b\u0826\3")
+ buf.write("\2\2\2\u017d\u0835\3\2\2\2\u017f\u083c\3\2\2\2\u0181\u0844")
+ buf.write("\3\2\2\2\u0183\u0849\3\2\2\2\u0185\u084e\3\2\2\2\u0187")
+ buf.write("\u0852\3\2\2\2\u0189\u0858\3\2\2\2\u018b\u085d\3\2\2\2")
+ buf.write("\u018d\u0861\3\2\2\2\u018f\u086a\3\2\2\2\u0191\u086e\3")
+ buf.write("\2\2\2\u0193\u0876\3\2\2\2\u0195\u087d\3\2\2\2\u0197\u0889")
+ buf.write("\3\2\2\2\u0199\u0895\3\2\2\2\u019b\u089d\3\2\2\2\u019d")
+ buf.write("\u08a7\3\2\2\2\u019f\u08b0\3\2\2\2\u01a1\u08b9\3\2\2\2")
+ buf.write("\u01a3\u08bd\3\2\2\2\u01a5\u08c2\3\2\2\2\u01a7\u08c8\3")
+ buf.write("\2\2\2\u01a9\u08cc\3\2\2\2\u01ab\u08d1\3\2\2\2\u01ad\u08d6")
+ buf.write("\3\2\2\2\u01af\u08e0\3\2\2\2\u01b1\u08e8\3\2\2\2\u01b3")
+ buf.write("\u08ef\3\2\2\2\u01b5\u08f3\3\2\2\2\u01b7\u08f6\3\2\2\2")
+ buf.write("\u01b9\u08fa\3\2\2\2\u01bb\u08fe\3\2\2\2\u01bd\u0900\3")
+ buf.write("\2\2\2\u01bf\u0908\3\2\2\2\u01c1\u0912\3\2\2\2\u01c3\u091b")
+ buf.write("\3\2\2\2\u01c5\u0923\3\2\2\2\u01c7\u092b\3\2\2\2\u01c9")
+ buf.write("\u0931\3\2\2\2\u01cb\u0938\3\2\2\2\u01cd\u0941\3\2\2\2")
+ buf.write("\u01cf\u0950\3\2\2\2\u01d1\u095d\3\2\2\2\u01d3\u0961\3")
+ buf.write("\2\2\2\u01d5\u096d\3\2\2\2\u01d7\u097a\3\2\2\2\u01d9\u0989")
+ buf.write("\3\2\2\2\u01db\u099c\3\2\2\2\u01dd\u09ab\3\2\2\2\u01df")
+ buf.write("\u09ba\3\2\2\2\u01e1\u09c9\3\2\2\2\u01e3\u09d8\3\2\2\2")
+ buf.write("\u01e5\u09e8\3\2\2\2\u01e7\u09f9\3\2\2\2\u01e9\u0a0a\3")
+ buf.write("\2\2\2\u01eb\u0a16\3\2\2\2\u01ed\u0a20\3\2\2\2\u01ef\u0a2f")
+ buf.write("\3\2\2\2\u01f1\u0a4c\3\2\2\2\u01f3\u0a4e\3\2\2\2\u01f5")
+ buf.write("\u0a55\3\2\2\2\u01f7\u0a68\3\2\2\2\u01f9\u0a79\3\2\2\2")
+ buf.write("\u01fb\u0a8e\3\2\2\2\u01fd\u0a99\3\2\2\2\u01ff\u0a9d\3")
+ buf.write("\2\2\2\u0201\u0aa8\3\2\2\2\u0203\u0204\7u\2\2\u0204\u0205")
+ buf.write("\7j\2\2\u0205\u0206\7q\2\2\u0206\u0207\7y\2\2\u0207\4")
+ buf.write("\3\2\2\2\u0208\u0209\7r\2\2\u0209\u020a\7w\2\2\u020a\u020b")
+ buf.write("\7u\2\2\u020b\u020c\7j\2\2\u020c\6\3\2\2\2\u020d\u020e")
+ buf.write("\7r\2\2\u020e\u020f\7q\2\2\u020f\u0210\7r\2\2\u0210\b")
+ buf.write("\3\2\2\2\u0211\u0212\7%\2\2\u0212\u0213\7r\2\2\u0213\u0214")
+ buf.write("\7t\2\2\u0214\u0215\7c\2\2\u0215\u0216\7i\2\2\u0216\u0217")
+ buf.write("\7o\2\2\u0217\u0218\7c\2\2\u0218\n\3\2\2\2\u0219\u021a")
+ buf.write("\7r\2\2\u021a\u021b\7c\2\2\u021b\u021c\7e\2\2\u021c\u021d")
+ buf.write("\7m\2\2\u021d\f\3\2\2\2\u021e\u021f\7?\2\2\u021f\16\3")
+ buf.write("\2\2\2\u0220\u0221\7K\2\2\u0221\u0222\7O\2\2\u0222\u0223")
+ buf.write("\7C\2\2\u0223\u0224\7I\2\2\u0224\u0225\7G\2\2\u0225\u0226")
+ buf.write("\7a\2\2\u0226\u0227\7V\2\2\u0227\u0228\7Q\2\2\u0228\u0229")
+ buf.write("\7M\2\2\u0229\u022a\7G\2\2\u022a\u022b\7P\2\2\u022b\20")
+ buf.write("\3\2\2\2\u022c\u022d\7J\2\2\u022d\u022e\7Q\2\2\u022e\u022f")
+ buf.write("\7T\2\2\u022f\u0230\7K\2\2\u0230\u0231\7\\\2\2\u0231\u0232")
+ buf.write("\7Q\2\2\u0232\u0233\7P\2\2\u0233\u0234\7V\2\2\u0234\u0235")
+ buf.write("\7C\2\2\u0235\u0236\7N\2\2\u0236\22\3\2\2\2\u0237\u0238")
+ buf.write("\7O\2\2\u0238\u0239\7W\2\2\u0239\u023a\7N\2\2\u023a\u023b")
+ buf.write("\7V\2\2\u023b\u023c\7K\2\2\u023c\u023d\7a\2\2\u023d\u023e")
+ buf.write("\7N\2\2\u023e\u023f\7K\2\2\u023f\u0240\7P\2\2\u0240\u0241")
+ buf.write("\7G\2\2\u0241\24\3\2\2\2\u0242\u0243\7>\2\2\u0243\u0244")
+ buf.write("\7>\2\2\u0244\26\3\2\2\2\u0245\u0246\7@\2\2\u0246\u0247")
+ buf.write("\7@\2\2\u0247\30\3\2\2\2\u0248\u0249\7-\2\2\u0249\32\3")
+ buf.write("\2\2\2\u024a\u024b\7,\2\2\u024b\34\3\2\2\2\u024c\u024d")
+ buf.write("\7\'\2\2\u024d\36\3\2\2\2\u024e\u024f\7h\2\2\u024f\u0250")
+ buf.write("\7q\2\2\u0250\u0251\7t\2\2\u0251\u0252\7o\2\2\u0252\u0253")
+ buf.write("\7c\2\2\u0253\u0254\7v\2\2\u0254 \3\2\2\2\u0255\u0256")
+ buf.write("\7A\2\2\u0256\"\3\2\2\2\u0257\u0258\7%\2\2\u0258\u0259")
+ buf.write("\7f\2\2\u0259\u025a\7g\2\2\u025a\u025b\7h\2\2\u025b\u025c")
+ buf.write("\7k\2\2\u025c\u025d\7p\2\2\u025d\u025e\7g\2\2\u025e$\3")
+ buf.write("\2\2\2\u025f\u0260\7%\2\2\u0260\u0261\7k\2\2\u0261\u0262")
+ buf.write("\7p\2\2\u0262\u0263\7e\2\2\u0263\u0264\7n\2\2\u0264\u0265")
+ buf.write("\7w\2\2\u0265\u0266\7f\2\2\u0266\u0267\7g\2\2\u0267&\3")
+ buf.write("\2\2\2\u0268\u0269\7h\2\2\u0269\u026a\7q\2\2\u026a\u026b")
+ buf.write("\7t\2\2\u026b\u026c\7o\2\2\u026c\u026d\7r\2\2\u026d\u026e")
+ buf.write("\7m\2\2\u026e\u026f\7i\2\2\u026f\u0270\7v\2\2\u0270\u0271")
+ buf.write("\7{\2\2\u0271\u0272\7r\2\2\u0272\u0273\7g\2\2\u0273(\3")
+ buf.write("\2\2\2\u0274\u0275\7}\2\2\u0275*\3\2\2\2\u0276\u0277\7")
+ buf.write("\177\2\2\u0277,\3\2\2\2\u0278\u0279\7*\2\2\u0279.\3\2")
+ buf.write("\2\2\u027a\u027b\7+\2\2\u027b\60\3\2\2\2\u027c\u027d\7")
+ buf.write("]\2\2\u027d\62\3\2\2\2\u027e\u027f\7_\2\2\u027f\64\3\2")
+ buf.write("\2\2\u0280\u0281\7\60\2\2\u0281\66\3\2\2\2\u0282\u0283")
+ buf.write("\7/\2\2\u02838\3\2\2\2\u0284\u0285\7<\2\2\u0285:\3\2\2")
+ buf.write("\2\u0286\u0287\7\61\2\2\u0287<\3\2\2\2\u0288\u0289\7=")
+ buf.write("\2\2\u0289>\3\2\2\2\u028a\u028b\7.\2\2\u028b@\3\2\2\2")
+ buf.write("\u028c\u028d\7?\2\2\u028d\u028e\7?\2\2\u028eB\3\2\2\2")
+ buf.write("\u028f\u0290\7#\2\2\u0290\u0291\7?\2\2\u0291D\3\2\2\2")
+ buf.write("\u0292\u0293\7>\2\2\u0293\u0294\7?\2\2\u0294F\3\2\2\2")
+ buf.write("\u0295\u0296\7>\2\2\u0296H\3\2\2\2\u0297\u0298\7@\2\2")
+ buf.write("\u0298\u0299\7?\2\2\u0299J\3\2\2\2\u029a\u029b\7@\2\2")
+ buf.write("\u029bL\3\2\2\2\u029c\u029d\7~\2\2\u029dN\3\2\2\2\u029e")
+ buf.write("\u029f\7(\2\2\u029fP\3\2\2\2\u02a0\u02a1\7f\2\2\u02a1")
+ buf.write("\u02a2\7g\2\2\u02a2\u02a3\7x\2\2\u02a3\u02a4\7k\2\2\u02a4")
+ buf.write("\u02a5\7e\2\2\u02a5\u02a6\7g\2\2\u02a6\u02a7\7r\2\2\u02a7")
+ buf.write("\u02a8\7c\2\2\u02a8\u02a9\7v\2\2\u02a9\u02aa\7j\2\2\u02aa")
+ buf.write("R\3\2\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7q\2\2\u02ad")
+ buf.write("\u02ae\7t\2\2\u02ae\u02af\7o\2\2\u02af\u02b0\7u\2\2\u02b0")
+ buf.write("\u02b1\7g\2\2\u02b1\u02b2\7v\2\2\u02b2T\3\2\2\2\u02b3")
+ buf.write("\u02b4\7h\2\2\u02b4\u02b5\7q\2\2\u02b5\u02b6\7t\2\2\u02b6")
+ buf.write("\u02b7\7o\2\2\u02b7\u02b8\7u\2\2\u02b8\u02b9\7g\2\2\u02b9")
+ buf.write("\u02ba\7v\2\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7f\2\2\u02bc")
+ buf.write("V\3\2\2\2\u02bd\u02be\7g\2\2\u02be\u02bf\7p\2\2\u02bf")
+ buf.write("\u02c0\7f\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2\7q\2\2\u02c2")
+ buf.write("\u02c3\7t\2\2\u02c3\u02c4\7o\2\2\u02c4\u02c5\7u\2\2\u02c5")
+ buf.write("\u02c6\7g\2\2\u02c6\u02c7\7v\2\2\u02c7X\3\2\2\2\u02c8")
+ buf.write("\u02c9\7v\2\2\u02c9\u02ca\7k\2\2\u02ca\u02cb\7v\2\2\u02cb")
+ buf.write("\u02cc\7n\2\2\u02cc\u02cd\7g\2\2\u02cdZ\3\2\2\2\u02ce")
+ buf.write("\u02cf\7h\2\2\u02cf\u02d0\7q\2\2\u02d0\u02d1\7t\2\2\u02d1")
+ buf.write("\u02d2\7o\2\2\u02d2\u02d3\7k\2\2\u02d3\u02d4\7f\2\2\u02d4")
+ buf.write("\\\3\2\2\2\u02d5\u02d6\7q\2\2\u02d6\u02d7\7p\2\2\u02d7")
+ buf.write("\u02d8\7g\2\2\u02d8\u02d9\7q\2\2\u02d9\u02da\7h\2\2\u02da")
+ buf.write("^\3\2\2\2\u02db\u02dc\7g\2\2\u02dc\u02dd\7p\2\2\u02dd")
+ buf.write("\u02de\7f\2\2\u02de\u02df\7q\2\2\u02df\u02e0\7p\2\2\u02e0")
+ buf.write("\u02e1\7g\2\2\u02e1\u02e2\7q\2\2\u02e2\u02e3\7h\2\2\u02e3")
+ buf.write("`\3\2\2\2\u02e4\u02e5\7r\2\2\u02e5\u02e6\7t\2\2\u02e6")
+ buf.write("\u02e7\7q\2\2\u02e7\u02e8\7o\2\2\u02e8\u02e9\7r\2\2\u02e9")
+ buf.write("\u02ea\7v\2\2\u02eab\3\2\2\2\u02eb\u02ec\7q\2\2\u02ec")
+ buf.write("\u02ed\7t\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef\7g\2\2\u02ef")
+ buf.write("\u02f0\7t\2\2\u02f0\u02f1\7g\2\2\u02f1\u02f2\7f\2\2\u02f2")
+ buf.write("\u02f3\7n\2\2\u02f3\u02f4\7k\2\2\u02f4\u02f5\7u\2\2\u02f5")
+ buf.write("\u02f6\7v\2\2\u02f6d\3\2\2\2\u02f7\u02f8\7o\2\2\u02f8")
+ buf.write("\u02f9\7c\2\2\u02f9\u02fa\7z\2\2\u02fa\u02fb\7e\2\2\u02fb")
+ buf.write("\u02fc\7q\2\2\u02fc\u02fd\7p\2\2\u02fd\u02fe\7v\2\2\u02fe")
+ buf.write("\u02ff\7c\2\2\u02ff\u0300\7k\2\2\u0300\u0301\7p\2\2\u0301")
+ buf.write("\u0302\7g\2\2\u0302\u0303\7t\2\2\u0303\u0304\7u\2\2\u0304")
+ buf.write("f\3\2\2\2\u0305\u0306\7g\2\2\u0306\u0307\7p\2\2\u0307")
+ buf.write("\u0308\7f\2\2\u0308\u0309\7n\2\2\u0309\u030a\7k\2\2\u030a")
+ buf.write("\u030b\7u\2\2\u030b\u030c\7v\2\2\u030ch\3\2\2\2\u030d")
+ buf.write("\u030e\7g\2\2\u030e\u030f\7p\2\2\u030f\u0310\7f\2\2\u0310")
+ buf.write("\u0311\7h\2\2\u0311\u0312\7q\2\2\u0312\u0313\7t\2\2\u0313")
+ buf.write("\u0314\7o\2\2\u0314j\3\2\2\2\u0315\u0316\7h\2\2\u0316")
+ buf.write("\u0317\7q\2\2\u0317\u0318\7t\2\2\u0318\u0319\7o\2\2\u0319")
+ buf.write("l\3\2\2\2\u031a\u031b\7h\2\2\u031b\u031c\7q\2\2\u031c")
+ buf.write("\u031d\7t\2\2\u031d\u031e\7o\2\2\u031e\u031f\7o\2\2\u031f")
+ buf.write("\u0320\7c\2\2\u0320\u0321\7r\2\2\u0321n\3\2\2\2\u0322")
+ buf.write("\u0323\7o\2\2\u0323\u0324\7c\2\2\u0324\u0325\7r\2\2\u0325")
+ buf.write("\u0326\7v\2\2\u0326\u0327\7k\2\2\u0327\u0328\7v\2\2\u0328")
+ buf.write("\u0329\7n\2\2\u0329\u032a\7g\2\2\u032ap\3\2\2\2\u032b")
+ buf.write("\u032c\7o\2\2\u032c\u032d\7c\2\2\u032d\u032e\7r\2\2\u032e")
+ buf.write("\u032f\7i\2\2\u032f\u0330\7w\2\2\u0330\u0331\7k\2\2\u0331")
+ buf.write("\u0332\7f\2\2\u0332r\3\2\2\2\u0333\u0334\7u\2\2\u0334")
+ buf.write("\u0335\7w\2\2\u0335\u0336\7d\2\2\u0336\u0337\7v\2\2\u0337")
+ buf.write("\u0338\7k\2\2\u0338\u0339\7v\2\2\u0339\u033a\7n\2\2\u033a")
+ buf.write("\u033b\7g\2\2\u033bt\3\2\2\2\u033c\u033d\7g\2\2\u033d")
+ buf.write("\u033e\7p\2\2\u033e\u033f\7f\2\2\u033f\u0340\7u\2\2\u0340")
+ buf.write("\u0341\7w\2\2\u0341\u0342\7d\2\2\u0342\u0343\7v\2\2\u0343")
+ buf.write("\u0344\7k\2\2\u0344\u0345\7v\2\2\u0345\u0346\7n\2\2\u0346")
+ buf.write("\u0347\7g\2\2\u0347v\3\2\2\2\u0348\u0349\7j\2\2\u0349")
+ buf.write("\u034a\7g\2\2\u034a\u034b\7n\2\2\u034b\u034c\7r\2\2\u034c")
+ buf.write("x\3\2\2\2\u034d\u034e\7v\2\2\u034e\u034f\7g\2\2\u034f")
+ buf.write("\u0350\7z\2\2\u0350\u0351\7v\2\2\u0351z\3\2\2\2\u0352")
+ buf.write("\u0353\7q\2\2\u0353\u0354\7r\2\2\u0354\u0355\7v\2\2\u0355")
+ buf.write("\u0356\7k\2\2\u0356\u0357\7q\2\2\u0357\u0358\7p\2\2\u0358")
+ buf.write("|\3\2\2\2\u0359\u035a\7h\2\2\u035a\u035b\7n\2\2\u035b")
+ buf.write("\u035c\7c\2\2\u035c\u035d\7i\2\2\u035d\u035e\7u\2\2\u035e")
+ buf.write("~\3\2\2\2\u035f\u0360\7f\2\2\u0360\u0361\7c\2\2\u0361")
+ buf.write("\u0362\7v\2\2\u0362\u0363\7g\2\2\u0363\u0080\3\2\2\2\u0364")
+ buf.write("\u0365\7g\2\2\u0365\u0366\7p\2\2\u0366\u0367\7f\2\2\u0367")
+ buf.write("\u0368\7f\2\2\u0368\u0369\7c\2\2\u0369\u036a\7v\2\2\u036a")
+ buf.write("\u036b\7g\2\2\u036b\u0082\3\2\2\2\u036c\u036d\7{\2\2\u036d")
+ buf.write("\u036e\7g\2\2\u036e\u036f\7c\2\2\u036f\u0370\7t\2\2\u0370")
+ buf.write("\u0084\3\2\2\2\u0371\u0372\7o\2\2\u0372\u0373\7q\2\2\u0373")
+ buf.write("\u0374\7p\2\2\u0374\u0375\7v\2\2\u0375\u0376\7j\2\2\u0376")
+ buf.write("\u0086\3\2\2\2\u0377\u0378\7f\2\2\u0378\u0379\7c\2\2\u0379")
+ buf.write("\u037a\7{\2\2\u037a\u0088\3\2\2\2\u037b\u037c\7v\2\2\u037c")
+ buf.write("\u037d\7k\2\2\u037d\u037e\7o\2\2\u037e\u037f\7g\2\2\u037f")
+ buf.write("\u008a\3\2\2\2\u0380\u0381\7g\2\2\u0381\u0382\7p\2\2\u0382")
+ buf.write("\u0383\7f\2\2\u0383\u0384\7v\2\2\u0384\u0385\7k\2\2\u0385")
+ buf.write("\u0386\7o\2\2\u0386\u0387\7g\2\2\u0387\u008c\3\2\2\2\u0388")
+ buf.write("\u0389\7j\2\2\u0389\u038a\7q\2\2\u038a\u038b\7w\2\2\u038b")
+ buf.write("\u038c\7t\2\2\u038c\u008e\3\2\2\2\u038d\u038e\7o\2\2\u038e")
+ buf.write("\u038f\7k\2\2\u038f\u0390\7p\2\2\u0390\u0391\7w\2\2\u0391")
+ buf.write("\u0392\7v\2\2\u0392\u0393\7g\2\2\u0393\u0090\3\2\2\2\u0394")
+ buf.write("\u0395\7u\2\2\u0395\u0396\7g\2\2\u0396\u0397\7e\2\2\u0397")
+ buf.write("\u0398\7q\2\2\u0398\u0399\7p\2\2\u0399\u039a\7f\2\2\u039a")
+ buf.write("\u0092\3\2\2\2\u039b\u039c\7i\2\2\u039c\u039d\7t\2\2\u039d")
+ buf.write("\u039e\7c\2\2\u039e\u039f\7{\2\2\u039f\u03a0\7q\2\2\u03a0")
+ buf.write("\u03a1\7w\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7k\2\2\u03a3")
+ buf.write("\u03a4\7h\2\2\u03a4\u0094\3\2\2\2\u03a5\u03a6\7n\2\2\u03a6")
+ buf.write("\u03a7\7c\2\2\u03a7\u03a8\7d\2\2\u03a8\u03a9\7g\2\2\u03a9")
+ buf.write("\u03aa\7n\2\2\u03aa\u0096\3\2\2\2\u03ab\u03ac\7v\2\2\u03ac")
+ buf.write("\u03ad\7k\2\2\u03ad\u03ae\7o\2\2\u03ae\u03af\7g\2\2\u03af")
+ buf.write("\u03b0\7q\2\2\u03b0\u03b1\7w\2\2\u03b1\u03b2\7v\2\2\u03b2")
+ buf.write("\u0098\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7p\2\2\u03b5")
+ buf.write("\u03b6\7x\2\2\u03b6\u03b7\7g\2\2\u03b7\u03b8\7p\2\2\u03b8")
+ buf.write("\u03b9\7v\2\2\u03b9\u03ba\7q\2\2\u03ba\u03bb\7t\2\2\u03bb")
+ buf.write("\u03bc\7{\2\2\u03bc\u009a\3\2\2\2\u03bd\u03be\7a\2\2\u03be")
+ buf.write("\u03bf\7P\2\2\u03bf\u03c0\7Q\2\2\u03c0\u03c1\7P\2\2\u03c1")
+ buf.write("\u03c2\7a\2\2\u03c2\u03c3\7P\2\2\u03c3\u03c4\7X\2\2\u03c4")
+ buf.write("\u03c5\7a\2\2\u03c5\u03c6\7F\2\2\u03c6\u03c7\7C\2\2\u03c7")
+ buf.write("\u03c8\7V\2\2\u03c8\u03c9\7C\2\2\u03c9\u03ca\7a\2\2\u03ca")
+ buf.write("\u03cb\7O\2\2\u03cb\u03cc\7C\2\2\u03cc\u03cd\7R\2\2\u03cd")
+ buf.write("\u009c\3\2\2\2\u03ce\u03cf\7u\2\2\u03cf\u03d0\7v\2\2\u03d0")
+ buf.write("\u03d1\7t\2\2\u03d1\u03d2\7w\2\2\u03d2\u03d3\7e\2\2\u03d3")
+ buf.write("\u03d4\7v\2\2\u03d4\u009e\3\2\2\2\u03d5\u03d6\7w\2\2\u03d6")
+ buf.write("\u03d7\7p\2\2\u03d7\u03d8\7k\2\2\u03d8\u03d9\7q\2\2\u03d9")
+ buf.write("\u03da\7p\2\2\u03da\u00a0\3\2\2\2\u03db\u03dc\7D\2\2\u03dc")
+ buf.write("\u03dd\7Q\2\2\u03dd\u03de\7Q\2\2\u03de\u03df\7N\2\2\u03df")
+ buf.write("\u03e0\7G\2\2\u03e0\u03e1\7C\2\2\u03e1\u03e2\7P\2\2\u03e2")
+ buf.write("\u00a2\3\2\2\2\u03e3\u03e4\7W\2\2\u03e4\u03e5\7K\2\2\u03e5")
+ buf.write("\u03e6\7P\2\2\u03e6\u03e7\7V\2\2\u03e7\u03e8\78\2\2\u03e8")
+ buf.write("\u03e9\7\66\2\2\u03e9\u00a4\3\2\2\2\u03ea\u03eb\7W\2\2")
+ buf.write("\u03eb\u03ec\7K\2\2\u03ec\u03ed\7P\2\2\u03ed\u03ee\7V")
+ buf.write("\2\2\u03ee\u03ef\7\65\2\2\u03ef\u03f0\7\64\2\2\u03f0\u00a6")
+ buf.write("\3\2\2\2\u03f1\u03f2\7W\2\2\u03f2\u03f3\7K\2\2\u03f3\u03f4")
+ buf.write("\7P\2\2\u03f4\u03f5\7V\2\2\u03f5\u03f6\7\63\2\2\u03f6")
+ buf.write("\u03f7\78\2\2\u03f7\u00a8\3\2\2\2\u03f8\u03f9\7W\2\2\u03f9")
+ buf.write("\u03fa\7K\2\2\u03fa\u03fb\7P\2\2\u03fb\u03fc\7V\2\2\u03fc")
+ buf.write("\u03fd\7:\2\2\u03fd\u00aa\3\2\2\2\u03fe\u03ff\7G\2\2\u03ff")
+ buf.write("\u0400\7H\2\2\u0400\u0401\7K\2\2\u0401\u0402\7a\2\2\u0402")
+ buf.write("\u0403\7U\2\2\u0403\u0404\7V\2\2\u0404\u0405\7T\2\2\u0405")
+ buf.write("\u0406\7K\2\2\u0406\u0407\7P\2\2\u0407\u0408\7I\2\2\u0408")
+ buf.write("\u0409\7a\2\2\u0409\u040a\7K\2\2\u040a\u040b\7F\2\2\u040b")
+ buf.write("\u00ac\3\2\2\2\u040c\u040d\7G\2\2\u040d\u040e\7H\2\2\u040e")
+ buf.write("\u040f\7K\2\2\u040f\u0410\7a\2\2\u0410\u0411\7J\2\2\u0411")
+ buf.write("\u0412\7K\2\2\u0412\u0413\7K\2\2\u0413\u0414\7a\2\2\u0414")
+ buf.write("\u0415\7F\2\2\u0415\u0416\7C\2\2\u0416\u0417\7V\2\2\u0417")
+ buf.write("\u0418\7G\2\2\u0418\u00ae\3\2\2\2\u0419\u041a\7G\2\2\u041a")
+ buf.write("\u041b\7H\2\2\u041b\u041c\7K\2\2\u041c\u041d\7a\2\2\u041d")
+ buf.write("\u041e\7J\2\2\u041e\u041f\7K\2\2\u041f\u0420\7K\2\2\u0420")
+ buf.write("\u0421\7a\2\2\u0421\u0422\7V\2\2\u0422\u0423\7K\2\2\u0423")
+ buf.write("\u0424\7O\2\2\u0424\u0425\7G\2\2\u0425\u00b0\3\2\2\2\u0426")
+ buf.write("\u0427\7G\2\2\u0427\u0428\7H\2\2\u0428\u0429\7K\2\2\u0429")
+ buf.write("\u042a\7a\2\2\u042a\u042b\7J\2\2\u042b\u042c\7K\2\2\u042c")
+ buf.write("\u042d\7K\2\2\u042d\u042e\7a\2\2\u042e\u042f\7T\2\2\u042f")
+ buf.write("\u0430\7G\2\2\u0430\u0431\7H\2\2\u0431\u00b2\3\2\2\2\u0432")
+ buf.write("\u0433\7i\2\2\u0433\u0434\7w\2\2\u0434\u0435\7k\2\2\u0435")
+ buf.write("\u0436\7f\2\2\u0436\u00b4\3\2\2\2\u0437\u0438\7e\2\2\u0438")
+ buf.write("\u0439\7j\2\2\u0439\u043a\7g\2\2\u043a\u043b\7e\2\2\u043b")
+ buf.write("\u043c\7m\2\2\u043c\u043d\7d\2\2\u043d\u043e\7q\2\2\u043e")
+ buf.write("\u043f\7z\2\2\u043f\u00b6\3\2\2\2\u0440\u0441\7g\2\2\u0441")
+ buf.write("\u0442\7p\2\2\u0442\u0443\7f\2\2\u0443\u0444\7e\2\2\u0444")
+ buf.write("\u0445\7j\2\2\u0445\u0446\7g\2\2\u0446\u0447\7e\2\2\u0447")
+ buf.write("\u0448\7m\2\2\u0448\u0449\7d\2\2\u0449\u044a\7q\2\2\u044a")
+ buf.write("\u044b\7z\2\2\u044b\u00b8\3\2\2\2\u044c\u044d\7p\2\2\u044d")
+ buf.write("\u044e\7w\2\2\u044e\u044f\7o\2\2\u044f\u0450\7g\2\2\u0450")
+ buf.write("\u0451\7t\2\2\u0451\u0452\7k\2\2\u0452\u0453\7e\2\2\u0453")
+ buf.write("\u00ba\3\2\2\2\u0454\u0455\7g\2\2\u0455\u0456\7p\2\2\u0456")
+ buf.write("\u0457\7f\2\2\u0457\u0458\7p\2\2\u0458\u0459\7w\2\2\u0459")
+ buf.write("\u045a\7o\2\2\u045a\u045b\7g\2\2\u045b\u045c\7t\2\2\u045c")
+ buf.write("\u045d\7k\2\2\u045d\u045e\7e\2\2\u045e\u00bc\3\2\2\2\u045f")
+ buf.write("\u0460\7o\2\2\u0460\u0461\7k\2\2\u0461\u0462\7p\2\2\u0462")
+ buf.write("\u0463\7k\2\2\u0463\u0464\7o\2\2\u0464\u0465\7w\2\2\u0465")
+ buf.write("\u0466\7o\2\2\u0466\u00be\3\2\2\2\u0467\u0468\7o\2\2\u0468")
+ buf.write("\u0469\7c\2\2\u0469\u046a\7z\2\2\u046a\u046b\7k\2\2\u046b")
+ buf.write("\u046c\7o\2\2\u046c\u046d\7w\2\2\u046d\u046e\7o\2\2\u046e")
+ buf.write("\u00c0\3\2\2\2\u046f\u0470\7u\2\2\u0470\u0471\7v\2\2\u0471")
+ buf.write("\u0472\7g\2\2\u0472\u0473\7r\2\2\u0473\u00c2\3\2\2\2\u0474")
+ buf.write("\u0475\7f\2\2\u0475\u0476\7g\2\2\u0476\u0477\7h\2\2\u0477")
+ buf.write("\u0478\7c\2\2\u0478\u0479\7w\2\2\u0479\u047a\7n\2\2\u047a")
+ buf.write("\u047b\7v\2\2\u047b\u00c4\3\2\2\2\u047c\u047d\7r\2\2\u047d")
+ buf.write("\u047e\7c\2\2\u047e\u047f\7u\2\2\u047f\u0480\7u\2\2\u0480")
+ buf.write("\u0481\7y\2\2\u0481\u0482\7q\2\2\u0482\u0483\7t\2\2\u0483")
+ buf.write("\u0484\7f\2\2\u0484\u00c6\3\2\2\2\u0485\u0486\7g\2\2\u0486")
+ buf.write("\u0487\7p\2\2\u0487\u0488\7f\2\2\u0488\u0489\7r\2\2\u0489")
+ buf.write("\u048a\7c\2\2\u048a\u048b\7u\2\2\u048b\u048c\7u\2\2\u048c")
+ buf.write("\u048d\7y\2\2\u048d\u048e\7q\2\2\u048e\u048f\7t\2\2\u048f")
+ buf.write("\u0490\7f\2\2\u0490\u00c8\3\2\2\2\u0491\u0492\7u\2\2\u0492")
+ buf.write("\u0493\7v\2\2\u0493\u0494\7t\2\2\u0494\u0495\7k\2\2\u0495")
+ buf.write("\u0496\7p\2\2\u0496\u0497\7i\2\2\u0497\u00ca\3\2\2\2\u0498")
+ buf.write("\u0499\7g\2\2\u0499\u049a\7p\2\2\u049a\u049b\7f\2\2\u049b")
+ buf.write("\u049c\7u\2\2\u049c\u049d\7v\2\2\u049d\u049e\7t\2\2\u049e")
+ buf.write("\u049f\7k\2\2\u049f\u04a0\7p\2\2\u04a0\u04a1\7i\2\2\u04a1")
+ buf.write("\u00cc\3\2\2\2\u04a2\u04a3\7o\2\2\u04a3\u04a4\7k\2\2\u04a4")
+ buf.write("\u04a5\7p\2\2\u04a5\u04a6\7u\2\2\u04a6\u04a7\7k\2\2\u04a7")
+ buf.write("\u04a8\7|\2\2\u04a8\u04a9\7g\2\2\u04a9\u00ce\3\2\2\2\u04aa")
+ buf.write("\u04ab\7o\2\2\u04ab\u04ac\7c\2\2\u04ac\u04ad\7z\2\2\u04ad")
+ buf.write("\u04ae\7u\2\2\u04ae\u04af\7k\2\2\u04af\u04b0\7|\2\2\u04b0")
+ buf.write("\u04b1\7g\2\2\u04b1\u00d0\3\2\2\2\u04b2\u04b3\7g\2\2\u04b3")
+ buf.write("\u04b4\7p\2\2\u04b4\u04b5\7e\2\2\u04b5\u04b6\7q\2\2\u04b6")
+ buf.write("\u04b7\7f\2\2\u04b7\u04b8\7k\2\2\u04b8\u04b9\7p\2\2\u04b9")
+ buf.write("\u04ba\7i\2\2\u04ba\u00d2\3\2\2\2\u04bb\u04bc\7u\2\2\u04bc")
+ buf.write("\u04bd\7w\2\2\u04bd\u04be\7r\2\2\u04be\u04bf\7r\2\2\u04bf")
+ buf.write("\u04c0\7t\2\2\u04c0\u04c1\7g\2\2\u04c1\u04c2\7u\2\2\u04c2")
+ buf.write("\u04c3\7u\2\2\u04c3\u04c4\7k\2\2\u04c4\u04c5\7h\2\2\u04c5")
+ buf.write("\u00d4\3\2\2\2\u04c6\u04c7\7f\2\2\u04c7\u04c8\7k\2\2\u04c8")
+ buf.write("\u04c9\7u\2\2\u04c9\u04ca\7c\2\2\u04ca\u04cb\7d\2\2\u04cb")
+ buf.write("\u04cc\7n\2\2\u04cc\u04cd\7g\2\2\u04cd\u04ce\7k\2\2\u04ce")
+ buf.write("\u04cf\7h\2\2\u04cf\u00d6\3\2\2\2\u04d0\u04d1\7j\2\2\u04d1")
+ buf.write("\u04d2\7k\2\2\u04d2\u04d3\7f\2\2\u04d3\u04d4\7f\2\2\u04d4")
+ buf.write("\u04d5\7g\2\2\u04d5\u04d6\7p\2\2\u04d6\u00d8\3\2\2\2\u04d7")
+ buf.write("\u04d8\7i\2\2\u04d8\u04d9\7q\2\2\u04d9\u04da\7v\2\2\u04da")
+ buf.write("\u04db\7q\2\2\u04db\u00da\3\2\2\2\u04dc\u04dd\7h\2\2\u04dd")
+ buf.write("\u04de\7q\2\2\u04de\u04df\7t\2\2\u04df\u04e0\7o\2\2\u04e0")
+ buf.write("\u04e1\7u\2\2\u04e1\u04e2\7g\2\2\u04e2\u04e3\7v\2\2\u04e3")
+ buf.write("\u04e4\7i\2\2\u04e4\u04e5\7w\2\2\u04e5\u04e6\7k\2\2\u04e6")
+ buf.write("\u04e7\7f\2\2\u04e7\u00dc\3\2\2\2\u04e8\u04e9\7k\2\2\u04e9")
+ buf.write("\u04ea\7p\2\2\u04ea\u04eb\7e\2\2\u04eb\u04ec\7q\2\2\u04ec")
+ buf.write("\u04ed\7p\2\2\u04ed\u04ee\7u\2\2\u04ee\u04ef\7k\2\2\u04ef")
+ buf.write("\u04f0\7u\2\2\u04f0\u04f1\7v\2\2\u04f1\u04f2\7g\2\2\u04f2")
+ buf.write("\u04f3\7p\2\2\u04f3\u04f4\7v\2\2\u04f4\u04f5\7k\2\2\u04f5")
+ buf.write("\u04f6\7h\2\2\u04f6\u00de\3\2\2\2\u04f7\u04f8\7y\2\2\u04f8")
+ buf.write("\u04f9\7c\2\2\u04f9\u04fa\7t\2\2\u04fa\u04fb\7p\2\2\u04fb")
+ buf.write("\u04fc\7k\2\2\u04fc\u04fd\7p\2\2\u04fd\u04fe\7i\2\2\u04fe")
+ buf.write("\u04ff\7k\2\2\u04ff\u0500\7h\2\2\u0500\u00e0\3\2\2\2\u0501")
+ buf.write("\u0502\7p\2\2\u0502\u0503\7q\2\2\u0503\u0504\7u\2\2\u0504")
+ buf.write("\u0505\7w\2\2\u0505\u0506\7d\2\2\u0506\u0507\7o\2\2\u0507")
+ buf.write("\u0508\7k\2\2\u0508\u0509\7v\2\2\u0509\u050a\7k\2\2\u050a")
+ buf.write("\u050b\7h\2\2\u050b\u00e2\3\2\2\2\u050c\u050d\7g\2\2\u050d")
+ buf.write("\u050e\7p\2\2\u050e\u050f\7f\2\2\u050f\u0510\7k\2\2\u0510")
+ buf.write("\u0511\7h\2\2\u0511\u00e4\3\2\2\2\u0512\u0513\7m\2\2\u0513")
+ buf.write("\u0514\7g\2\2\u0514\u0515\7{\2\2\u0515\u00e6\3\2\2\2\u0516")
+ buf.write("\u0517\7F\2\2\u0517\u0518\7G\2\2\u0518\u0519\7H\2\2\u0519")
+ buf.write("\u051a\7C\2\2\u051a\u051b\7W\2\2\u051b\u051c\7N\2\2\u051c")
+ buf.write("\u051d\7V\2\2\u051d\u00e8\3\2\2\2\u051e\u051f\7O\2\2\u051f")
+ buf.write("\u0520\7C\2\2\u0520\u0521\7P\2\2\u0521\u0522\7W\2\2\u0522")
+ buf.write("\u0523\7H\2\2\u0523\u0524\7C\2\2\u0524\u0525\7E\2\2\u0525")
+ buf.write("\u0526\7V\2\2\u0526\u0527\7W\2\2\u0527\u0528\7T\2\2\u0528")
+ buf.write("\u0529\7K\2\2\u0529\u052a\7P\2\2\u052a\u052b\7I\2\2\u052b")
+ buf.write("\u00ea\3\2\2\2\u052c\u052d\7E\2\2\u052d\u052e\7J\2\2\u052e")
+ buf.write("\u052f\7G\2\2\u052f\u0530\7E\2\2\u0530\u0531\7M\2\2\u0531")
+ buf.write("\u0532\7D\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7Z\2\2\u0534")
+ buf.write("\u0535\7a\2\2\u0535\u0536\7F\2\2\u0536\u0537\7G\2\2\u0537")
+ buf.write("\u0538\7H\2\2\u0538\u0539\7C\2\2\u0539\u053a\7W\2\2\u053a")
+ buf.write("\u053b\7N\2\2\u053b\u053c\7V\2\2\u053c\u00ec\3\2\2\2\u053d")
+ buf.write("\u053e\7E\2\2\u053e\u053f\7J\2\2\u053f\u0540\7G\2\2\u0540")
+ buf.write("\u0541\7E\2\2\u0541\u0542\7M\2\2\u0542\u0543\7D\2\2\u0543")
+ buf.write("\u0544\7Q\2\2\u0544\u0545\7Z\2\2\u0545\u0546\7a\2\2\u0546")
+ buf.write("\u0547\7F\2\2\u0547\u0548\7G\2\2\u0548\u0549\7H\2\2\u0549")
+ buf.write("\u054a\7C\2\2\u054a\u054b\7W\2\2\u054b\u054c\7N\2\2\u054c")
+ buf.write("\u054d\7V\2\2\u054d\u054e\7a\2\2\u054e\u054f\7O\2\2\u054f")
+ buf.write("\u0550\7H\2\2\u0550\u0551\7I\2\2\u0551\u00ee\3\2\2\2\u0552")
+ buf.write("\u0553\7K\2\2\u0553\u0554\7P\2\2\u0554\u0555\7V\2\2\u0555")
+ buf.write("\u0556\7G\2\2\u0556\u0557\7T\2\2\u0557\u0558\7C\2\2\u0558")
+ buf.write("\u0559\7E\2\2\u0559\u055a\7V\2\2\u055a\u055b\7K\2\2\u055b")
+ buf.write("\u055c\7X\2\2\u055c\u055d\7G\2\2\u055d\u00f0\3\2\2\2\u055e")
+ buf.write("\u055f\7P\2\2\u055f\u0560\7X\2\2\u0560\u0561\7a\2\2\u0561")
+ buf.write("\u0562\7C\2\2\u0562\u0563\7E\2\2\u0563\u0564\7E\2\2\u0564")
+ buf.write("\u0565\7G\2\2\u0565\u0566\7U\2\2\u0566\u0567\7U\2\2\u0567")
+ buf.write("\u00f2\3\2\2\2\u0568\u0569\7T\2\2\u0569\u056a\7G\2\2\u056a")
+ buf.write("\u056b\7U\2\2\u056b\u056c\7G\2\2\u056c\u056d\7V\2\2\u056d")
+ buf.write("\u056e\7a\2\2\u056e\u056f\7T\2\2\u056f\u0570\7G\2\2\u0570")
+ buf.write("\u0571\7S\2\2\u0571\u0572\7W\2\2\u0572\u0573\7K\2\2\u0573")
+ buf.write("\u0574\7T\2\2\u0574\u0575\7G\2\2\u0575\u0576\7F\2\2\u0576")
+ buf.write("\u00f4\3\2\2\2\u0577\u0578\7T\2\2\u0578\u0579\7G\2\2\u0579")
+ buf.write("\u057a\7E\2\2\u057a\u057b\7Q\2\2\u057b\u057c\7P\2\2\u057c")
+ buf.write("\u057d\7P\2\2\u057d\u057e\7G\2\2\u057e\u057f\7E\2\2\u057f")
+ buf.write("\u0580\7V\2\2\u0580\u0581\7a\2\2\u0581\u0582\7T\2\2\u0582")
+ buf.write("\u0583\7G\2\2\u0583\u0584\7S\2\2\u0584\u0585\7W\2\2\u0585")
+ buf.write("\u0586\7K\2\2\u0586\u0587\7T\2\2\u0587\u0588\7G\2\2\u0588")
+ buf.write("\u0589\7F\2\2\u0589\u00f6\3\2\2\2\u058a\u058b\7N\2\2\u058b")
+ buf.write("\u058c\7C\2\2\u058c\u058d\7V\2\2\u058d\u058e\7G\2\2\u058e")
+ buf.write("\u058f\7a\2\2\u058f\u0590\7E\2\2\u0590\u0591\7J\2\2\u0591")
+ buf.write("\u0592\7G\2\2\u0592\u0593\7E\2\2\u0593\u0594\7M\2\2\u0594")
+ buf.write("\u00f8\3\2\2\2\u0595\u0596\7T\2\2\u0596\u0597\7G\2\2\u0597")
+ buf.write("\u0598\7C\2\2\u0598\u0599\7F\2\2\u0599\u059a\7a\2\2\u059a")
+ buf.write("\u059b\7Q\2\2\u059b\u059c\7P\2\2\u059c\u059d\7N\2\2\u059d")
+ buf.write("\u059e\7[\2\2\u059e\u00fa\3\2\2\2\u059f\u05a0\7Q\2\2\u05a0")
+ buf.write("\u05a1\7R\2\2\u05a1\u05a2\7V\2\2\u05a2\u05a3\7K\2\2\u05a3")
+ buf.write("\u05a4\7Q\2\2\u05a4\u05a5\7P\2\2\u05a5\u05a6\7U\2\2\u05a6")
+ buf.write("\u05a7\7a\2\2\u05a7\u05a8\7Q\2\2\u05a8\u05a9\7P\2\2\u05a9")
+ buf.write("\u05aa\7N\2\2\u05aa\u05ab\7[\2\2\u05ab\u00fc\3\2\2\2\u05ac")
+ buf.write("\u05ad\7T\2\2\u05ad\u05ae\7G\2\2\u05ae\u05af\7U\2\2\u05af")
+ buf.write("\u05b0\7V\2\2\u05b0\u05b1\7a\2\2\u05b1\u05b2\7U\2\2\u05b2")
+ buf.write("\u05b3\7V\2\2\u05b3\u05b4\7[\2\2\u05b4\u05b5\7N\2\2\u05b5")
+ buf.write("\u05b6\7G\2\2\u05b6\u00fe\3\2\2\2\u05b7\u05b8\7e\2\2\u05b8")
+ buf.write("\u05b9\7n\2\2\u05b9\u05ba\7c\2\2\u05ba\u05bb\7u\2\2\u05bb")
+ buf.write("\u05bc\7u\2\2\u05bc\u0100\3\2\2\2\u05bd\u05be\7u\2\2\u05be")
+ buf.write("\u05bf\7w\2\2\u05bf\u05c0\7d\2\2\u05c0\u05c1\7e\2\2\u05c1")
+ buf.write("\u05c2\7n\2\2\u05c2\u05c3\7c\2\2\u05c3\u05c4\7u\2\2\u05c4")
+ buf.write("\u05c5\7u\2\2\u05c5\u0102\3\2\2\2\u05c6\u05c7\7e\2\2\u05c7")
+ buf.write("\u05c8\7n\2\2\u05c8\u05c9\7c\2\2\u05c9\u05ca\7u\2\2\u05ca")
+ buf.write("\u05cb\7u\2\2\u05cb\u05cc\7i\2\2\u05cc\u05cd\7w\2\2\u05cd")
+ buf.write("\u05ce\7k\2\2\u05ce\u05cf\7f\2\2\u05cf\u0104\3\2\2\2\u05d0")
+ buf.write("\u05d1\7v\2\2\u05d1\u05d2\7{\2\2\u05d2\u05d3\7r\2\2\u05d3")
+ buf.write("\u05d4\7g\2\2\u05d4\u05d5\7f\2\2\u05d5\u05d6\7g\2\2\u05d6")
+ buf.write("\u05d7\7h\2\2\u05d7\u0106\3\2\2\2\u05d8\u05d9\7t\2\2\u05d9")
+ buf.write("\u05da\7g\2\2\u05da\u05db\7u\2\2\u05db\u05dc\7v\2\2\u05dc")
+ buf.write("\u05dd\7q\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7g\2\2\u05df")
+ buf.write("\u0108\3\2\2\2\u05e0\u05e1\7u\2\2\u05e1\u05e2\7c\2\2\u05e2")
+ buf.write("\u05e3\7x\2\2\u05e3\u05e4\7g\2\2\u05e4\u010a\3\2\2\2\u05e5")
+ buf.write("\u05e6\7f\2\2\u05e6\u05e7\7g\2\2\u05e7\u05e8\7h\2\2\u05e8")
+ buf.write("\u05e9\7c\2\2\u05e9\u05ea\7w\2\2\u05ea\u05eb\7n\2\2\u05eb")
+ buf.write("\u05ec\7v\2\2\u05ec\u05ed\7u\2\2\u05ed\u010c\3\2\2\2\u05ee")
+ buf.write("\u05ef\7d\2\2\u05ef\u05f0\7c\2\2\u05f0\u05f1\7p\2\2\u05f1")
+ buf.write("\u05f2\7p\2\2\u05f2\u05f3\7g\2\2\u05f3\u05f4\7t\2\2\u05f4")
+ buf.write("\u010e\3\2\2\2\u05f5\u05f6\7c\2\2\u05f6\u05f7\7n\2\2\u05f7")
+ buf.write("\u05f8\7k\2\2\u05f8\u05f9\7i\2\2\u05f9\u05fa\7p\2\2\u05fa")
+ buf.write("\u0110\3\2\2\2\u05fb\u05fc\7n\2\2\u05fc\u05fd\7g\2\2\u05fd")
+ buf.write("\u05fe\7h\2\2\u05fe\u05ff\7v\2\2\u05ff\u0112\3\2\2\2\u0600")
+ buf.write("\u0601\7t\2\2\u0601\u0602\7k\2\2\u0602\u0603\7i\2\2\u0603")
+ buf.write("\u0604\7j\2\2\u0604\u0605\7v\2\2\u0605\u0114\3\2\2\2\u0606")
+ buf.write("\u0607\7e\2\2\u0607\u0608\7g\2\2\u0608\u0609\7p\2\2\u0609")
+ buf.write("\u060a\7v\2\2\u060a\u060b\7g\2\2\u060b\u060c\7t\2\2\u060c")
+ buf.write("\u0116\3\2\2\2\u060d\u060e\7n\2\2\u060e\u060f\7k\2\2\u060f")
+ buf.write("\u0610\7p\2\2\u0610\u0611\7g\2\2\u0611\u0118\3\2\2\2\u0612")
+ buf.write("\u0613\7p\2\2\u0613\u0614\7c\2\2\u0614\u0615\7o\2\2\u0615")
+ buf.write("\u0616\7g\2\2\u0616\u011a\3\2\2\2\u0617\u0618\7x\2\2\u0618")
+ buf.write("\u0619\7c\2\2\u0619\u061a\7t\2\2\u061a\u061b\7k\2\2\u061b")
+ buf.write("\u061c\7f\2\2\u061c\u011c\3\2\2\2\u061d\u061e\7s\2\2\u061e")
+ buf.write("\u061f\7w\2\2\u061f\u0620\7g\2\2\u0620\u0621\7u\2\2\u0621")
+ buf.write("\u0622\7v\2\2\u0622\u0623\7k\2\2\u0623\u0624\7q\2\2\u0624")
+ buf.write("\u0625\7p\2\2\u0625\u011e\3\2\2\2\u0626\u0627\7s\2\2\u0627")
+ buf.write("\u0628\7w\2\2\u0628\u0629\7g\2\2\u0629\u062a\7u\2\2\u062a")
+ buf.write("\u062b\7v\2\2\u062b\u062c\7k\2\2\u062c\u062d\7q\2\2\u062d")
+ buf.write("\u062e\7p\2\2\u062e\u062f\7k\2\2\u062f\u0630\7f\2\2\u0630")
+ buf.write("\u0120\3\2\2\2\u0631\u0632\7k\2\2\u0632\u0633\7o\2\2\u0633")
+ buf.write("\u0634\7c\2\2\u0634\u0635\7i\2\2\u0635\u0636\7g\2\2\u0636")
+ buf.write("\u0122\3\2\2\2\u0637\u0638\7n\2\2\u0638\u0639\7q\2\2\u0639")
+ buf.write("\u063a\7e\2\2\u063a\u063b\7m\2\2\u063b\u063c\7g\2\2\u063c")
+ buf.write("\u063d\7f\2\2\u063d\u0124\3\2\2\2\u063e\u063f\7t\2\2\u063f")
+ buf.write("\u0640\7w\2\2\u0640\u0641\7n\2\2\u0641\u0642\7g\2\2\u0642")
+ buf.write("\u0126\3\2\2\2\u0643\u0644\7g\2\2\u0644\u0645\7p\2\2\u0645")
+ buf.write("\u0646\7f\2\2\u0646\u0647\7t\2\2\u0647\u0648\7w\2\2\u0648")
+ buf.write("\u0649\7n\2\2\u0649\u064a\7g\2\2\u064a\u0128\3\2\2\2\u064b")
+ buf.write("\u064c\7x\2\2\u064c\u064d\7c\2\2\u064d\u064e\7n\2\2\u064e")
+ buf.write("\u064f\7w\2\2\u064f\u0650\7g\2\2\u0650\u012a\3\2\2\2\u0651")
+ buf.write("\u0652\7t\2\2\u0652\u0653\7g\2\2\u0653\u0654\7c\2\2\u0654")
+ buf.write("\u0655\7f\2\2\u0655\u012c\3\2\2\2\u0656\u0657\7y\2\2\u0657")
+ buf.write("\u0658\7t\2\2\u0658\u0659\7k\2\2\u0659\u065a\7v\2\2\u065a")
+ buf.write("\u065b\7g\2\2\u065b\u012e\3\2\2\2\u065c\u065d\7t\2\2\u065d")
+ buf.write("\u065e\7g\2\2\u065e\u065f\7u\2\2\u065f\u0660\7g\2\2\u0660")
+ buf.write("\u0661\7v\2\2\u0661\u0662\7d\2\2\u0662\u0663\7w\2\2\u0663")
+ buf.write("\u0664\7v\2\2\u0664\u0665\7v\2\2\u0665\u0666\7q\2\2\u0666")
+ buf.write("\u0667\7p\2\2\u0667\u0130\3\2\2\2\u0668\u0669\7g\2\2\u0669")
+ buf.write("\u066a\7p\2\2\u066a\u066b\7f\2\2\u066b\u066c\7t\2\2\u066c")
+ buf.write("\u066d\7g\2\2\u066d\u066e\7u\2\2\u066e\u066f\7g\2\2\u066f")
+ buf.write("\u0670\7v\2\2\u0670\u0671\7d\2\2\u0671\u0672\7w\2\2\u0672")
+ buf.write("\u0673\7v\2\2\u0673\u0674\7v\2\2\u0674\u0675\7q\2\2\u0675")
+ buf.write("\u0676\7p\2\2\u0676\u0132\3\2\2\2\u0677\u0678\7f\2\2\u0678")
+ buf.write("\u0679\7g\2\2\u0679\u067a\7h\2\2\u067a\u067b\7c\2\2\u067b")
+ buf.write("\u067c\7w\2\2\u067c\u067d\7n\2\2\u067d\u067e\7v\2\2\u067e")
+ buf.write("\u067f\7u\2\2\u067f\u0680\7v\2\2\u0680\u0681\7q\2\2\u0681")
+ buf.write("\u0682\7t\2\2\u0682\u0683\7g\2\2\u0683\u0134\3\2\2\2\u0684")
+ buf.write("\u0685\7c\2\2\u0685\u0686\7v\2\2\u0686\u0687\7v\2\2\u0687")
+ buf.write("\u0688\7t\2\2\u0688\u0689\7k\2\2\u0689\u068a\7d\2\2\u068a")
+ buf.write("\u068b\7w\2\2\u068b\u068c\7v\2\2\u068c\u068d\7g\2\2\u068d")
+ buf.write("\u0136\3\2\2\2\u068e\u068f\7x\2\2\u068f\u0690\7c\2\2\u0690")
+ buf.write("\u0691\7t\2\2\u0691\u0692\7u\2\2\u0692\u0693\7v\2\2\u0693")
+ buf.write("\u0694\7q\2\2\u0694\u0695\7t\2\2\u0695\u0696\7g\2\2\u0696")
+ buf.write("\u0138\3\2\2\2\u0697\u0698\7g\2\2\u0698\u0699\7h\2\2\u0699")
+ buf.write("\u069a\7k\2\2\u069a\u069b\7x\2\2\u069b\u069c\7c\2\2\u069c")
+ buf.write("\u069d\7t\2\2\u069d\u069e\7u\2\2\u069e\u069f\7v\2\2\u069f")
+ buf.write("\u06a0\7q\2\2\u06a0\u06a1\7t\2\2\u06a1\u06a2\7g\2\2\u06a2")
+ buf.write("\u013a\3\2\2\2\u06a3\u06a4\7x\2\2\u06a4\u06a5\7c\2\2\u06a5")
+ buf.write("\u06a6\7t\2\2\u06a6\u06a7\7u\2\2\u06a7\u06a8\7k\2\2\u06a8")
+ buf.write("\u06a9\7|\2\2\u06a9\u06aa\7g\2\2\u06aa\u013c\3\2\2\2\u06ab")
+ buf.write("\u06ac\7p\2\2\u06ac\u06ad\7c\2\2\u06ad\u06ae\7o\2\2\u06ae")
+ buf.write("\u06af\7g\2\2\u06af\u06b0\7x\2\2\u06b0\u06b1\7c\2\2\u06b1")
+ buf.write("\u06b2\7n\2\2\u06b2\u06b3\7w\2\2\u06b3\u06b4\7g\2\2\u06b4")
+ buf.write("\u06b5\7x\2\2\u06b5\u06b6\7c\2\2\u06b6\u06b7\7t\2\2\u06b7")
+ buf.write("\u06b8\7u\2\2\u06b8\u06b9\7v\2\2\u06b9\u06ba\7q\2\2\u06ba")
+ buf.write("\u06bb\7t\2\2\u06bb\u06bc\7g\2\2\u06bc\u013e\3\2\2\2\u06bd")
+ buf.write("\u06be\7c\2\2\u06be\u06bf\7e\2\2\u06bf\u06c0\7v\2\2\u06c0")
+ buf.write("\u06c1\7k\2\2\u06c1\u06c2\7q\2\2\u06c2\u06c3\7p\2\2\u06c3")
+ buf.write("\u0140\3\2\2\2\u06c4\u06c5\7e\2\2\u06c5\u06c6\7q\2\2\u06c6")
+ buf.write("\u06c7\7p\2\2\u06c7\u06c8\7h\2\2\u06c8\u06c9\7k\2\2\u06c9")
+ buf.write("\u06ca\7i\2\2\u06ca\u0142\3\2\2\2\u06cb\u06cc\7g\2\2\u06cc")
+ buf.write("\u06cd\7p\2\2\u06cd\u06ce\7f\2\2\u06ce\u06cf\7c\2\2\u06cf")
+ buf.write("\u06d0\7e\2\2\u06d0\u06d1\7v\2\2\u06d1\u06d2\7k\2\2\u06d2")
+ buf.write("\u06d3\7q\2\2\u06d3\u06d4\7p\2\2\u06d4\u0144\3\2\2\2\u06d5")
+ buf.write("\u06d6\7t\2\2\u06d6\u06d7\7g\2\2\u06d7\u06d8\7h\2\2\u06d8")
+ buf.write("\u06d9\7t\2\2\u06d9\u06da\7g\2\2\u06da\u06db\7u\2\2\u06db")
+ buf.write("\u06dc\7j\2\2\u06dc\u0146\3\2\2\2\u06dd\u06de\7k\2\2\u06de")
+ buf.write("\u06df\7p\2\2\u06df\u06e0\7v\2\2\u06e0\u06e1\7g\2\2\u06e1")
+ buf.write("\u06e2\7t\2\2\u06e2\u06e3\7x\2\2\u06e3\u06e4\7c\2\2\u06e4")
+ buf.write("\u06e5\7n\2\2\u06e5\u0148\3\2\2\2\u06e6\u06e7\7x\2\2\u06e7")
+ buf.write("\u06e8\7c\2\2\u06e8\u06e9\7t\2\2\u06e9\u06ea\7u\2\2\u06ea")
+ buf.write("\u06eb\7v\2\2\u06eb\u06ec\7q\2\2\u06ec\u06ed\7t\2\2\u06ed")
+ buf.write("\u06ee\7g\2\2\u06ee\u06ef\7f\2\2\u06ef\u06f0\7g\2\2\u06f0")
+ buf.write("\u06f1\7x\2\2\u06f1\u06f2\7k\2\2\u06f2\u06f3\7e\2\2\u06f3")
+ buf.write("\u06f4\7g\2\2\u06f4\u014a\3\2\2\2\u06f5\u06f6\7i\2\2\u06f6")
+ buf.write("\u06f7\7w\2\2\u06f7\u06f8\7k\2\2\u06f8\u06f9\7f\2\2\u06f9")
+ buf.write("\u06fa\7q\2\2\u06fa\u06fb\7r\2\2\u06fb\u014c\3\2\2\2\u06fc")
+ buf.write("\u06fd\7g\2\2\u06fd\u06fe\7p\2\2\u06fe\u06ff\7f\2\2\u06ff")
+ buf.write("\u0700\7i\2\2\u0700\u0701\7w\2\2\u0701\u0702\7k\2\2\u0702")
+ buf.write("\u0703\7f\2\2\u0703\u0704\7q\2\2\u0704\u0705\7r\2\2\u0705")
+ buf.write("\u014e\3\2\2\2\u0706\u0707\7f\2\2\u0707\u0708\7c\2\2\u0708")
+ buf.write("\u0709\7v\2\2\u0709\u070a\7c\2\2\u070a\u070b\7v\2\2\u070b")
+ buf.write("\u070c\7{\2\2\u070c\u070d\7r\2\2\u070d\u070e\7g\2\2\u070e")
+ buf.write("\u0150\3\2\2\2\u070f\u0710\7f\2\2\u0710\u0711\7c\2\2\u0711")
+ buf.write("\u0712\7v\2\2\u0712\u0713\7c\2\2\u0713\u0152\3\2\2\2\u0714")
+ buf.write("\u0715\7o\2\2\u0715\u0716\7q\2\2\u0716\u0717\7f\2\2\u0717")
+ buf.write("\u0718\7c\2\2\u0718\u0719\7n\2\2\u0719\u0154\3\2\2\2\u071a")
+ buf.write("\u071b\7P\2\2\u071b\u071c\7Q\2\2\u071c\u071d\7P\2\2\u071d")
+ buf.write("\u071e\7a\2\2\u071e\u071f\7F\2\2\u071f\u0720\7G\2\2\u0720")
+ buf.write("\u0721\7X\2\2\u0721\u0722\7K\2\2\u0722\u0723\7E\2\2\u0723")
+ buf.write("\u0724\7G\2\2\u0724\u0156\3\2\2\2\u0725\u0726\7F\2\2\u0726")
+ buf.write("\u0727\7K\2\2\u0727\u0728\7U\2\2\u0728\u0729\7M\2\2\u0729")
+ buf.write("\u072a\7a\2\2\u072a\u072b\7F\2\2\u072b\u072c\7G\2\2\u072c")
+ buf.write("\u072d\7X\2\2\u072d\u072e\7K\2\2\u072e\u072f\7E\2\2\u072f")
+ buf.write("\u0730\7G\2\2\u0730\u0158\3\2\2\2\u0731\u0732\7X\2\2\u0732")
+ buf.write("\u0733\7K\2\2\u0733\u0734\7F\2\2\u0734\u0735\7G\2\2\u0735")
+ buf.write("\u0736\7Q\2\2\u0736\u0737\7a\2\2\u0737\u0738\7F\2\2\u0738")
+ buf.write("\u0739\7G\2\2\u0739\u073a\7X\2\2\u073a\u073b\7K\2\2\u073b")
+ buf.write("\u073c\7E\2\2\u073c\u073d\7G\2\2\u073d\u015a\3\2\2\2\u073e")
+ buf.write("\u073f\7P\2\2\u073f\u0740\7G\2\2\u0740\u0741\7V\2\2\u0741")
+ buf.write("\u0742\7Y\2\2\u0742\u0743\7Q\2\2\u0743\u0744\7T\2\2\u0744")
+ buf.write("\u0745\7M\2\2\u0745\u0746\7a\2\2\u0746\u0747\7F\2\2\u0747")
+ buf.write("\u0748\7G\2\2\u0748\u0749\7X\2\2\u0749\u074a\7K\2\2\u074a")
+ buf.write("\u074b\7E\2\2\u074b\u074c\7G\2\2\u074c\u015c\3\2\2\2\u074d")
+ buf.write("\u074e\7K\2\2\u074e\u074f\7P\2\2\u074f\u0750\7R\2\2\u0750")
+ buf.write("\u0751\7W\2\2\u0751\u0752\7V\2\2\u0752\u0753\7a\2\2\u0753")
+ buf.write("\u0754\7F\2\2\u0754\u0755\7G\2\2\u0755\u0756\7X\2\2\u0756")
+ buf.write("\u0757\7K\2\2\u0757\u0758\7E\2\2\u0758\u0759\7G\2\2\u0759")
+ buf.write("\u015e\3\2\2\2\u075a\u075b\7Q\2\2\u075b\u075c\7P\2\2\u075c")
+ buf.write("\u075d\7D\2\2\u075d\u075e\7Q\2\2\u075e\u075f\7C\2\2\u075f")
+ buf.write("\u0760\7T\2\2\u0760\u0761\7F\2\2\u0761\u0762\7a\2\2\u0762")
+ buf.write("\u0763\7F\2\2\u0763\u0764\7G\2\2\u0764\u0765\7X\2\2\u0765")
+ buf.write("\u0766\7K\2\2\u0766\u0767\7E\2\2\u0767\u0768\7G\2\2\u0768")
+ buf.write("\u0160\3\2\2\2\u0769\u076a\7Q\2\2\u076a\u076b\7V\2\2\u076b")
+ buf.write("\u076c\7J\2\2\u076c\u076d\7G\2\2\u076d\u076e\7T\2\2\u076e")
+ buf.write("\u076f\7a\2\2\u076f\u0770\7F\2\2\u0770\u0771\7G\2\2\u0771")
+ buf.write("\u0772\7X\2\2\u0772\u0773\7K\2\2\u0773\u0774\7E\2\2\u0774")
+ buf.write("\u0775\7G\2\2\u0775\u0162\3\2\2\2\u0776\u0777\7U\2\2\u0777")
+ buf.write("\u0778\7G\2\2\u0778\u0779\7V\2\2\u0779\u077a\7W\2\2\u077a")
+ buf.write("\u077b\7R\2\2\u077b\u077c\7a\2\2\u077c\u077d\7C\2\2\u077d")
+ buf.write("\u077e\7R\2\2\u077e\u077f\7R\2\2\u077f\u0780\7N\2\2\u0780")
+ buf.write("\u0781\7K\2\2\u0781\u0782\7E\2\2\u0782\u0783\7C\2\2\u0783")
+ buf.write("\u0784\7V\2\2\u0784\u0785\7K\2\2\u0785\u0786\7Q\2\2\u0786")
+ buf.write("\u0787\7P\2\2\u0787\u0164\3\2\2\2\u0788\u0789\7I\2\2\u0789")
+ buf.write("\u078a\7G\2\2\u078a\u078b\7P\2\2\u078b\u078c\7G\2\2\u078c")
+ buf.write("\u078d\7T\2\2\u078d\u078e\7C\2\2\u078e\u078f\7N\2\2\u078f")
+ buf.write("\u0790\7a\2\2\u0790\u0791\7C\2\2\u0791\u0792\7R\2\2\u0792")
+ buf.write("\u0793\7R\2\2\u0793\u0794\7N\2\2\u0794\u0795\7K\2\2\u0795")
+ buf.write("\u0796\7E\2\2\u0796\u0797\7C\2\2\u0797\u0798\7V\2\2\u0798")
+ buf.write("\u0799\7K\2\2\u0799\u079a\7Q\2\2\u079a\u079b\7P\2\2\u079b")
+ buf.write("\u0166\3\2\2\2\u079c\u079d\7H\2\2\u079d\u079e\7T\2\2\u079e")
+ buf.write("\u079f\7Q\2\2\u079f\u07a0\7P\2\2\u07a0\u07a1\7V\2\2\u07a1")
+ buf.write("\u07a2\7a\2\2\u07a2\u07a3\7R\2\2\u07a3\u07a4\7C\2\2\u07a4")
+ buf.write("\u07a5\7I\2\2\u07a5\u07a6\7G\2\2\u07a6\u0168\3\2\2\2\u07a7")
+ buf.write("\u07a8\7U\2\2\u07a8\u07a9\7K\2\2\u07a9\u07aa\7P\2\2\u07aa")
+ buf.write("\u07ab\7I\2\2\u07ab\u07ac\7N\2\2\u07ac\u07ad\7G\2\2\u07ad")
+ buf.write("\u07ae\7a\2\2\u07ae\u07af\7W\2\2\u07af\u07b0\7U\2\2\u07b0")
+ buf.write("\u07b1\7G\2\2\u07b1\u016a\3\2\2\2\u07b2\u07b3\7[\2\2\u07b3")
+ buf.write("\u07b4\7G\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7T\2\2\u07b6")
+ buf.write("\u07b7\7a\2\2\u07b7\u07b8\7U\2\2\u07b8\u07b9\7W\2\2\u07b9")
+ buf.write("\u07ba\7R\2\2\u07ba\u07bb\7R\2\2\u07bb\u07bc\7T\2\2\u07bc")
+ buf.write("\u07bd\7G\2\2\u07bd\u07be\7U\2\2\u07be\u07bf\7U\2\2\u07bf")
+ buf.write("\u016c\3\2\2\2\u07c0\u07c1\7O\2\2\u07c1\u07c2\7Q\2\2\u07c2")
+ buf.write("\u07c3\7P\2\2\u07c3\u07c4\7V\2\2\u07c4\u07c5\7J\2\2\u07c5")
+ buf.write("\u07c6\7a\2\2\u07c6\u07c7\7U\2\2\u07c7\u07c8\7W\2\2\u07c8")
+ buf.write("\u07c9\7R\2\2\u07c9\u07ca\7R\2\2\u07ca\u07cb\7T\2\2\u07cb")
+ buf.write("\u07cc\7G\2\2\u07cc\u07cd\7U\2\2\u07cd\u07ce\7U\2\2\u07ce")
+ buf.write("\u016e\3\2\2\2\u07cf\u07d0\7F\2\2\u07d0\u07d1\7C\2\2\u07d1")
+ buf.write("\u07d2\7[\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d4\7U\2\2\u07d4")
+ buf.write("\u07d5\7W\2\2\u07d5\u07d6\7R\2\2\u07d6\u07d7\7R\2\2\u07d7")
+ buf.write("\u07d8\7T\2\2\u07d8\u07d9\7G\2\2\u07d9\u07da\7U\2\2\u07da")
+ buf.write("\u07db\7U\2\2\u07db\u0170\3\2\2\2\u07dc\u07dd\7J\2\2\u07dd")
+ buf.write("\u07de\7Q\2\2\u07de\u07df\7W\2\2\u07df\u07e0\7T\2\2\u07e0")
+ buf.write("\u07e1\7a\2\2\u07e1\u07e2\7U\2\2\u07e2\u07e3\7W\2\2\u07e3")
+ buf.write("\u07e4\7R\2\2\u07e4\u07e5\7R\2\2\u07e5\u07e6\7T\2\2\u07e6")
+ buf.write("\u07e7\7G\2\2\u07e7\u07e8\7U\2\2\u07e8\u07e9\7U\2\2\u07e9")
+ buf.write("\u0172\3\2\2\2\u07ea\u07eb\7O\2\2\u07eb\u07ec\7K\2\2\u07ec")
+ buf.write("\u07ed\7P\2\2\u07ed\u07ee\7W\2\2\u07ee\u07ef\7V\2\2\u07ef")
+ buf.write("\u07f0\7G\2\2\u07f0\u07f1\7a\2\2\u07f1\u07f2\7U\2\2\u07f2")
+ buf.write("\u07f3\7W\2\2\u07f3\u07f4\7R\2\2\u07f4\u07f5\7R\2\2\u07f5")
+ buf.write("\u07f6\7T\2\2\u07f6\u07f7\7G\2\2\u07f7\u07f8\7U\2\2\u07f8")
+ buf.write("\u07f9\7U\2\2\u07f9\u0174\3\2\2\2\u07fa\u07fb\7U\2\2\u07fb")
+ buf.write("\u07fc\7G\2\2\u07fc\u07fd\7E\2\2\u07fd\u07fe\7Q\2\2\u07fe")
+ buf.write("\u07ff\7P\2\2\u07ff\u0800\7F\2\2\u0800\u0801\7a\2\2\u0801")
+ buf.write("\u0802\7U\2\2\u0802\u0803\7W\2\2\u0803\u0804\7R\2\2\u0804")
+ buf.write("\u0805\7R\2\2\u0805\u0806\7T\2\2\u0806\u0807\7G\2\2\u0807")
+ buf.write("\u0808\7U\2\2\u0808\u0809\7U\2\2\u0809\u0176\3\2\2\2\u080a")
+ buf.write("\u080b\7U\2\2\u080b\u080c\7V\2\2\u080c\u080d\7Q\2\2\u080d")
+ buf.write("\u080e\7T\2\2\u080e\u080f\7C\2\2\u080f\u0810\7I\2\2\u0810")
+ buf.write("\u0811\7G\2\2\u0811\u0812\7a\2\2\u0812\u0813\7P\2\2\u0813")
+ buf.write("\u0814\7Q\2\2\u0814\u0815\7T\2\2\u0815\u0816\7O\2\2\u0816")
+ buf.write("\u0817\7C\2\2\u0817\u0818\7N\2\2\u0818\u0178\3\2\2\2\u0819")
+ buf.write("\u081a\7U\2\2\u081a\u081b\7V\2\2\u081b\u081c\7Q\2\2\u081c")
+ buf.write("\u081d\7T\2\2\u081d\u081e\7C\2\2\u081e\u081f\7I\2\2\u081f")
+ buf.write("\u0820\7G\2\2\u0820\u0821\7a\2\2\u0821\u0822\7V\2\2\u0822")
+ buf.write("\u0823\7K\2\2\u0823\u0824\7O\2\2\u0824\u0825\7G\2\2\u0825")
+ buf.write("\u017a\3\2\2\2\u0826\u0827\7U\2\2\u0827\u0828\7V\2\2\u0828")
+ buf.write("\u0829\7Q\2\2\u0829\u082a\7T\2\2\u082a\u082b\7C\2\2\u082b")
+ buf.write("\u082c\7I\2\2\u082c\u082d\7G\2\2\u082d\u082e\7a\2\2\u082e")
+ buf.write("\u082f\7Y\2\2\u082f\u0830\7C\2\2\u0830\u0831\7M\2\2\u0831")
+ buf.write("\u0832\7G\2\2\u0832\u0833\7W\2\2\u0833\u0834\7R\2\2\u0834")
+ buf.write("\u017c\3\2\2\2\u0835\u0836\7W\2\2\u0836\u0837\7P\2\2\u0837")
+ buf.write("\u0838\7K\2\2\u0838\u0839\7S\2\2\u0839\u083a\7W\2\2\u083a")
+ buf.write("\u083b\7G\2\2\u083b\u017e\3\2\2\2\u083c\u083d\7P\2\2\u083d")
+ buf.write("\u083e\7Q\2\2\u083e\u083f\7G\2\2\u083f\u0840\7O\2\2\u0840")
+ buf.write("\u0841\7R\2\2\u0841\u0842\7V\2\2\u0842\u0843\7[\2\2\u0843")
+ buf.write("\u0180\3\2\2\2\u0844\u0845\7e\2\2\u0845\u0846\7q\2\2\u0846")
+ buf.write("\u0847\7p\2\2\u0847\u0848\7f\2\2\u0848\u0182\3\2\2\2\u0849")
+ buf.write("\u084a\7h\2\2\u084a\u084b\7k\2\2\u084b\u084c\7p\2\2\u084c")
+ buf.write("\u084d\7f\2\2\u084d\u0184\3\2\2\2\u084e\u084f\7o\2\2\u084f")
+ buf.write("\u0850\7k\2\2\u0850\u0851\7f\2\2\u0851\u0186\3\2\2\2\u0852")
+ buf.write("\u0853\7v\2\2\u0853\u0854\7q\2\2\u0854\u0855\7m\2\2\u0855")
+ buf.write("\u0856\7g\2\2\u0856\u0857\7p\2\2\u0857\u0188\3\2\2\2\u0858")
+ buf.write("\u0859\7u\2\2\u0859\u085a\7r\2\2\u085a\u085b\7c\2\2\u085b")
+ buf.write("\u085c\7p\2\2\u085c\u018a\3\2\2\2\u085d\u085e\7f\2\2\u085e")
+ buf.write("\u085f\7w\2\2\u085f\u0860\7r\2\2\u0860\u018c\3\2\2\2\u0861")
+ buf.write("\u0862\7x\2\2\u0862\u0863\7c\2\2\u0863\u0864\7t\2\2\u0864")
+ buf.write("\u0865\7g\2\2\u0865\u0866\7s\2\2\u0866\u0867\7x\2\2\u0867")
+ buf.write("\u0868\7c\2\2\u0868\u0869\7n\2\2\u0869\u018e\3\2\2\2\u086a")
+ buf.write("\u086b\7x\2\2\u086b\u086c\7c\2\2\u086c\u086d\7t\2\2\u086d")
+ buf.write("\u0190\3\2\2\2\u086e\u086f\7k\2\2\u086f\u0870\7f\2\2\u0870")
+ buf.write("\u0871\7g\2\2\u0871\u0872\7s\2\2\u0872\u0873\7x\2\2\u0873")
+ buf.write("\u0874\7c\2\2\u0874\u0875\7n\2\2\u0875\u0192\3\2\2\2\u0876")
+ buf.write("\u0877\7k\2\2\u0877\u0878\7f\2\2\u0878\u0879\7g\2\2\u0879")
+ buf.write("\u087a\7s\2\2\u087a\u087b\7k\2\2\u087b\u087c\7f\2\2\u087c")
+ buf.write("\u0194\3\2\2\2\u087d\u087e\7k\2\2\u087e\u087f\7f\2\2\u087f")
+ buf.write("\u0880\7g\2\2\u0880\u0881\7s\2\2\u0881\u0882\7x\2\2\u0882")
+ buf.write("\u0883\7c\2\2\u0883\u0884\7n\2\2\u0884\u0885\7n\2\2\u0885")
+ buf.write("\u0886\7k\2\2\u0886\u0887\7u\2\2\u0887\u0888\7v\2\2\u0888")
+ buf.write("\u0196\3\2\2\2\u0889\u088a\7s\2\2\u088a\u088b\7w\2\2\u088b")
+ buf.write("\u088c\7g\2\2\u088c\u088d\7u\2\2\u088d\u088e\7v\2\2\u088e")
+ buf.write("\u088f\7k\2\2\u088f\u0890\7q\2\2\u0890\u0891\7p\2\2\u0891")
+ buf.write("\u0892\7t\2\2\u0892\u0893\7g\2\2\u0893\u0894\7h\2\2\u0894")
+ buf.write("\u0198\3\2\2\2\u0895\u0896\7t\2\2\u0896\u0897\7w\2\2\u0897")
+ buf.write("\u0898\7n\2\2\u0898\u0899\7g\2\2\u0899\u089a\7t\2\2\u089a")
+ buf.write("\u089b\7g\2\2\u089b\u089c\7h\2\2\u089c\u019a\3\2\2\2\u089d")
+ buf.write("\u089e\7u\2\2\u089e\u089f\7v\2\2\u089f\u08a0\7t\2\2\u08a0")
+ buf.write("\u08a1\7k\2\2\u08a1\u08a2\7p\2\2\u08a2\u08a3\7i\2\2\u08a3")
+ buf.write("\u08a4\7t\2\2\u08a4\u08a5\7g\2\2\u08a5\u08a6\7h\2\2\u08a6")
+ buf.write("\u019c\3\2\2\2\u08a7\u08a8\7r\2\2\u08a8\u08a9\7w\2\2\u08a9")
+ buf.write("\u08aa\7u\2\2\u08aa\u08ab\7j\2\2\u08ab\u08ac\7v\2\2\u08ac")
+ buf.write("\u08ad\7j\2\2\u08ad\u08ae\7k\2\2\u08ae\u08af\7u\2\2\u08af")
+ buf.write("\u019e\3\2\2\2\u08b0\u08b1\7u\2\2\u08b1\u08b2\7g\2\2\u08b2")
+ buf.write("\u08b3\7e\2\2\u08b3\u08b4\7w\2\2\u08b4\u08b5\7t\2\2\u08b5")
+ buf.write("\u08b6\7k\2\2\u08b6\u08b7\7v\2\2\u08b7\u08b8\7{\2\2\u08b8")
+ buf.write("\u01a0\3\2\2\2\u08b9\u08ba\7i\2\2\u08ba\u08bb\7g\2\2\u08bb")
+ buf.write("\u08bc\7v\2\2\u08bc\u01a2\3\2\2\2\u08bd\u08be\7V\2\2\u08be")
+ buf.write("\u08bf\7T\2\2\u08bf\u08c0\7W\2\2\u08c0\u08c1\7G\2\2\u08c1")
+ buf.write("\u01a4\3\2\2\2\u08c2\u08c3\7H\2\2\u08c3\u08c4\7C\2\2\u08c4")
+ buf.write("\u08c5\7N\2\2\u08c5\u08c6\7U\2\2\u08c6\u08c7\7G\2\2\u08c7")
+ buf.write("\u01a6\3\2\2\2\u08c8\u08c9\7Q\2\2\u08c9\u08ca\7P\2\2\u08ca")
+ buf.write("\u08cb\7G\2\2\u08cb\u01a8\3\2\2\2\u08cc\u08cd\7Q\2\2\u08cd")
+ buf.write("\u08ce\7P\2\2\u08ce\u08cf\7G\2\2\u08cf\u08d0\7U\2\2\u08d0")
+ buf.write("\u01aa\3\2\2\2\u08d1\u08d2\7\\\2\2\u08d2\u08d3\7G\2\2")
+ buf.write("\u08d3\u08d4\7T\2\2\u08d4\u08d5\7Q\2\2\u08d5\u01ac\3\2")
+ buf.write("\2\2\u08d6\u08d7\7W\2\2\u08d7\u08d8\7P\2\2\u08d8\u08d9")
+ buf.write("\7F\2\2\u08d9\u08da\7G\2\2\u08da\u08db\7H\2\2\u08db\u08dc")
+ buf.write("\7K\2\2\u08dc\u08dd\7P\2\2\u08dd\u08de\7G\2\2\u08de\u08df")
+ buf.write("\7F\2\2\u08df\u01ae\3\2\2\2\u08e0\u08e1\7X\2\2\u08e1\u08e2")
+ buf.write("\7G\2\2\u08e2\u08e3\7T\2\2\u08e3\u08e4\7U\2\2\u08e4\u08e5")
+ buf.write("\7K\2\2\u08e5\u08e6\7Q\2\2\u08e6\u08e7\7P\2\2\u08e7\u01b0")
+ buf.write("\3\2\2\2\u08e8\u08e9\7n\2\2\u08e9\u08ea\7g\2\2\u08ea\u08eb")
+ buf.write("\7p\2\2\u08eb\u08ec\7i\2\2\u08ec\u08ed\7v\2\2\u08ed\u08ee")
+ buf.write("\7j\2\2\u08ee\u01b2\3\2\2\2\u08ef\u08f0\7C\2\2\u08f0\u08f1")
+ buf.write("\7P\2\2\u08f1\u08f2\7F\2\2\u08f2\u01b4\3\2\2\2\u08f3\u08f4")
+ buf.write("\7Q\2\2\u08f4\u08f5\7T\2\2\u08f5\u01b6\3\2\2\2\u08f6\u08f7")
+ buf.write("\7P\2\2\u08f7\u08f8\7Q\2\2\u08f8\u08f9\7V\2\2\u08f9\u01b8")
+ buf.write("\3\2\2\2\u08fa\u08fb\7u\2\2\u08fb\u08fc\7g\2\2\u08fc\u08fd")
+ buf.write("\7v\2\2\u08fd\u01ba\3\2\2\2\u08fe\u08ff\7\u0080\2\2\u08ff")
+ buf.write("\u01bc\3\2\2\2\u0900\u0901\7d\2\2\u0901\u0902\7q\2\2\u0902")
+ buf.write("\u0903\7q\2\2\u0903\u0904\7n\2\2\u0904\u0905\7x\2\2\u0905")
+ buf.write("\u0906\7c\2\2\u0906\u0907\7n\2\2\u0907\u01be\3\2\2\2\u0908")
+ buf.write("\u0909\7u\2\2\u0909\u090a\7v\2\2\u090a\u090b\7t\2\2\u090b")
+ buf.write("\u090c\7k\2\2\u090c\u090d\7p\2\2\u090d\u090e\7i\2\2\u090e")
+ buf.write("\u090f\7x\2\2\u090f\u0910\7c\2\2\u0910\u0911\7n\2\2\u0911")
+ buf.write("\u01c0\3\2\2\2\u0912\u0913\7w\2\2\u0913\u0914\7p\2\2\u0914")
+ buf.write("\u0915\7k\2\2\u0915\u0916\7p\2\2\u0916\u0917\7v\2\2\u0917")
+ buf.write("\u0918\7x\2\2\u0918\u0919\7c\2\2\u0919\u091a\7n\2\2\u091a")
+ buf.write("\u01c2\3\2\2\2\u091b\u091c\7v\2\2\u091c\u091d\7q\2\2\u091d")
+ buf.write("\u091e\7w\2\2\u091e\u091f\7r\2\2\u091f\u0920\7r\2\2\u0920")
+ buf.write("\u0921\7g\2\2\u0921\u0922\7t\2\2\u0922\u01c4\3\2\2\2\u0923")
+ buf.write("\u0924\7v\2\2\u0924\u0925\7q\2\2\u0925\u0926\7n\2\2\u0926")
+ buf.write("\u0927\7q\2\2\u0927\u0928\7y\2\2\u0928\u0929\7g\2\2\u0929")
+ buf.write("\u092a\7t\2\2\u092a\u01c6\3\2\2\2\u092b\u092c\7o\2\2\u092c")
+ buf.write("\u092d\7c\2\2\u092d\u092e\7v\2\2\u092e\u092f\7e\2\2\u092f")
+ buf.write("\u0930\7j\2\2\u0930\u01c8\3\2\2\2\u0931\u0932\7o\2\2\u0932")
+ buf.write("\u0933\7c\2\2\u0933\u0934\7v\2\2\u0934\u0935\7e\2\2\u0935")
+ buf.write("\u0936\7j\2\2\u0936\u0937\7\64\2\2\u0937\u01ca\3\2\2\2")
+ buf.write("\u0938\u0939\7e\2\2\u0939\u093a\7c\2\2\u093a\u093b\7v")
+ buf.write("\2\2\u093b\u093c\7g\2\2\u093c\u093d\7p\2\2\u093d\u093e")
+ buf.write("\7c\2\2\u093e\u093f\7v\2\2\u093f\u0940\7g\2\2\u0940\u01cc")
+ buf.write("\3\2\2\2\u0941\u0942\7s\2\2\u0942\u0943\7w\2\2\u0943\u0944")
+ buf.write("\7g\2\2\u0944\u0945\7u\2\2\u0945\u0946\7v\2\2\u0946\u0947")
+ buf.write("\7k\2\2\u0947\u0948\7q\2\2\u0948\u0949\7p\2\2\u0949\u094a")
+ buf.write("\7t\2\2\u094a\u094b\7g\2\2\u094b\u094c\7h\2\2\u094c\u094d")
+ buf.write("\7x\2\2\u094d\u094e\7c\2\2\u094e\u094f\7n\2\2\u094f\u01ce")
+ buf.write("\3\2\2\2\u0950\u0951\7u\2\2\u0951\u0952\7v\2\2\u0952\u0953")
+ buf.write("\7t\2\2\u0953\u0954\7k\2\2\u0954\u0955\7p\2\2\u0955\u0956")
+ buf.write("\7i\2\2\u0956\u0957\7t\2\2\u0957\u0958\7g\2\2\u0958\u0959")
+ buf.write("\7h\2\2\u0959\u095a\7x\2\2\u095a\u095b\7c\2\2\u095b\u095c")
+ buf.write("\7n\2\2\u095c\u01d0\3\2\2\2\u095d\u095e\7o\2\2\u095e\u095f")
+ buf.write("\7c\2\2\u095f\u0960\7r\2\2\u0960\u01d2\3\2\2\2\u0961\u0962")
+ buf.write("\7t\2\2\u0962\u0963\7g\2\2\u0963\u0964\7h\2\2\u0964\u0965")
+ buf.write("\7t\2\2\u0965\u0966\7g\2\2\u0966\u0967\7u\2\2\u0967\u0968")
+ buf.write("\7j\2\2\u0968\u0969\7i\2\2\u0969\u096a\7w\2\2\u096a\u096b")
+ buf.write("\7k\2\2\u096b\u096c\7f\2\2\u096c\u01d4\3\2\2\2\u096d\u096e")
+ buf.write("\7U\2\2\u096e\u096f\7V\2\2\u096f\u0970\7T\2\2\u0970\u0971")
+ buf.write("\7K\2\2\u0971\u0972\7P\2\2\u0972\u0973\7I\2\2\u0973\u0974")
+ buf.write("\7a\2\2\u0974\u0975\7V\2\2\u0975\u0976\7Q\2\2\u0976\u0977")
+ buf.write("\7M\2\2\u0977\u0978\7G\2\2\u0978\u0979\7P\2\2\u0979\u01d6")
+ buf.write("\3\2\2\2\u097a\u097b\7Q\2\2\u097b\u097c\7R\2\2\u097c\u097d")
+ buf.write("\7V\2\2\u097d\u097e\7K\2\2\u097e\u097f\7Q\2\2\u097f\u0980")
+ buf.write("\7P\2\2\u0980\u0981\7a\2\2\u0981\u0982\7F\2\2\u0982\u0983")
+ buf.write("\7G\2\2\u0983\u0984\7H\2\2\u0984\u0985\7C\2\2\u0985\u0986")
+ buf.write("\7W\2\2\u0986\u0987\7N\2\2\u0987\u0988\7V\2\2\u0988\u01d8")
+ buf.write("\3\2\2\2\u0989\u098a\7Q\2\2\u098a\u098b\7R\2\2\u098b\u098c")
+ buf.write("\7V\2\2\u098c\u098d\7K\2\2\u098d\u098e\7Q\2\2\u098e\u098f")
+ buf.write("\7P\2\2\u098f\u0990\7a\2\2\u0990\u0991\7F\2\2\u0991\u0992")
+ buf.write("\7G\2\2\u0992\u0993\7H\2\2\u0993\u0994\7C\2\2\u0994\u0995")
+ buf.write("\7W\2\2\u0995\u0996\7N\2\2\u0996\u0997\7V\2\2\u0997\u0998")
+ buf.write("\7a\2\2\u0998\u0999\7O\2\2\u0999\u099a\7H\2\2\u099a\u099b")
+ buf.write("\7I\2\2\u099b\u01da\3\2\2\2\u099c\u099d\7P\2\2\u099d\u099e")
+ buf.write("\7W\2\2\u099e\u099f\7O\2\2\u099f\u09a0\7G\2\2\u09a0\u09a1")
+ buf.write("\7T\2\2\u09a1\u09a2\7K\2\2\u09a2\u09a3\7E\2\2\u09a3\u09a4")
+ buf.write("\7a\2\2\u09a4\u09a5\7U\2\2\u09a5\u09a6\7K\2\2\u09a6\u09a7")
+ buf.write("\7\\\2\2\u09a7\u09a8\7G\2\2\u09a8\u09a9\7a\2\2\u09a9\u09aa")
+ buf.write("\7\63\2\2\u09aa\u01dc\3\2\2\2\u09ab\u09ac\7P\2\2\u09ac")
+ buf.write("\u09ad\7W\2\2\u09ad\u09ae\7O\2\2\u09ae\u09af\7G\2\2\u09af")
+ buf.write("\u09b0\7T\2\2\u09b0\u09b1\7K\2\2\u09b1\u09b2\7E\2\2\u09b2")
+ buf.write("\u09b3\7a\2\2\u09b3\u09b4\7U\2\2\u09b4\u09b5\7K\2\2\u09b5")
+ buf.write("\u09b6\7\\\2\2\u09b6\u09b7\7G\2\2\u09b7\u09b8\7a\2\2\u09b8")
+ buf.write("\u09b9\7\64\2\2\u09b9\u01de\3\2\2\2\u09ba\u09bb\7P\2\2")
+ buf.write("\u09bb\u09bc\7W\2\2\u09bc\u09bd\7O\2\2\u09bd\u09be\7G")
+ buf.write("\2\2\u09be\u09bf\7T\2\2\u09bf\u09c0\7K\2\2\u09c0\u09c1")
+ buf.write("\7E\2\2\u09c1\u09c2\7a\2\2\u09c2\u09c3\7U\2\2\u09c3\u09c4")
+ buf.write("\7K\2\2\u09c4\u09c5\7\\\2\2\u09c5\u09c6\7G\2\2\u09c6\u09c7")
+ buf.write("\7a\2\2\u09c7\u09c8\7\66\2\2\u09c8\u01e0\3\2\2\2\u09c9")
+ buf.write("\u09ca\7P\2\2\u09ca\u09cb\7W\2\2\u09cb\u09cc\7O\2\2\u09cc")
+ buf.write("\u09cd\7G\2\2\u09cd\u09ce\7T\2\2\u09ce\u09cf\7K\2\2\u09cf")
+ buf.write("\u09d0\7E\2\2\u09d0\u09d1\7a\2\2\u09d1\u09d2\7U\2\2\u09d2")
+ buf.write("\u09d3\7K\2\2\u09d3\u09d4\7\\\2\2\u09d4\u09d5\7G\2\2\u09d5")
+ buf.write("\u09d6\7a\2\2\u09d6\u09d7\7:\2\2\u09d7\u01e2\3\2\2\2\u09d8")
+ buf.write("\u09d9\7F\2\2\u09d9\u09da\7K\2\2\u09da\u09db\7U\2\2\u09db")
+ buf.write("\u09dc\7R\2\2\u09dc\u09dd\7N\2\2\u09dd\u09de\7C\2\2\u09de")
+ buf.write("\u09df\7[\2\2\u09df\u09e0\7a\2\2\u09e0\u09e1\7K\2\2\u09e1")
+ buf.write("\u09e2\7P\2\2\u09e2\u09e3\7V\2\2\u09e3\u09e4\7a\2\2\u09e4")
+ buf.write("\u09e5\7F\2\2\u09e5\u09e6\7G\2\2\u09e6\u09e7\7E\2\2\u09e7")
+ buf.write("\u01e4\3\2\2\2\u09e8\u09e9\7F\2\2\u09e9\u09ea\7K\2\2\u09ea")
+ buf.write("\u09eb\7U\2\2\u09eb\u09ec\7R\2\2\u09ec\u09ed\7N\2\2\u09ed")
+ buf.write("\u09ee\7C\2\2\u09ee\u09ef\7[\2\2\u09ef\u09f0\7a\2\2\u09f0")
+ buf.write("\u09f1\7W\2\2\u09f1\u09f2\7K\2\2\u09f2\u09f3\7P\2\2\u09f3")
+ buf.write("\u09f4\7V\2\2\u09f4\u09f5\7a\2\2\u09f5\u09f6\7F\2\2\u09f6")
+ buf.write("\u09f7\7G\2\2\u09f7\u09f8\7E\2\2\u09f8\u01e6\3\2\2\2\u09f9")
+ buf.write("\u09fa\7F\2\2\u09fa\u09fb\7K\2\2\u09fb\u09fc\7U\2\2\u09fc")
+ buf.write("\u09fd\7R\2\2\u09fd\u09fe\7N\2\2\u09fe\u09ff\7C\2\2\u09ff")
+ buf.write("\u0a00\7[\2\2\u0a00\u0a01\7a\2\2\u0a01\u0a02\7W\2\2\u0a02")
+ buf.write("\u0a03\7K\2\2\u0a03\u0a04\7P\2\2\u0a04\u0a05\7V\2\2\u0a05")
+ buf.write("\u0a06\7a\2\2\u0a06\u0a07\7J\2\2\u0a07\u0a08\7G\2\2\u0a08")
+ buf.write("\u0a09\7Z\2\2\u0a09\u01e8\3\2\2\2\u0a0a\u0a0b\7K\2\2\u0a0b")
+ buf.write("\u0a0c\7P\2\2\u0a0c\u0a0d\7U\2\2\u0a0d\u0a0e\7G\2\2\u0a0e")
+ buf.write("\u0a0f\7P\2\2\u0a0f\u0a10\7U\2\2\u0a10\u0a11\7K\2\2\u0a11")
+ buf.write("\u0a12\7V\2\2\u0a12\u0a13\7K\2\2\u0a13\u0a14\7X\2\2\u0a14")
+ buf.write("\u0a15\7G\2\2\u0a15\u01ea\3\2\2\2\u0a16\u0a17\7U\2\2\u0a17")
+ buf.write("\u0a18\7G\2\2\u0a18\u0a19\7P\2\2\u0a19\u0a1a\7U\2\2\u0a1a")
+ buf.write("\u0a1b\7K\2\2\u0a1b\u0a1c\7V\2\2\u0a1c\u0a1d\7K\2\2\u0a1d")
+ buf.write("\u0a1e\7X\2\2\u0a1e\u0a1f\7G\2\2\u0a1f\u01ec\3\2\2\2\u0a20")
+ buf.write("\u0a21\7N\2\2\u0a21\u0a22\7C\2\2\u0a22\u0a23\7U\2\2\u0a23")
+ buf.write("\u0a24\7V\2\2\u0a24\u0a25\7a\2\2\u0a25\u0a26\7P\2\2\u0a26")
+ buf.write("\u0a27\7Q\2\2\u0a27\u0a28\7P\2\2\u0a28\u0a29\7a\2\2\u0a29")
+ buf.write("\u0a2a\7O\2\2\u0a2a\u0a2b\7C\2\2\u0a2b\u0a2c\7V\2\2\u0a2c")
+ buf.write("\u0a2d\7E\2\2\u0a2d\u0a2e\7J\2\2\u0a2e\u01ee\3\2\2\2\u0a2f")
+ buf.write("\u0a30\7H\2\2\u0a30\u0a31\7K\2\2\u0a31\u0a32\7T\2\2\u0a32")
+ buf.write("\u0a33\7U\2\2\u0a33\u0a34\7V\2\2\u0a34\u0a35\7a\2\2\u0a35")
+ buf.write("\u0a36\7P\2\2\u0a36\u0a37\7Q\2\2\u0a37\u0a38\7P\2\2\u0a38")
+ buf.write("\u0a39\7a\2\2\u0a39\u0a3a\7O\2\2\u0a3a\u0a3b\7C\2\2\u0a3b")
+ buf.write("\u0a3c\7V\2\2\u0a3c\u0a3d\7E\2\2\u0a3d\u0a3e\7J\2\2\u0a3e")
+ buf.write("\u01f0\3\2\2\2\u0a3f\u0a40\7\62\2\2\u0a40\u0a41\7z\2\2")
+ buf.write("\u0a41\u0a43\3\2\2\2\u0a42\u0a44\t\2\2\2\u0a43\u0a42\3")
+ buf.write("\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46")
+ buf.write("\3\2\2\2\u0a46\u0a4d\3\2\2\2\u0a47\u0a49\t\3\2\2\u0a48")
+ buf.write("\u0a47\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a48\3\2\2\2")
+ buf.write("\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4d\3\2\2\2\u0a4c\u0a3f\3")
+ buf.write("\2\2\2\u0a4c\u0a48\3\2\2\2\u0a4d\u01f2\3\2\2\2\u0a4e\u0a52")
+ buf.write("\t\4\2\2\u0a4f\u0a51\t\5\2\2\u0a50\u0a4f\3\2\2\2\u0a51")
+ buf.write("\u0a54\3\2\2\2\u0a52\u0a50\3\2\2\2\u0a52\u0a53\3\2\2\2")
+ buf.write("\u0a53\u01f4\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a55\u0a57\7")
+ buf.write("%\2\2\u0a56\u0a58\5\u01fb\u00fe\2\u0a57\u0a56\3\2\2\2")
+ buf.write("\u0a57\u0a58\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\7")
+ buf.write("f\2\2\u0a5a\u0a5b\7g\2\2\u0a5b\u0a5c\7h\2\2\u0a5c\u0a5d")
+ buf.write("\7k\2\2\u0a5d\u0a5e\7p\2\2\u0a5e\u0a5f\7g\2\2\u0a5f\u0a63")
+ buf.write("\3\2\2\2\u0a60\u0a62\n\6\2\2\u0a61\u0a60\3\2\2\2\u0a62")
+ buf.write("\u0a65\3\2\2\2\u0a63\u0a61\3\2\2\2\u0a63\u0a64\3\2\2\2")
+ buf.write("\u0a64\u0a66\3\2\2\2\u0a65\u0a63\3\2\2\2\u0a66\u0a67\b")
+ buf.write("\u00fb\2\2\u0a67\u01f6\3\2\2\2\u0a68\u0a6a\7%\2\2\u0a69")
+ buf.write("\u0a6b\5\u01fb\u00fe\2\u0a6a\u0a69\3\2\2\2\u0a6a\u0a6b")
+ buf.write("\3\2\2\2\u0a6b\u0a6c\3\2\2\2\u0a6c\u0a6d\7n\2\2\u0a6d")
+ buf.write("\u0a6e\7k\2\2\u0a6e\u0a6f\7p\2\2\u0a6f\u0a70\7g\2\2\u0a70")
+ buf.write("\u0a74\3\2\2\2\u0a71\u0a73\n\6\2\2\u0a72\u0a71\3\2\2\2")
+ buf.write("\u0a73\u0a76\3\2\2\2\u0a74\u0a72\3\2\2\2\u0a74\u0a75\3")
+ buf.write("\2\2\2\u0a75\u0a77\3\2\2\2\u0a76\u0a74\3\2\2\2\u0a77\u0a78")
+ buf.write("\b\u00fc\2\2\u0a78\u01f8\3\2\2\2\u0a79\u0a7b\7%\2\2\u0a7a")
+ buf.write("\u0a7c\5\u01fb\u00fe\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c")
+ buf.write("\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7e\7k\2\2\u0a7e")
+ buf.write("\u0a7f\7p\2\2\u0a7f\u0a80\7e\2\2\u0a80\u0a81\7n\2\2\u0a81")
+ buf.write("\u0a82\7w\2\2\u0a82\u0a83\7f\2\2\u0a83\u0a84\7g\2\2\u0a84")
+ buf.write("\u0a88\3\2\2\2\u0a85\u0a87\n\6\2\2\u0a86\u0a85\3\2\2\2")
+ buf.write("\u0a87\u0a8a\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a88\u0a89\3")
+ buf.write("\2\2\2\u0a89\u0a8b\3\2\2\2\u0a8a\u0a88\3\2\2\2\u0a8b\u0a8c")
+ buf.write("\b\u00fd\2\2\u0a8c\u01fa\3\2\2\2\u0a8d\u0a8f\t\7\2\2\u0a8e")
+ buf.write("\u0a8d\3\2\2\2\u0a8f\u0a90\3\2\2\2\u0a90\u0a8e\3\2\2\2")
+ buf.write("\u0a90\u0a91\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a93\b")
+ buf.write("\u00fe\2\2\u0a93\u01fc\3\2\2\2\u0a94\u0a96\7\17\2\2\u0a95")
+ buf.write("\u0a97\7\f\2\2\u0a96\u0a95\3\2\2\2\u0a96\u0a97\3\2\2\2")
+ buf.write("\u0a97\u0a9a\3\2\2\2\u0a98\u0a9a\7\f\2\2\u0a99\u0a94\3")
+ buf.write("\2\2\2\u0a99\u0a98\3\2\2\2\u0a9a\u0a9b\3\2\2\2\u0a9b\u0a9c")
+ buf.write("\b\u00ff\2\2\u0a9c\u01fe\3\2\2\2\u0a9d\u0a9e\7\61\2\2")
+ buf.write("\u0a9e\u0a9f\7\61\2\2\u0a9f\u0aa3\3\2\2\2\u0aa0\u0aa2")
+ buf.write("\n\b\2\2\u0aa1\u0aa0\3\2\2\2\u0aa2\u0aa5\3\2\2\2\u0aa3")
+ buf.write("\u0aa1\3\2\2\2\u0aa3\u0aa4\3\2\2\2\u0aa4\u0aa6\3\2\2\2")
+ buf.write("\u0aa5\u0aa3\3\2\2\2\u0aa6\u0aa7\b\u0100\2\2\u0aa7\u0200")
+ buf.write("\3\2\2\2\u0aa8\u0aa9\7g\2\2\u0aa9\u0aaa\7z\2\2\u0aaa\u0aab")
+ buf.write("\7v\2\2\u0aab\u0aac\7g\2\2\u0aac\u0aad\7t\2\2\u0aad\u0aae")
+ buf.write("\7p\2\2\u0aae\u0ab2\3\2\2\2\u0aaf\u0ab1\n\6\2\2\u0ab0")
+ buf.write("\u0aaf\3\2\2\2\u0ab1\u0ab4\3\2\2\2\u0ab2\u0ab0\3\2\2\2")
+ buf.write("\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0ab2\3")
+ buf.write("\2\2\2\u0ab5\u0ab6\b\u0101\2\2\u0ab6\u0202\3\2\2\2\22")
+ buf.write("\2\u0a45\u0a4a\u0a4c\u0a52\u0a57\u0a63\u0a6a\u0a74\u0a7b")
+ buf.write("\u0a88\u0a90\u0a96\u0a99\u0aa3\u0ab2\3\b\2\2")
+ return buf.getvalue()
+
+
+class VfrSyntaxLexer(Lexer):
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ T__0 = 1
+ T__1 = 2
+ T__2 = 3
+ T__3 = 4
+ T__4 = 5
+ T__5 = 6
+ T__6 = 7
+ T__7 = 8
+ T__8 = 9
+ T__9 = 10
+ T__10 = 11
+ T__11 = 12
+ T__12 = 13
+ T__13 = 14
+ T__14 = 15
+ T__15 = 16
+ Define = 17
+ Include = 18
+ FormPkgType = 19
+ OpenBrace = 20
+ CloseBrace = 21
+ OpenParen = 22
+ CloseParen = 23
+ OpenBracket = 24
+ CloseBracket = 25
+ Dot = 26
+ Negative = 27
+ Colon = 28
+ Slash = 29
+ Semicolon = 30
+ Comma = 31
+ Equal = 32
+ NotEqual = 33
+ LessEqual = 34
+ Less = 35
+ GreaterEqual = 36
+ Greater = 37
+ BitWiseOr = 38
+ BitWiseAnd = 39
+ DevicePath = 40
+ FormSet = 41
+ FormSetId = 42
+ EndFormSet = 43
+ Title = 44
+ FormId = 45
+ OneOf = 46
+ EndOneOf = 47
+ Prompt = 48
+ OrderedList = 49
+ MaxContainers = 50
+ EndList = 51
+ EndForm = 52
+ Form = 53
+ FormMap = 54
+ MapTitle = 55
+ MapGuid = 56
+ Subtitle = 57
+ EndSubtitle = 58
+ Help = 59
+ Text = 60
+ Option = 61
+ FLAGS = 62
+ Date = 63
+ EndDate = 64
+ Year = 65
+ Month = 66
+ Day = 67
+ Time = 68
+ EndTime = 69
+ Hour = 70
+ Minute = 71
+ Second = 72
+ GrayOutIf = 73
+ Label = 74
+ Timeout = 75
+ Inventory = 76
+ NonNvDataMap = 77
+ Struct = 78
+ Union = 79
+ Boolean = 80
+ Uint64 = 81
+ Uint32 = 82
+ Uint16 = 83
+ Uint8 = 84
+ EFI_STRING_ID = 85
+ EFI_HII_DATE = 86
+ EFI_HII_TIME = 87
+ EFI_HII_REF = 88
+ Uuid = 89
+ CheckBox = 90
+ EndCheckBox = 91
+ Numeric = 92
+ EndNumeric = 93
+ Minimum = 94
+ Maximum = 95
+ Step = 96
+ Default = 97
+ Password = 98
+ EndPassword = 99
+ String = 100
+ EndString = 101
+ MinSize = 102
+ MaxSize = 103
+ Encoding = 104
+ SuppressIf = 105
+ DisableIf = 106
+ Hidden = 107
+ Goto = 108
+ FormSetGuid = 109
+ InconsistentIf = 110
+ WarningIf = 111
+ NoSubmitIf = 112
+ EndIf = 113
+ Key = 114
+ DefaultFlag = 115
+ ManufacturingFlag = 116
+ CheckBoxDefaultFlag = 117
+ CheckBoxDefaultMfgFlag = 118
+ InteractiveFlag = 119
+ NVAccessFlag = 120
+ ResetRequiredFlag = 121
+ ReconnectRequiredFlag = 122
+ LateCheckFlag = 123
+ ReadOnlyFlag = 124
+ OptionOnlyFlag = 125
+ RestStyleFlag = 126
+ Class = 127
+ Subclass = 128
+ ClassGuid = 129
+ TypeDef = 130
+ Restore = 131
+ Save = 132
+ Defaults = 133
+ Banner = 134
+ Align = 135
+ Left = 136
+ Right = 137
+ Center = 138
+ Line = 139
+ Name = 140
+ VarId = 141
+ Question = 142
+ QuestionId = 143
+ Image = 144
+ Locked = 145
+ Rule = 146
+ EndRule = 147
+ Value = 148
+ Read = 149
+ Write = 150
+ ResetButton = 151
+ EndResetButton = 152
+ DefaultStore = 153
+ Attribute = 154
+ Varstore = 155
+ Efivarstore = 156
+ VarSize = 157
+ NameValueVarStore = 158
+ Action = 159
+ Config = 160
+ EndAction = 161
+ Refresh = 162
+ Interval = 163
+ VarstoreDevice = 164
+ GuidOp = 165
+ EndGuidOp = 166
+ DataType = 167
+ Data = 168
+ Modal = 169
+ ClassNonDevice = 170
+ ClassDiskDevice = 171
+ ClassVideoDevice = 172
+ ClassNetworkDevice = 173
+ ClassInputDevice = 174
+ ClassOnBoardDevice = 175
+ ClassOtherDevice = 176
+ SubclassSetupApplication = 177
+ SubclassGeneralApplication = 178
+ SubclassFrontPage = 179
+ SubclassSingleUse = 180
+ YearSupppressFlag = 181
+ MonthSuppressFlag = 182
+ DaySuppressFlag = 183
+ HourSupppressFlag = 184
+ MinuteSuppressFlag = 185
+ SecondSuppressFlag = 186
+ StorageNormalFlag = 187
+ StorageTimeFlag = 188
+ StorageWakeUpFlag = 189
+ UniQueFlag = 190
+ NoEmptyFlag = 191
+ Cond = 192
+ Find = 193
+ Mid = 194
+ Tok = 195
+ Span = 196
+ Dup = 197
+ VarEqVal = 198
+ Var = 199
+ IdEqVal = 200
+ IdEqId = 201
+ IdEqValList = 202
+ QuestionRef = 203
+ RuleRef = 204
+ StringRef = 205
+ PushThis = 206
+ Security = 207
+ Get = 208
+ TrueSymbol = 209
+ FalseSymbol = 210
+ One = 211
+ Ones = 212
+ Zero = 213
+ Undefined = 214
+ Version = 215
+ Length = 216
+ AND = 217
+ OR = 218
+ NOT = 219
+ Set = 220
+ BitWiseNot = 221
+ BoolVal = 222
+ StringVal = 223
+ UnIntVal = 224
+ ToUpper = 225
+ ToLower = 226
+ Match = 227
+ Match2 = 228
+ Catenate = 229
+ QuestionRefVal = 230
+ StringRefVal = 231
+ Map = 232
+ RefreshGuid = 233
+ StringToken = 234
+ OptionDefault = 235
+ OptionDefaultMfg = 236
+ NumericSizeOne = 237
+ NumericSizeTwo = 238
+ NumericSizeFour = 239
+ NumericSizeEight = 240
+ DisPlayIntDec = 241
+ DisPlayUIntDec = 242
+ DisPlayUIntHex = 243
+ Insensitive = 244
+ Sensitive = 245
+ LastNonMatch = 246
+ FirstNonMatch = 247
+ Number = 248
+ StringIdentifier = 249
+ ComplexDefine = 250
+ LineDefinition = 251
+ IncludeDefinition = 252
+ Whitespace = 253
+ Newline = 254
+ LineComment = 255
+ Extern = 256
+
+ channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+ modeNames = [ "DEFAULT_MODE" ]
+
+ literalNames = [ "<INVALID>",
+ "'show'", "'push'", "'pop'", "'#pragma'", "'pack'", "'='", "'IMAGE_TOKEN'",
+ "'HORIZONTAL'", "'MULTI_LINE'", "'<<'", "'>>'", "'+'", "'*'",
+ "'%'", "'format'", "'?'", "'#define'", "'#include'", "'formpkgtype'",
+ "'{'", "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
+ "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'", "'>='",
+ "'>'", "'|'", "'&'", "'devicepath'", "'formset'", "'formsetid'",
+ "'endformset'", "'title'", "'formid'", "'oneof'", "'endoneof'",
+ "'prompt'", "'orderedlist'", "'maxcontainers'", "'endlist'",
+ "'endform'", "'form'", "'formmap'", "'maptitle'", "'mapguid'",
+ "'subtitle'", "'endsubtitle'", "'help'", "'text'", "'option'",
+ "'flags'", "'date'", "'enddate'", "'year'", "'month'", "'day'",
+ "'time'", "'endtime'", "'hour'", "'minute'", "'second'", "'grayoutif'",
+ "'label'", "'timeout'", "'inventory'", "'_NON_NV_DATA_MAP'",
+ "'struct'", "'union'", "'BOOLEAN'", "'UINT64'", "'UINT32'",
+ "'UINT16'", "'UINT8'", "'EFI_STRING_ID'", "'EFI_HII_DATE'",
+ "'EFI_HII_TIME'", "'EFI_HII_REF'", "'guid'", "'checkbox'", "'endcheckbox'",
+ "'numeric'", "'endnumeric'", "'minimum'", "'maximum'", "'step'",
+ "'default'", "'password'", "'endpassword'", "'string'", "'endstring'",
+ "'minsize'", "'maxsize'", "'encoding'", "'suppressif'", "'disableif'",
+ "'hidden'", "'goto'", "'formsetguid'", "'inconsistentif'", "'warningif'",
+ "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'",
+ "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'", "'INTERACTIVE'",
+ "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'", "'LATE_CHECK'",
+ "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'", "'class'",
+ "'subclass'", "'classguid'", "'typedef'", "'restore'", "'save'",
+ "'defaults'", "'banner'", "'align'", "'left'", "'right'", "'center'",
+ "'line'", "'name'", "'varid'", "'question'", "'questionid'",
+ "'image'", "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
+ "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
+ "'attribute'", "'varstore'", "'efivarstore'", "'varsize'", "'namevaluevarstore'",
+ "'action'", "'config'", "'endaction'", "'refresh'", "'interval'",
+ "'varstoredevice'", "'guidop'", "'endguidop'", "'datatype'",
+ "'data'", "'modal'", "'NON_DEVICE'", "'DISK_DEVICE'", "'VIDEO_DEVICE'",
+ "'NETWORK_DEVICE'", "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'",
+ "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'",
+ "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'", "'DAY_SUPPRESS'",
+ "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'", "'SECOND_SUPPRESS'",
+ "'STORAGE_NORMAL'", "'STORAGE_TIME'", "'STORAGE_WAKEUP'", "'UNIQUE'",
+ "'NOEMPTY'", "'cond'", "'find'", "'mid'", "'token'", "'span'",
+ "'dup'", "'vareqval'", "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
+ "'questionref'", "'ruleref'", "'stringref'", "'pushthis'", "'security'",
+ "'get'", "'TRUE'", "'FALSE'", "'ONE'", "'ONES'", "'ZERO'", "'UNDEFINED'",
+ "'VERSION'", "'length'", "'AND'", "'OR'", "'NOT'", "'set'",
+ "'~'", "'boolval'", "'stringval'", "'unintval'", "'toupper'",
+ "'tolower'", "'match'", "'match2'", "'catenate'", "'questionrefval'",
+ "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
+ "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'", "'NUMERIC_SIZE_1'",
+ "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
+ "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'",
+ "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'", "'FIRST_NON_MATCH'" ]
+
+ symbolicNames = [ "<INVALID>",
+ "Define", "Include", "FormPkgType", "OpenBrace", "CloseBrace",
+ "OpenParen", "CloseParen", "OpenBracket", "CloseBracket", "Dot",
+ "Negative", "Colon", "Slash", "Semicolon", "Comma", "Equal",
+ "NotEqual", "LessEqual", "Less", "GreaterEqual", "Greater",
+ "BitWiseOr", "BitWiseAnd", "DevicePath", "FormSet", "FormSetId",
+ "EndFormSet", "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
+ "OrderedList", "MaxContainers", "EndList", "EndForm", "Form",
+ "FormMap", "MapTitle", "MapGuid", "Subtitle", "EndSubtitle",
+ "Help", "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
+ "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
+ "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
+ "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
+ "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME", "EFI_HII_REF",
+ "Uuid", "CheckBox", "EndCheckBox", "Numeric", "EndNumeric",
+ "Minimum", "Maximum", "Step", "Default", "Password", "EndPassword",
+ "String", "EndString", "MinSize", "MaxSize", "Encoding", "SuppressIf",
+ "DisableIf", "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
+ "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag",
+ "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag",
+ "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
+ "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag",
+ "Class", "Subclass", "ClassGuid", "TypeDef", "Restore", "Save",
+ "Defaults", "Banner", "Align", "Left", "Right", "Center", "Line",
+ "Name", "VarId", "Question", "QuestionId", "Image", "Locked",
+ "Rule", "EndRule", "Value", "Read", "Write", "ResetButton",
+ "EndResetButton", "DefaultStore", "Attribute", "Varstore", "Efivarstore",
+ "VarSize", "NameValueVarStore", "Action", "Config", "EndAction",
+ "Refresh", "Interval", "VarstoreDevice", "GuidOp", "EndGuidOp",
+ "DataType", "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
+ "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
+ "ClassOnBoardDevice", "ClassOtherDevice", "SubclassSetupApplication",
+ "SubclassGeneralApplication", "SubclassFrontPage", "SubclassSingleUse",
+ "YearSupppressFlag", "MonthSuppressFlag", "DaySuppressFlag",
+ "HourSupppressFlag", "MinuteSuppressFlag", "SecondSuppressFlag",
+ "StorageNormalFlag", "StorageTimeFlag", "StorageWakeUpFlag",
+ "UniQueFlag", "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span",
+ "Dup", "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
+ "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
+ "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero", "Undefined",
+ "Version", "Length", "AND", "OR", "NOT", "Set", "BitWiseNot",
+ "BoolVal", "StringVal", "UnIntVal", "ToUpper", "ToLower", "Match",
+ "Match2", "Catenate", "QuestionRefVal", "StringRefVal", "Map",
+ "RefreshGuid", "StringToken", "OptionDefault", "OptionDefaultMfg",
+ "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour", "NumericSizeEight",
+ "DisPlayIntDec", "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive",
+ "Sensitive", "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier",
+ "ComplexDefine", "LineDefinition", "IncludeDefinition", "Whitespace",
+ "Newline", "LineComment", "Extern" ]
+
+ ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
+ "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
+ "T__14", "T__15", "Define", "Include", "FormPkgType",
+ "OpenBrace", "CloseBrace", "OpenParen", "CloseParen",
+ "OpenBracket", "CloseBracket", "Dot", "Negative", "Colon",
+ "Slash", "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
+ "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
+ "DevicePath", "FormSet", "FormSetId", "EndFormSet", "Title",
+ "FormId", "OneOf", "EndOneOf", "Prompt", "OrderedList",
+ "MaxContainers", "EndList", "EndForm", "Form", "FormMap",
+ "MapTitle", "MapGuid", "Subtitle", "EndSubtitle", "Help",
+ "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
+ "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
+ "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
+ "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
+ "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
+ "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox", "Numeric",
+ "EndNumeric", "Minimum", "Maximum", "Step", "Default",
+ "Password", "EndPassword", "String", "EndString", "MinSize",
+ "MaxSize", "Encoding", "SuppressIf", "DisableIf", "Hidden",
+ "Goto", "FormSetGuid", "InconsistentIf", "WarningIf",
+ "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag",
+ "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag",
+ "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
+ "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag",
+ "Class", "Subclass", "ClassGuid", "TypeDef", "Restore",
+ "Save", "Defaults", "Banner", "Align", "Left", "Right",
+ "Center", "Line", "Name", "VarId", "Question", "QuestionId",
+ "Image", "Locked", "Rule", "EndRule", "Value", "Read",
+ "Write", "ResetButton", "EndResetButton", "DefaultStore",
+ "Attribute", "Varstore", "Efivarstore", "VarSize", "NameValueVarStore",
+ "Action", "Config", "EndAction", "Refresh", "Interval",
+ "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType", "Data",
+ "Modal", "ClassNonDevice", "ClassDiskDevice", "ClassVideoDevice",
+ "ClassNetworkDevice", "ClassInputDevice", "ClassOnBoardDevice",
+ "ClassOtherDevice", "SubclassSetupApplication", "SubclassGeneralApplication",
+ "SubclassFrontPage", "SubclassSingleUse", "YearSupppressFlag",
+ "MonthSuppressFlag", "DaySuppressFlag", "HourSupppressFlag",
+ "MinuteSuppressFlag", "SecondSuppressFlag", "StorageNormalFlag",
+ "StorageTimeFlag", "StorageWakeUpFlag", "UniQueFlag",
+ "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span", "Dup",
+ "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
+ "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
+ "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
+ "Undefined", "Version", "Length", "AND", "OR", "NOT",
+ "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
+ "ToUpper", "ToLower", "Match", "Match2", "Catenate", "QuestionRefVal",
+ "StringRefVal", "Map", "RefreshGuid", "StringToken", "OptionDefault",
+ "OptionDefaultMfg", "NumericSizeOne", "NumericSizeTwo",
+ "NumericSizeFour", "NumericSizeEight", "DisPlayIntDec",
+ "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive", "Sensitive",
+ "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier",
+ "ComplexDefine", "LineDefinition", "IncludeDefinition",
+ "Whitespace", "Newline", "LineComment", "Extern" ]
+
+ grammarFileName = "VfrSyntax.g4"
+
+ def __init__(self, input=None, output:TextIO = sys.stdout):
+ super().__init__(input, output)
+ self.checkVersion("4.7.2")
+ self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+ self._actions = None
+ self._predicates = None
diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
new file mode 100644
index 0000000000..d5d61a26a9
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
@@ -0,0 +1,20475 @@
+# 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
+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\u0102")
+ 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")
+ buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
+ buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
+ buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
+ buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
+ buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
+ buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
+ buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
+ buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
+ buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
+ buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
+ buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
+ buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
+ buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
+ buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
+ buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
+ buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
+ buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
+ buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
+ buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
+ buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
+ buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
+ buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
+ buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
+ buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
+ buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
+ buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
+ buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
+ buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
+ buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
+ buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
+ buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
+ buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
+ buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
+ buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
+ buf.write("\t\u00ca\4\u00cb\t\u00cb\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\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\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\3M\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\u05ac")
+ 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\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\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("\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\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("\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\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\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\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\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\u01d2")
+ 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\u0530")
+ 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\u0634")
+ 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\u09dc")
+ 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()
+
+
+class VfrSyntaxParser ( Parser ):
+
+ grammarFileName = "VfrSyntax.g4"
+
+ atn = ATNDeserializer().deserialize(serializedATN())
+
+ decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+ sharedContextCache = PredictionContextCache()
+
+ literalNames = [ "<INVALID>", "'show'", "'push'", "'pop'", "'#pragma'",
+ "'pack'", "'='", "'IMAGE_TOKEN'", "'HORIZONTAL'", "'MULTI_LINE'",
+ "'<<'", "'>>'", "'+'", "'*'", "'%'", "'format'", "'?'",
+ "'#define'", "'#include'", "'formpkgtype'", "'{'",
+ "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
+ "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'",
+ "'>='", "'>'", "'|'", "'&'", "'devicepath'", "'formset'",
+ "'formsetid'", "'endformset'", "'title'", "'formid'",
+ "'oneof'", "'endoneof'", "'prompt'", "'orderedlist'",
+ "'maxcontainers'", "'endlist'", "'endform'", "'form'",
+ "'formmap'", "'maptitle'", "'mapguid'", "'subtitle'",
+ "'endsubtitle'", "'help'", "'text'", "'option'", "'flags'",
+ "'date'", "'enddate'", "'year'", "'month'", "'day'",
+ "'time'", "'endtime'", "'hour'", "'minute'", "'second'",
+ "'grayoutif'", "'label'", "'timeout'", "'inventory'",
+ "'_NON_NV_DATA_MAP'", "'struct'", "'union'", "'BOOLEAN'",
+ "'UINT64'", "'UINT32'", "'UINT16'", "'UINT8'", "'EFI_STRING_ID'",
+ "'EFI_HII_DATE'", "'EFI_HII_TIME'", "'EFI_HII_REF'",
+ "'guid'", "'checkbox'", "'endcheckbox'", "'numeric'",
+ "'endnumeric'", "'minimum'", "'maximum'", "'step'",
+ "'default'", "'password'", "'endpassword'", "'string'",
+ "'endstring'", "'minsize'", "'maxsize'", "'encoding'",
+ "'suppressif'", "'disableif'", "'hidden'", "'goto'",
+ "'formsetguid'", "'inconsistentif'", "'warningif'",
+ "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'",
+ "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'", "'INTERACTIVE'",
+ "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'",
+ "'LATE_CHECK'", "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'",
+ "'class'", "'subclass'", "'classguid'", "'typedef'",
+ "'restore'", "'save'", "'defaults'", "'banner'", "'align'",
+ "'left'", "'right'", "'center'", "'line'", "'name'",
+ "'varid'", "'question'", "'questionid'", "'image'",
+ "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
+ "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
+ "'attribute'", "'varstore'", "'efivarstore'", "'varsize'",
+ "'namevaluevarstore'", "'action'", "'config'", "'endaction'",
+ "'refresh'", "'interval'", "'varstoredevice'", "'guidop'",
+ "'endguidop'", "'datatype'", "'data'", "'modal'", "'NON_DEVICE'",
+ "'DISK_DEVICE'", "'VIDEO_DEVICE'", "'NETWORK_DEVICE'",
+ "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'",
+ "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'",
+ "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'",
+ "'DAY_SUPPRESS'", "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'",
+ "'SECOND_SUPPRESS'", "'STORAGE_NORMAL'", "'STORAGE_TIME'",
+ "'STORAGE_WAKEUP'", "'UNIQUE'", "'NOEMPTY'", "'cond'",
+ "'find'", "'mid'", "'token'", "'span'", "'dup'", "'vareqval'",
+ "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
+ "'questionref'", "'ruleref'", "'stringref'", "'pushthis'",
+ "'security'", "'get'", "'TRUE'", "'FALSE'", "'ONE'",
+ "'ONES'", "'ZERO'", "'UNDEFINED'", "'VERSION'", "'length'",
+ "'AND'", "'OR'", "'NOT'", "'set'", "'~'", "'boolval'",
+ "'stringval'", "'unintval'", "'toupper'", "'tolower'",
+ "'match'", "'match2'", "'catenate'", "'questionrefval'",
+ "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
+ "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'", "'NUMERIC_SIZE_1'",
+ "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
+ "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'",
+ "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'",
+ "'FIRST_NON_MATCH'" ]
+
+ symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
+ "<INVALID>", "Define", "Include", "FormPkgType", "OpenBrace",
+ "CloseBrace", "OpenParen", "CloseParen", "OpenBracket",
+ "CloseBracket", "Dot", "Negative", "Colon", "Slash",
+ "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
+ "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
+ "DevicePath", "FormSet", "FormSetId", "EndFormSet",
+ "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
+ "OrderedList", "MaxContainers", "EndList", "EndForm",
+ "Form", "FormMap", "MapTitle", "MapGuid", "Subtitle",
+ "EndSubtitle", "Help", "Text", "Option", "FLAGS",
+ "Date", "EndDate", "Year", "Month", "Day", "Time",
+ "EndTime", "Hour", "Minute", "Second", "GrayOutIf",
+ "Label", "Timeout", "Inventory", "NonNvDataMap", "Struct",
+ "Union", "Boolean", "Uint64", "Uint32", "Uint16",
+ "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
+ "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox",
+ "Numeric", "EndNumeric", "Minimum", "Maximum", "Step",
+ "Default", "Password", "EndPassword", "String", "EndString",
+ "MinSize", "MaxSize", "Encoding", "SuppressIf", "DisableIf",
+ "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
+ "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
+ "ManufacturingFlag", "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag",
+ "InteractiveFlag", "NVAccessFlag", "ResetRequiredFlag",
+ "ReconnectRequiredFlag", "LateCheckFlag", "ReadOnlyFlag",
+ "OptionOnlyFlag", "RestStyleFlag", "Class", "Subclass",
+ "ClassGuid", "TypeDef", "Restore", "Save", "Defaults",
+ "Banner", "Align", "Left", "Right", "Center", "Line",
+ "Name", "VarId", "Question", "QuestionId", "Image",
+ "Locked", "Rule", "EndRule", "Value", "Read", "Write",
+ "ResetButton", "EndResetButton", "DefaultStore", "Attribute",
+ "Varstore", "Efivarstore", "VarSize", "NameValueVarStore",
+ "Action", "Config", "EndAction", "Refresh", "Interval",
+ "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType",
+ "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
+ "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
+ "ClassOnBoardDevice", "ClassOtherDevice", "SubclassSetupApplication",
+ "SubclassGeneralApplication", "SubclassFrontPage",
+ "SubclassSingleUse", "YearSupppressFlag", "MonthSuppressFlag",
+ "DaySuppressFlag", "HourSupppressFlag", "MinuteSuppressFlag",
+ "SecondSuppressFlag", "StorageNormalFlag", "StorageTimeFlag",
+ "StorageWakeUpFlag", "UniQueFlag", "NoEmptyFlag",
+ "Cond", "Find", "Mid", "Tok", "Span", "Dup", "VarEqVal",
+ "Var", "IdEqVal", "IdEqId", "IdEqValList", "QuestionRef",
+ "RuleRef", "StringRef", "PushThis", "Security", "Get",
+ "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
+ "Undefined", "Version", "Length", "AND", "OR", "NOT",
+ "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
+ "ToUpper", "ToLower", "Match", "Match2", "Catenate",
+ "QuestionRefVal", "StringRefVal", "Map", "RefreshGuid",
+ "StringToken", "OptionDefault", "OptionDefaultMfg",
+ "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour",
+ "NumericSizeEight", "DisPlayIntDec", "DisPlayUIntDec",
+ "DisPlayUIntHex", "Insensitive", "Sensitive", "LastNonMatch",
+ "FirstNonMatch", "Number", "StringIdentifier", "ComplexDefine",
+ "LineDefinition", "IncludeDefinition", "Whitespace",
+ "Newline", "LineComment", "Extern" ]
+
+ RULE_vfrProgram = 0
+ RULE_pragmaPackShowDef = 1
+ RULE_pragmaPackStackDef = 2
+ RULE_pragmaPackNumber = 3
+ RULE_vfrPragmaPackDefinition = 4
+ RULE_vfrDataStructDefinition = 5
+ RULE_vfrDataUnionDefinition = 6
+ RULE_vfrDataStructFields = 7
+ RULE_dataStructField64 = 8
+ RULE_dataStructField32 = 9
+ RULE_dataStructField16 = 10
+ RULE_dataStructField8 = 11
+ RULE_dataStructFieldBool = 12
+ RULE_dataStructFieldString = 13
+ RULE_dataStructFieldDate = 14
+ RULE_dataStructFieldTime = 15
+ RULE_dataStructFieldRef = 16
+ RULE_dataStructFieldUser = 17
+ RULE_dataStructBitField64 = 18
+ RULE_dataStructBitField32 = 19
+ RULE_dataStructBitField16 = 20
+ RULE_dataStructBitField8 = 21
+ RULE_vfrFormSetDefinition = 22
+ RULE_classguidDefinition = 23
+ RULE_classDefinition = 24
+ RULE_validClassNames = 25
+ RULE_subclassDefinition = 26
+ RULE_vfrFormSetList = 27
+ RULE_vfrFormSet = 28
+ RULE_vfrStatementDefaultStore = 29
+ RULE_vfrStatementVarStoreLinear = 30
+ RULE_vfrStatementVarStoreEfi = 31
+ RULE_vfrVarStoreEfiAttr = 32
+ RULE_vfrStatementVarStoreNameValue = 33
+ RULE_vfrStatementDisableIfFormSet = 34
+ RULE_vfrStatementSuppressIfFormSet = 35
+ RULE_guidSubDefinition = 36
+ RULE_guidDefinition = 37
+ RULE_getStringId = 38
+ RULE_vfrQuestionHeader = 39
+ RULE_vfrQuestionBaseInfo = 40
+ RULE_vfrStatementHeader = 41
+ RULE_questionheaderFlagsField = 42
+ RULE_vfrStorageVarId = 43
+ RULE_vfrConstantValueField = 44
+ RULE_vfrImageTag = 45
+ RULE_vfrLockedTag = 46
+ RULE_vfrStatementStatTag = 47
+ RULE_vfrStatementStatTagList = 48
+ RULE_vfrFormDefinition = 49
+ RULE_vfrForm = 50
+ RULE_vfrFormMapDefinition = 51
+ RULE_vfrStatementImage = 52
+ RULE_vfrStatementLocked = 53
+ RULE_vfrStatementRules = 54
+ RULE_vfrStatementStat = 55
+ RULE_vfrStatementSubTitle = 56
+ RULE_vfrStatementSubTitleComponent = 57
+ RULE_vfrSubtitleFlags = 58
+ RULE_subtitleFlagsField = 59
+ RULE_vfrStatementStaticText = 60
+ RULE_staticTextFlagsField = 61
+ RULE_vfrStatementCrossReference = 62
+ RULE_vfrStatementGoto = 63
+ RULE_vfrGotoFlags = 64
+ RULE_gotoFlagsField = 65
+ RULE_vfrStatementResetButton = 66
+ RULE_vfrStatementQuestions = 67
+ RULE_vfrStatementQuestionTag = 68
+ RULE_vfrStatementInconsistentIf = 69
+ RULE_vfrStatementNoSubmitIf = 70
+ RULE_vfrStatementDisableIfQuest = 71
+ RULE_vfrStatementRefresh = 72
+ RULE_vfrStatementVarstoreDevice = 73
+ RULE_vfrStatementRefreshEvent = 74
+ RULE_vfrStatementWarningIf = 75
+ RULE_vfrStatementQuestionTagList = 76
+ RULE_vfrStatementQuestionOptionTag = 77
+ RULE_flagsField = 78
+ RULE_vfrStatementSuppressIfQuest = 79
+ RULE_vfrStatementGrayOutIfQuest = 80
+ RULE_vfrStatementDefault = 81
+ RULE_vfrStatementValue = 82
+ RULE_vfrStatementOptions = 83
+ RULE_vfrStatementOneOfOption = 84
+ RULE_vfrOneOfOptionFlags = 85
+ RULE_oneofoptionFlagsField = 86
+ RULE_vfrStatementRead = 87
+ RULE_vfrStatementWrite = 88
+ RULE_vfrStatementQuestionOptionList = 89
+ RULE_vfrStatementQuestionOption = 90
+ RULE_vfrStatementBooleanType = 91
+ RULE_vfrStatementCheckBox = 92
+ RULE_vfrCheckBoxFlags = 93
+ RULE_checkboxFlagsField = 94
+ RULE_vfrStatementAction = 95
+ RULE_vfrActionFlags = 96
+ RULE_actionFlagsField = 97
+ RULE_vfrStatementNumericType = 98
+ RULE_vfrStatementNumeric = 99
+ RULE_vfrSetMinMaxStep = 100
+ RULE_vfrNumericFlags = 101
+ RULE_numericFlagsField = 102
+ RULE_vfrStatementOneOf = 103
+ RULE_vfrOneofFlagsField = 104
+ RULE_vfrStatementStringType = 105
+ RULE_vfrStatementString = 106
+ RULE_vfrStringFlagsField = 107
+ RULE_stringFlagsField = 108
+ RULE_vfrStatementPassword = 109
+ RULE_vfrPasswordFlagsField = 110
+ RULE_passwordFlagsField = 111
+ RULE_vfrStatementOrderedList = 112
+ RULE_vfrOrderedListFlags = 113
+ RULE_orderedlistFlagsField = 114
+ RULE_vfrStatementDate = 115
+ RULE_minMaxDateStepDefault = 116
+ RULE_vfrDateFlags = 117
+ RULE_dateFlagsField = 118
+ RULE_vfrStatementTime = 119
+ RULE_minMaxTimeStepDefault = 120
+ RULE_vfrTimeFlags = 121
+ RULE_timeFlagsField = 122
+ RULE_vfrStatementConditional = 123
+ RULE_vfrStatementConditionalNew = 124
+ RULE_vfrStatementSuppressIfStat = 125
+ RULE_vfrStatementGrayOutIfStat = 126
+ RULE_vfrStatementStatList = 127
+ RULE_vfrStatementStatListOld = 128
+ RULE_vfrStatementDisableIfStat = 129
+ RULE_vfrStatementgrayoutIfSuppressIf = 130
+ RULE_vfrStatementsuppressIfGrayOutIf = 131
+ RULE_vfrStatementSuppressIfStatNew = 132
+ RULE_vfrStatementGrayOutIfStatNew = 133
+ RULE_vfrStatementInconsistentIfStat = 134
+ RULE_vfrStatementInvalid = 135
+ RULE_vfrStatementInvalidHidden = 136
+ RULE_vfrStatementInvalidInventory = 137
+ RULE_vfrStatementInvalidSaveRestoreDefaults = 138
+ RULE_vfrStatementLabel = 139
+ RULE_vfrStatementBanner = 140
+ RULE_vfrStatementExtension = 141
+ RULE_vfrExtensionData = 142
+ RULE_vfrStatementModal = 143
+ RULE_vfrModalTag = 144
+ RULE_vfrStatementExpression = 145
+ RULE_vfrStatementExpressionSub = 146
+ RULE_andTerm = 147
+ RULE_bitwiseorTerm = 148
+ RULE_bitwiseandTerm = 149
+ RULE_equalTerm = 150
+ RULE_equalTermSupplementary = 151
+ RULE_compareTerm = 152
+ RULE_compareTermSupplementary = 153
+ RULE_shiftTerm = 154
+ RULE_shiftTermSupplementary = 155
+ RULE_addMinusTerm = 156
+ RULE_addMinusTermSupplementary = 157
+ RULE_multdivmodTerm = 158
+ RULE_multdivmodTermSupplementary = 159
+ RULE_castTerm = 160
+ RULE_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",
+ "vfrDataUnionDefinition", "vfrDataStructFields", "dataStructField64",
+ "dataStructField32", "dataStructField16", "dataStructField8",
+ "dataStructFieldBool", "dataStructFieldString", "dataStructFieldDate",
+ "dataStructFieldTime", "dataStructFieldRef", "dataStructFieldUser",
+ "dataStructBitField64", "dataStructBitField32", "dataStructBitField16",
+ "dataStructBitField8", "vfrFormSetDefinition", "classguidDefinition",
+ "classDefinition", "validClassNames", "subclassDefinition",
+ "vfrFormSetList", "vfrFormSet", "vfrStatementDefaultStore",
+ "vfrStatementVarStoreLinear", "vfrStatementVarStoreEfi",
+ "vfrVarStoreEfiAttr", "vfrStatementVarStoreNameValue",
+ "vfrStatementDisableIfFormSet", "vfrStatementSuppressIfFormSet",
+ "guidSubDefinition", "guidDefinition", "getStringId",
+ "vfrQuestionHeader", "vfrQuestionBaseInfo", "vfrStatementHeader",
+ "questionheaderFlagsField", "vfrStorageVarId", "vfrConstantValueField",
+ "vfrImageTag", "vfrLockedTag", "vfrStatementStatTag",
+ "vfrStatementStatTagList", "vfrFormDefinition", "vfrForm",
+ "vfrFormMapDefinition", "vfrStatementImage", "vfrStatementLocked",
+ "vfrStatementRules", "vfrStatementStat", "vfrStatementSubTitle",
+ "vfrStatementSubTitleComponent", "vfrSubtitleFlags",
+ "subtitleFlagsField", "vfrStatementStaticText", "staticTextFlagsField",
+ "vfrStatementCrossReference", "vfrStatementGoto", "vfrGotoFlags",
+ "gotoFlagsField", "vfrStatementResetButton", "vfrStatementQuestions",
+ "vfrStatementQuestionTag", "vfrStatementInconsistentIf",
+ "vfrStatementNoSubmitIf", "vfrStatementDisableIfQuest",
+ "vfrStatementRefresh", "vfrStatementVarstoreDevice",
+ "vfrStatementRefreshEvent", "vfrStatementWarningIf",
+ "vfrStatementQuestionTagList", "vfrStatementQuestionOptionTag",
+ "flagsField", "vfrStatementSuppressIfQuest", "vfrStatementGrayOutIfQuest",
+ "vfrStatementDefault", "vfrStatementValue", "vfrStatementOptions",
+ "vfrStatementOneOfOption", "vfrOneOfOptionFlags", "oneofoptionFlagsField",
+ "vfrStatementRead", "vfrStatementWrite", "vfrStatementQuestionOptionList",
+ "vfrStatementQuestionOption", "vfrStatementBooleanType",
+ "vfrStatementCheckBox", "vfrCheckBoxFlags", "checkboxFlagsField",
+ "vfrStatementAction", "vfrActionFlags", "actionFlagsField",
+ "vfrStatementNumericType", "vfrStatementNumeric", "vfrSetMinMaxStep",
+ "vfrNumericFlags", "numericFlagsField", "vfrStatementOneOf",
+ "vfrOneofFlagsField", "vfrStatementStringType", "vfrStatementString",
+ "vfrStringFlagsField", "stringFlagsField", "vfrStatementPassword",
+ "vfrPasswordFlagsField", "passwordFlagsField", "vfrStatementOrderedList",
+ "vfrOrderedListFlags", "orderedlistFlagsField", "vfrStatementDate",
+ "minMaxDateStepDefault", "vfrDateFlags", "dateFlagsField",
+ "vfrStatementTime", "minMaxTimeStepDefault", "vfrTimeFlags",
+ "timeFlagsField", "vfrStatementConditional", "vfrStatementConditionalNew",
+ "vfrStatementSuppressIfStat", "vfrStatementGrayOutIfStat",
+ "vfrStatementStatList", "vfrStatementStatListOld", "vfrStatementDisableIfStat",
+ "vfrStatementgrayoutIfSuppressIf", "vfrStatementsuppressIfGrayOutIf",
+ "vfrStatementSuppressIfStatNew", "vfrStatementGrayOutIfStatNew",
+ "vfrStatementInconsistentIfStat", "vfrStatementInvalid",
+ "vfrStatementInvalidHidden", "vfrStatementInvalidInventory",
+ "vfrStatementInvalidSaveRestoreDefaults", "vfrStatementLabel",
+ "vfrStatementBanner", "vfrStatementExtension", "vfrExtensionData",
+ "vfrStatementModal", "vfrModalTag", "vfrStatementExpression",
+ "vfrStatementExpressionSub", "andTerm", "bitwiseorTerm",
+ "bitwiseandTerm", "equalTerm", "equalTermSupplementary",
+ "compareTerm", "compareTermSupplementary", "shiftTerm",
+ "shiftTermSupplementary", "addMinusTerm", "addMinusTermSupplementary",
+ "multdivmodTerm", "multdivmodTermSupplementary", "castTerm",
+ "castTermSub", "atomTerm", "vfrExpressionCatenate", "vfrExpressionMatch",
+ "vfrExpressionMatch2", "vfrExpressionParen", "vfrExpressionBuildInFunction",
+ "dupExp", "vareqvalExp", "ideqvalExp", "ideqidExp", "ideqvallistExp",
+ "vfrQuestionDataFieldName", "arrayName", "questionref1Exp",
+ "rulerefExp", "stringref1Exp", "pushthisExp", "securityExp",
+ "numericVarStoreType", "getExp", "vfrExpressionConstant",
+ "vfrExpressionUnaryOp", "lengthExp", "bitwisenotExp",
+ "question23refExp", "stringref2Exp", "toboolExp", "tostringExp",
+ "unintExp", "toupperExp", "tolwerExp", "setExp", "vfrExpressionTernaryOp",
+ "conditionalExp", "findExp", "findFormat", "midExp",
+ "tokenExp", "spanExp", "spanFlags", "vfrExpressionMap" ]
+
+ EOF = Token.EOF
+ T__0=1
+ T__1=2
+ T__2=3
+ T__3=4
+ T__4=5
+ T__5=6
+ T__6=7
+ T__7=8
+ T__8=9
+ T__9=10
+ T__10=11
+ T__11=12
+ T__12=13
+ T__13=14
+ T__14=15
+ T__15=16
+ Define=17
+ Include=18
+ FormPkgType=19
+ OpenBrace=20
+ CloseBrace=21
+ OpenParen=22
+ CloseParen=23
+ OpenBracket=24
+ CloseBracket=25
+ Dot=26
+ Negative=27
+ Colon=28
+ Slash=29
+ Semicolon=30
+ Comma=31
+ Equal=32
+ NotEqual=33
+ LessEqual=34
+ Less=35
+ GreaterEqual=36
+ Greater=37
+ BitWiseOr=38
+ BitWiseAnd=39
+ DevicePath=40
+ FormSet=41
+ FormSetId=42
+ EndFormSet=43
+ Title=44
+ FormId=45
+ OneOf=46
+ EndOneOf=47
+ Prompt=48
+ OrderedList=49
+ MaxContainers=50
+ EndList=51
+ EndForm=52
+ Form=53
+ FormMap=54
+ MapTitle=55
+ MapGuid=56
+ Subtitle=57
+ EndSubtitle=58
+ Help=59
+ Text=60
+ Option=61
+ FLAGS=62
+ Date=63
+ EndDate=64
+ Year=65
+ Month=66
+ Day=67
+ Time=68
+ EndTime=69
+ Hour=70
+ Minute=71
+ Second=72
+ GrayOutIf=73
+ Label=74
+ Timeout=75
+ Inventory=76
+ NonNvDataMap=77
+ Struct=78
+ Union=79
+ Boolean=80
+ Uint64=81
+ Uint32=82
+ Uint16=83
+ Uint8=84
+ EFI_STRING_ID=85
+ EFI_HII_DATE=86
+ EFI_HII_TIME=87
+ EFI_HII_REF=88
+ Uuid=89
+ CheckBox=90
+ EndCheckBox=91
+ Numeric=92
+ EndNumeric=93
+ Minimum=94
+ Maximum=95
+ Step=96
+ Default=97
+ Password=98
+ EndPassword=99
+ String=100
+ EndString=101
+ MinSize=102
+ MaxSize=103
+ Encoding=104
+ SuppressIf=105
+ DisableIf=106
+ Hidden=107
+ Goto=108
+ FormSetGuid=109
+ InconsistentIf=110
+ WarningIf=111
+ NoSubmitIf=112
+ EndIf=113
+ Key=114
+ DefaultFlag=115
+ ManufacturingFlag=116
+ CheckBoxDefaultFlag=117
+ CheckBoxDefaultMfgFlag=118
+ InteractiveFlag=119
+ NVAccessFlag=120
+ ResetRequiredFlag=121
+ ReconnectRequiredFlag=122
+ LateCheckFlag=123
+ ReadOnlyFlag=124
+ OptionOnlyFlag=125
+ RestStyleFlag=126
+ Class=127
+ Subclass=128
+ ClassGuid=129
+ TypeDef=130
+ Restore=131
+ Save=132
+ Defaults=133
+ Banner=134
+ Align=135
+ Left=136
+ Right=137
+ Center=138
+ Line=139
+ Name=140
+ VarId=141
+ Question=142
+ QuestionId=143
+ Image=144
+ Locked=145
+ Rule=146
+ EndRule=147
+ Value=148
+ Read=149
+ Write=150
+ ResetButton=151
+ EndResetButton=152
+ DefaultStore=153
+ Attribute=154
+ Varstore=155
+ Efivarstore=156
+ VarSize=157
+ NameValueVarStore=158
+ Action=159
+ Config=160
+ EndAction=161
+ Refresh=162
+ Interval=163
+ VarstoreDevice=164
+ GuidOp=165
+ EndGuidOp=166
+ DataType=167
+ Data=168
+ Modal=169
+ ClassNonDevice=170
+ ClassDiskDevice=171
+ ClassVideoDevice=172
+ ClassNetworkDevice=173
+ ClassInputDevice=174
+ ClassOnBoardDevice=175
+ ClassOtherDevice=176
+ SubclassSetupApplication=177
+ SubclassGeneralApplication=178
+ SubclassFrontPage=179
+ SubclassSingleUse=180
+ YearSupppressFlag=181
+ MonthSuppressFlag=182
+ DaySuppressFlag=183
+ HourSupppressFlag=184
+ MinuteSuppressFlag=185
+ SecondSuppressFlag=186
+ StorageNormalFlag=187
+ StorageTimeFlag=188
+ StorageWakeUpFlag=189
+ UniQueFlag=190
+ NoEmptyFlag=191
+ Cond=192
+ Find=193
+ Mid=194
+ Tok=195
+ Span=196
+ Dup=197
+ VarEqVal=198
+ Var=199
+ IdEqVal=200
+ IdEqId=201
+ IdEqValList=202
+ QuestionRef=203
+ RuleRef=204
+ StringRef=205
+ PushThis=206
+ Security=207
+ Get=208
+ TrueSymbol=209
+ FalseSymbol=210
+ One=211
+ Ones=212
+ Zero=213
+ Undefined=214
+ Version=215
+ Length=216
+ AND=217
+ OR=218
+ NOT=219
+ Set=220
+ BitWiseNot=221
+ BoolVal=222
+ StringVal=223
+ UnIntVal=224
+ ToUpper=225
+ ToLower=226
+ Match=227
+ Match2=228
+ Catenate=229
+ QuestionRefVal=230
+ StringRefVal=231
+ Map=232
+ RefreshGuid=233
+ StringToken=234
+ OptionDefault=235
+ OptionDefaultMfg=236
+ NumericSizeOne=237
+ NumericSizeTwo=238
+ NumericSizeFour=239
+ NumericSizeEight=240
+ DisPlayIntDec=241
+ DisPlayUIntDec=242
+ DisPlayUIntHex=243
+ Insensitive=244
+ Sensitive=245
+ LastNonMatch=246
+ FirstNonMatch=247
+ Number=248
+ StringIdentifier=249
+ ComplexDefine=250
+ LineDefinition=251
+ IncludeDefinition=252
+ Whitespace=253
+ Newline=254
+ LineComment=255
+ Extern=256
+
+ def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
+ super().__init__(input, output)
+ self.checkVersion("4.7.2")
+ self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
+ self._predicates = None
+
+
+
+
+ class VfrProgramContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def vfrPragmaPackDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrPragmaPackDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrPragmaPackDefinitionContext,i)
+
+
+ def vfrDataStructDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrDataStructDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructDefinitionContext,i)
+
+
+ def vfrDataUnionDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrDataUnionDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataUnionDefinitionContext,i)
+
+
+ def vfrFormSetDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrProgram
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrProgram" ):
+ return visitor.visitVfrProgram(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrProgram(self):
+
+ localctx = VfrSyntaxParser.VfrProgramContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 0, self.RULE_vfrProgram)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 409
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
+ if la_ == 1:
+ self.state = 406
+ self.vfrPragmaPackDefinition()
+ pass
+
+ elif la_ == 2:
+ self.state = 407
+ self.vfrDataStructDefinition()
+ pass
+
+ elif la_ == 3:
+ self.state = 408
+ self.vfrDataUnionDefinition()
+ pass
+
+
+ self.state = 413
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ 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)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PragmaPackShowDefContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pragmaPackShowDef
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPragmaPackShowDef" ):
+ return visitor.visitPragmaPackShowDef(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pragmaPackShowDef(self):
+
+ localctx = VfrSyntaxParser.PragmaPackShowDefContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 2, self.RULE_pragmaPackShowDef)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 417
+ self.match(VfrSyntaxParser.T__0)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PragmaPackStackDefContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pragmaPackStackDef
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPragmaPackStackDef" ):
+ return visitor.visitPragmaPackStackDef(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pragmaPackStackDef(self):
+
+ localctx = VfrSyntaxParser.PragmaPackStackDefContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 4, self.RULE_pragmaPackStackDef)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 422
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
+ if la_ == 1:
+ self.state = 420
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 421
+ self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 426
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 424
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 425
+ self.match(VfrSyntaxParser.Number)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PragmaPackNumberContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pragmaPackNumber
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPragmaPackNumber" ):
+ return visitor.visitPragmaPackNumber(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pragmaPackNumber(self):
+
+ localctx = VfrSyntaxParser.PragmaPackNumberContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 6, self.RULE_pragmaPackNumber)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 429
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Number:
+ self.state = 428
+ self.match(VfrSyntaxParser.Number)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrPragmaPackDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def pragmaPackShowDef(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackShowDefContext,0)
+
+
+ def pragmaPackStackDef(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackStackDefContext,0)
+
+
+ def pragmaPackNumber(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PragmaPackNumberContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrPragmaPackDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrPragmaPackDefinition" ):
+ return visitor.visitVfrPragmaPackDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrPragmaPackDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrPragmaPackDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 8, self.RULE_vfrPragmaPackDefinition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 431
+ self.match(VfrSyntaxParser.T__3)
+ self.state = 432
+ self.match(VfrSyntaxParser.T__4)
+ self.state = 433
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 437
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
+ if la_ == 1:
+ self.state = 434
+ self.pragmaPackShowDef()
+
+ elif la_ == 2:
+ self.state = 435
+ self.pragmaPackStackDef()
+
+ elif la_ == 3:
+ self.state = 436
+ self.pragmaPackNumber()
+
+
+ self.state = 439
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDataStructDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.N1 = None # Token
+ self.N2 = None # Token
+
+ def Struct(self):
+ return self.getToken(VfrSyntaxParser.Struct, 0)
+
+ def OpenBrace(self):
+ return self.getToken(VfrSyntaxParser.OpenBrace, 0)
+
+ def vfrDataStructFields(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
+
+
+ def CloseBrace(self):
+ return self.getToken(VfrSyntaxParser.CloseBrace, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def TypeDef(self):
+ return self.getToken(VfrSyntaxParser.TypeDef, 0)
+
+ def NonNvDataMap(self):
+ return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDataStructDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDataStructDefinition" ):
+ return visitor.visitVfrDataStructDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDataStructDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrDataStructDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 10, self.RULE_vfrDataStructDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 442
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.TypeDef:
+ self.state = 441
+ self.match(VfrSyntaxParser.TypeDef)
+
+
+ self.state = 444
+ self.match(VfrSyntaxParser.Struct)
+ self.state = 446
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.NonNvDataMap:
+ self.state = 445
+ self.match(VfrSyntaxParser.NonNvDataMap)
+
+
+ self.state = 449
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 448
+ localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 451
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 452
+ self.vfrDataStructFields(False)
+ self.state = 453
+ self.match(VfrSyntaxParser.CloseBrace)
+ self.state = 455
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 454
+ localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 457
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDataUnionDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.N1 = None # Token
+ self.N2 = None # Token
+
+ def Union(self):
+ return self.getToken(VfrSyntaxParser.Union, 0)
+
+ def OpenBrace(self):
+ return self.getToken(VfrSyntaxParser.OpenBrace, 0)
+
+ def vfrDataStructFields(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
+
+
+ def CloseBrace(self):
+ return self.getToken(VfrSyntaxParser.CloseBrace, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def TypeDef(self):
+ return self.getToken(VfrSyntaxParser.TypeDef, 0)
+
+ def NonNvDataMap(self):
+ return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDataUnionDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDataUnionDefinition" ):
+ return visitor.visitVfrDataUnionDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDataUnionDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrDataUnionDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 12, self.RULE_vfrDataUnionDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 460
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.TypeDef:
+ self.state = 459
+ self.match(VfrSyntaxParser.TypeDef)
+
+
+ self.state = 462
+ self.match(VfrSyntaxParser.Union)
+ self.state = 464
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.NonNvDataMap:
+ self.state = 463
+ self.match(VfrSyntaxParser.NonNvDataMap)
+
+
+ self.state = 467
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 466
+ localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 469
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 470
+ self.vfrDataStructFields(True)
+ self.state = 471
+ self.match(VfrSyntaxParser.CloseBrace)
+ self.state = 473
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 472
+ localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 475
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDataStructFieldsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.FieldInUnion = FieldInUnion
+
+ def dataStructField64(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField64Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField64Context,i)
+
+
+ def dataStructField32(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField32Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField32Context,i)
+
+
+ def dataStructField16(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField16Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField16Context,i)
+
+
+ def dataStructField8(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructField8Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructField8Context,i)
+
+
+ def dataStructFieldBool(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldBoolContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldBoolContext,i)
+
+
+ def dataStructFieldString(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldStringContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldStringContext,i)
+
+
+ def dataStructFieldDate(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldDateContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldDateContext,i)
+
+
+ def dataStructFieldTime(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldTimeContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldTimeContext,i)
+
+
+ def dataStructFieldRef(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldRefContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldRefContext,i)
+
+
+ def dataStructFieldUser(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldUserContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldUserContext,i)
+
+
+ def dataStructBitField64(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField64Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField64Context,i)
+
+
+ def dataStructBitField32(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField32Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField32Context,i)
+
+
+ def dataStructBitField16(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField16Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField16Context,i)
+
+
+ def dataStructBitField8(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField8Context)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField8Context,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDataStructFields
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDataStructFields" ):
+ return visitor.visitVfrDataStructFields(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDataStructFields(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.VfrDataStructFieldsContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 14, self.RULE_vfrDataStructFields)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 491
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
+ if la_ == 1:
+ self.state = 477
+ self.dataStructField64(FieldInUnion)
+ pass
+
+ elif la_ == 2:
+ self.state = 478
+ self.dataStructField32(FieldInUnion)
+ pass
+
+ elif la_ == 3:
+ self.state = 479
+ self.dataStructField16(FieldInUnion)
+ pass
+
+ elif la_ == 4:
+ self.state = 480
+ self.dataStructField8(FieldInUnion)
+ pass
+
+ elif la_ == 5:
+ self.state = 481
+ self.dataStructFieldBool(FieldInUnion)
+ pass
+
+ elif la_ == 6:
+ self.state = 482
+ self.dataStructFieldString(FieldInUnion)
+ pass
+
+ elif la_ == 7:
+ self.state = 483
+ self.dataStructFieldDate(FieldInUnion)
+ pass
+
+ elif la_ == 8:
+ self.state = 484
+ self.dataStructFieldTime(FieldInUnion)
+ pass
+
+ elif la_ == 9:
+ self.state = 485
+ self.dataStructFieldRef(FieldInUnion)
+ pass
+
+ elif la_ == 10:
+ self.state = 486
+ self.dataStructFieldUser(FieldInUnion)
+ pass
+
+ elif la_ == 11:
+ self.state = 487
+ self.dataStructBitField64(FieldInUnion)
+ pass
+
+ elif la_ == 12:
+ self.state = 488
+ self.dataStructBitField32(FieldInUnion)
+ pass
+
+ elif la_ == 13:
+ self.state = 489
+ self.dataStructBitField16(FieldInUnion)
+ pass
+
+ elif la_ == 14:
+ self.state = 490
+ self.dataStructBitField8(FieldInUnion)
+ pass
+
+
+ self.state = 495
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField64Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField64
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField64" ):
+ return visitor.visitDataStructField64(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField64(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField64Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 16, self.RULE_dataStructField64)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 496
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 497
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 501
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 498
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 499
+ self.match(VfrSyntaxParser.Number)
+ self.state = 500
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 503
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField32Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField32
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField32" ):
+ return visitor.visitDataStructField32(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField32(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField32Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 18, self.RULE_dataStructField32)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 505
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 506
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 510
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 507
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 508
+ self.match(VfrSyntaxParser.Number)
+ self.state = 509
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 512
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField16Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField16
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField16" ):
+ return visitor.visitDataStructField16(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField16(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField16Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 20, self.RULE_dataStructField16)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 514
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 515
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 519
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 516
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 517
+ self.match(VfrSyntaxParser.Number)
+ self.state = 518
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 521
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructField8Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructField8
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructField8" ):
+ return visitor.visitDataStructField8(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructField8(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructField8Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 22, self.RULE_dataStructField8)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 523
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 524
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 528
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 525
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 526
+ self.match(VfrSyntaxParser.Number)
+ self.state = 527
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 530
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldBoolContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Boolean(self):
+ return self.getToken(VfrSyntaxParser.Boolean, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldBool
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldBool" ):
+ return visitor.visitDataStructFieldBool(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldBool(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldBoolContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 24, self.RULE_dataStructFieldBool)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 532
+ self.match(VfrSyntaxParser.Boolean)
+ self.state = 533
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 537
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 534
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 535
+ self.match(VfrSyntaxParser.Number)
+ self.state = 536
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 539
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldStringContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_STRING_ID(self):
+ return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldString
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldString" ):
+ return visitor.visitDataStructFieldString(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldString(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldStringContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 26, self.RULE_dataStructFieldString)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 541
+ self.match(VfrSyntaxParser.EFI_STRING_ID)
+ self.state = 542
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 546
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 543
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 544
+ self.match(VfrSyntaxParser.Number)
+ self.state = 545
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 548
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldDateContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldDate
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldDate" ):
+ return visitor.visitDataStructFieldDate(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldDate(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldDateContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 28, self.RULE_dataStructFieldDate)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 550
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 551
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 555
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 552
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 553
+ self.match(VfrSyntaxParser.Number)
+ self.state = 554
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 557
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldTimeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldTime
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldTime" ):
+ return visitor.visitDataStructFieldTime(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldTime(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldTimeContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 30, self.RULE_dataStructFieldTime)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 559
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 560
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 564
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 561
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 562
+ self.match(VfrSyntaxParser.Number)
+ self.state = 563
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 566
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldRefContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldRef
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldRef" ):
+ return visitor.visitDataStructFieldRef(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldRef(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldRefContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 32, self.RULE_dataStructFieldRef)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 568
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 569
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 573
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 570
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 571
+ self.match(VfrSyntaxParser.Number)
+ self.state = 572
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 575
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructFieldUserContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.T = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructFieldUser
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructFieldUser" ):
+ return visitor.visitDataStructFieldUser(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructFieldUser(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructFieldUserContext(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 34, self.RULE_dataStructFieldUser)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 577
+ localctx.T = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 578
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 582
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 579
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 580
+ self.match(VfrSyntaxParser.Number)
+ self.state = 581
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 584
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField64Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField64
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField64" ):
+ return visitor.visitDataStructBitField64(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField64(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField64Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 36, self.RULE_dataStructBitField64)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 586
+ localctx.D = self.match(VfrSyntaxParser.Uint64)
+ self.state = 588
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 587
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 590
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 591
+ self.match(VfrSyntaxParser.Number)
+ self.state = 592
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField32Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField32
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField32" ):
+ return visitor.visitDataStructBitField32(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField32(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField32Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 38, self.RULE_dataStructBitField32)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 594
+ localctx.D = self.match(VfrSyntaxParser.Uint32)
+ self.state = 596
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 595
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 598
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 599
+ self.match(VfrSyntaxParser.Number)
+ self.state = 600
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField16Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField16
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField16" ):
+ return visitor.visitDataStructBitField16(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField16(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField16Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 40, self.RULE_dataStructBitField16)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 602
+ localctx.D = self.match(VfrSyntaxParser.Uint16)
+ self.state = 604
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 603
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 606
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 607
+ self.match(VfrSyntaxParser.Number)
+ self.state = 608
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DataStructBitField8Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, FieldInUnion=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.FieldInUnion = None
+ self.D = None # Token
+ self.N = None # Token
+ self.FieldInUnion = FieldInUnion
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dataStructBitField8
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDataStructBitField8" ):
+ return visitor.visitDataStructBitField8(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dataStructBitField8(self, FieldInUnion):
+
+ localctx = VfrSyntaxParser.DataStructBitField8Context(self, self._ctx, self.state, FieldInUnion)
+ self.enterRule(localctx, 42, self.RULE_dataStructBitField8)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 610
+ localctx.D = self.match(VfrSyntaxParser.Uint8)
+ self.state = 612
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.StringIdentifier:
+ self.state = 611
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+
+
+ self.state = 614
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 615
+ self.match(VfrSyntaxParser.Number)
+ self.state = 616
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormSetDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_FORM_SET_OP)
+
+ def FormSet(self):
+ return self.getToken(VfrSyntaxParser.FormSet, 0)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Title(self):
+ return self.getToken(VfrSyntaxParser.Title, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def vfrFormSetList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
+
+
+ def EndFormSet(self):
+ return self.getToken(VfrSyntaxParser.EndFormSet, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def ClassGuid(self):
+ return self.getToken(VfrSyntaxParser.ClassGuid, 0)
+
+ def classguidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ClassguidDefinitionContext,0)
+
+
+ def Class(self):
+ return self.getToken(VfrSyntaxParser.Class, 0)
+
+ def classDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ClassDefinitionContext,0)
+
+
+ def Subclass(self):
+ return self.getToken(VfrSyntaxParser.Subclass, 0)
+
+ def subclassDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SubclassDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormSetDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormSetDefinition" ):
+ return visitor.visitVfrFormSetDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormSetDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrFormSetDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 44, self.RULE_vfrFormSetDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 618
+ self.match(VfrSyntaxParser.FormSet)
+ self.state = 619
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 620
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 621
+ self.guidDefinition()
+ self.state = 622
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 623
+ self.match(VfrSyntaxParser.Title)
+ self.state = 624
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 625
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 626
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 627
+ self.match(VfrSyntaxParser.Number)
+ self.state = 628
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 629
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 630
+ self.match(VfrSyntaxParser.Help)
+ self.state = 631
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 632
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 633
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 634
+ self.match(VfrSyntaxParser.Number)
+ self.state = 635
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 636
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 642
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.ClassGuid:
+ self.state = 637
+ self.match(VfrSyntaxParser.ClassGuid)
+ self.state = 638
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 639
+ self.classguidDefinition(localctx.Node)
+ self.state = 640
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 649
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Class:
+ self.state = 644
+ self.match(VfrSyntaxParser.Class)
+ self.state = 645
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 646
+ self.classDefinition()
+ self.state = 647
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 656
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Subclass:
+ self.state = 651
+ self.match(VfrSyntaxParser.Subclass)
+ self.state = 652
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 653
+ self.subclassDefinition()
+ self.state = 654
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 658
+ self.vfrFormSetList(localctx.Node)
+ self.state = 659
+ self.match(VfrSyntaxParser.EndFormSet)
+ self.state = 660
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ClassguidDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.GuidList = []
+ self.Node = Node
+
+ def guidDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_classguidDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitClassguidDefinition" ):
+ return visitor.visitClassguidDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def classguidDefinition(self, Node):
+
+ localctx = VfrSyntaxParser.ClassguidDefinitionContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 46, self.RULE_classguidDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 662
+ self.guidDefinition()
+ self.state = 665
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
+ if la_ == 1:
+ self.state = 663
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 664
+ self.guidDefinition()
+
+
+ self.state = 669
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
+ if la_ == 1:
+ self.state = 667
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 668
+ self.guidDefinition()
+
+
+ self.state = 673
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 671
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 672
+ self.guidDefinition()
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ClassDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
+
+ def validClassNames(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ValidClassNamesContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ValidClassNamesContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_classDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitClassDefinition" ):
+ return visitor.visitClassDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def classDefinition(self):
+
+ localctx = VfrSyntaxParser.ClassDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 48, self.RULE_classDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 675
+ self.validClassNames()
+ self.state = 680
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 676
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 677
+ self.validClassNames()
+ self.state = 682
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ValidClassNamesContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ClassName = 0
+
+ def ClassNonDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassNonDevice, 0)
+
+ def ClassDiskDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassDiskDevice, 0)
+
+ def ClassVideoDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassVideoDevice, 0)
+
+ def ClassNetworkDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassNetworkDevice, 0)
+
+ def ClassInputDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassInputDevice, 0)
+
+ def ClassOnBoardDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassOnBoardDevice, 0)
+
+ def ClassOtherDevice(self):
+ return self.getToken(VfrSyntaxParser.ClassOtherDevice, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_validClassNames
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitValidClassNames" ):
+ return visitor.visitValidClassNames(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def validClassNames(self):
+
+ localctx = VfrSyntaxParser.ValidClassNamesContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 50, self.RULE_validClassNames)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SubclassDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
+
+ def SubclassSetupApplication(self):
+ return self.getToken(VfrSyntaxParser.SubclassSetupApplication, 0)
+
+ def SubclassGeneralApplication(self):
+ return self.getToken(VfrSyntaxParser.SubclassGeneralApplication, 0)
+
+ def SubclassFrontPage(self):
+ return self.getToken(VfrSyntaxParser.SubclassFrontPage, 0)
+
+ def SubclassSingleUse(self):
+ return self.getToken(VfrSyntaxParser.SubclassSingleUse, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_subclassDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSubclassDefinition" ):
+ return visitor.visitSubclassDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def subclassDefinition(self):
+
+ localctx = VfrSyntaxParser.SubclassDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 52, self.RULE_subclassDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormSetListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrFormSet(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormSetContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormSetList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormSetList" ):
+ return visitor.visitVfrFormSetList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormSetList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrFormSetListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 54, self.RULE_vfrFormSetList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 687
+ self.vfrFormSet()
+ self.state = 692
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormSetContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrFormDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormDefinitionContext,0)
+
+
+ def vfrFormMapDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormMapDefinitionContext,0)
+
+
+ def vfrStatementImage(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
+
+
+ def vfrStatementVarStoreLinear(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreLinearContext,0)
+
+
+ def vfrStatementVarStoreEfi(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreEfiContext,0)
+
+
+ def vfrStatementVarStoreNameValue(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreNameValueContext,0)
+
+
+ def vfrStatementDefaultStore(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultStoreContext,0)
+
+
+ def vfrStatementDisableIfFormSet(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfFormSetContext,0)
+
+
+ def vfrStatementSuppressIfFormSet(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfFormSetContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormSet
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormSet" ):
+ return visitor.visitVfrFormSet(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormSet(self):
+
+ localctx = VfrSyntaxParser.VfrFormSetContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 56, self.RULE_vfrFormSet)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 703
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Form]:
+ self.state = 693
+ self.vfrFormDefinition()
+ pass
+ elif token in [VfrSyntaxParser.FormMap]:
+ self.state = 694
+ self.vfrFormMapDefinition()
+ pass
+ elif token in [VfrSyntaxParser.Image]:
+ self.state = 695
+ self.vfrStatementImage()
+ pass
+ elif token in [VfrSyntaxParser.Varstore]:
+ self.state = 696
+ self.vfrStatementVarStoreLinear()
+ pass
+ elif token in [VfrSyntaxParser.Efivarstore]:
+ self.state = 697
+ self.vfrStatementVarStoreEfi()
+ pass
+ elif token in [VfrSyntaxParser.NameValueVarStore]:
+ self.state = 698
+ self.vfrStatementVarStoreNameValue()
+ pass
+ elif token in [VfrSyntaxParser.DefaultStore]:
+ self.state = 699
+ self.vfrStatementDefaultStore()
+ pass
+ elif token in [VfrSyntaxParser.DisableIf]:
+ self.state = 700
+ self.vfrStatementDisableIfFormSet()
+ pass
+ elif token in [VfrSyntaxParser.SuppressIf]:
+ self.state = 701
+ self.vfrStatementSuppressIfFormSet()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.state = 702
+ self.vfrStatementExtension()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDefaultStoreContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)
+ self.N = None # Token
+ self.S = None # Token
+ self.A = None # Token
+
+ def DefaultStore(self):
+ return self.getToken(VfrSyntaxParser.DefaultStore, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Attribute(self):
+ return self.getToken(VfrSyntaxParser.Attribute, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDefaultStore
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDefaultStore" ):
+ return visitor.visitVfrStatementDefaultStore(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDefaultStore(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDefaultStoreContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 58, self.RULE_vfrStatementDefaultStore)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 705
+ self.match(VfrSyntaxParser.DefaultStore)
+ self.state = 706
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 707
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 708
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 709
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 710
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 711
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 712
+ localctx.S = self.match(VfrSyntaxParser.Number)
+ self.state = 713
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 718
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 714
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 715
+ self.match(VfrSyntaxParser.Attribute)
+ self.state = 716
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 717
+ localctx.A = self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 720
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarStoreLinearContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_VARSTORE_OP)
+ self.TN = None # Token
+ self.ID = None # Token
+ self.SN = None # Token
+
+ def Varstore(self):
+ return self.getToken(VfrSyntaxParser.Varstore, 0)
+
+ def Name(self):
+ return self.getToken(VfrSyntaxParser.Name, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarStoreLinear
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarStoreLinear" ):
+ return visitor.visitVfrStatementVarStoreLinear(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarStoreLinear(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarStoreLinearContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 60, self.RULE_vfrStatementVarStoreLinear)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 722
+ self.match(VfrSyntaxParser.Varstore)
+ self.state = 739
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 723
+ localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 724
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint8]:
+ self.state = 725
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 726
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint16]:
+ self.state = 727
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 728
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint32]:
+ self.state = 729
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 730
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint64]:
+ self.state = 731
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 732
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_DATE]:
+ self.state = 733
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 734
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_TIME]:
+ self.state = 735
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 736
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_REF]:
+ self.state = 737
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 738
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 745
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 741
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 742
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 743
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 744
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 747
+ self.match(VfrSyntaxParser.Name)
+ self.state = 748
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 749
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 750
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 751
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 752
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 753
+ self.guidDefinition()
+ self.state = 754
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarStoreEfiContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)
+ self.TN = None # Token
+ self.ID = None # Token
+ self.SN = None # Token
+ self.VN = None # Token
+ self.N = None # Token
+
+ def Efivarstore(self):
+ return self.getToken(VfrSyntaxParser.Efivarstore, 0)
+
+ def Attribute(self):
+ return self.getToken(VfrSyntaxParser.Attribute, 0)
+
+ def vfrVarStoreEfiAttr(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrVarStoreEfiAttrContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrVarStoreEfiAttrContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def Name(self):
+ return self.getToken(VfrSyntaxParser.Name, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def VarSize(self):
+ return self.getToken(VfrSyntaxParser.VarSize, 0)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarStoreEfi
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarStoreEfi" ):
+ return visitor.visitVfrStatementVarStoreEfi(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarStoreEfi(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarStoreEfiContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 62, self.RULE_vfrStatementVarStoreEfi)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 756
+ self.match(VfrSyntaxParser.Efivarstore)
+ self.state = 773
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 757
+ localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 758
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint8]:
+ self.state = 759
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 760
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint16]:
+ self.state = 761
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 762
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint32]:
+ self.state = 763
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 764
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Uint64]:
+ self.state = 765
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 766
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_DATE]:
+ self.state = 767
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 768
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_TIME]:
+ self.state = 769
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 770
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_REF]:
+ self.state = 771
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 772
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 779
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 775
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 776
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 777
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 778
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 781
+ self.match(VfrSyntaxParser.Attribute)
+ self.state = 782
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 783
+ self.vfrVarStoreEfiAttr()
+ self.state = 788
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 784
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 785
+ self.vfrVarStoreEfiAttr()
+ self.state = 790
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 791
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 807
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
+ if la_ == 1:
+ self.state = 792
+ self.match(VfrSyntaxParser.Name)
+ self.state = 793
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 794
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 795
+ self.match(VfrSyntaxParser.Comma)
+ pass
+
+ elif la_ == 2:
+ self.state = 796
+ self.match(VfrSyntaxParser.Name)
+ self.state = 797
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 798
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 799
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 800
+ localctx.VN = self.match(VfrSyntaxParser.Number)
+ self.state = 801
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 802
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 803
+ self.match(VfrSyntaxParser.VarSize)
+ self.state = 804
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 805
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 806
+ self.match(VfrSyntaxParser.Comma)
+ pass
+
+
+ self.state = 809
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 810
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 811
+ self.guidDefinition()
+ self.state = 812
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrVarStoreEfiAttrContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Attr = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrVarStoreEfiAttr
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrVarStoreEfiAttr" ):
+ return visitor.visitVfrVarStoreEfiAttr(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrVarStoreEfiAttr(self):
+
+ localctx = VfrSyntaxParser.VfrVarStoreEfiAttrContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 64, self.RULE_vfrVarStoreEfiAttr)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 814
+ self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarStoreNameValueContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)
+ self.SN = None # Token
+ self.ID = None # Token
+
+ def NameValueVarStore(self):
+ return self.getToken(VfrSyntaxParser.NameValueVarStore, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def Name(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Name)
+ else:
+ return self.getToken(VfrSyntaxParser.Name, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarStoreNameValue
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarStoreNameValue" ):
+ return visitor.visitVfrStatementVarStoreNameValue(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarStoreNameValue(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarStoreNameValueContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 66, self.RULE_vfrStatementVarStoreNameValue)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 816
+ self.match(VfrSyntaxParser.NameValueVarStore)
+ self.state = 817
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 818
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 823
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 819
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 820
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 821
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 822
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 832
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while True:
+ self.state = 825
+ self.match(VfrSyntaxParser.Name)
+ self.state = 826
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 827
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 828
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 829
+ self.match(VfrSyntaxParser.Number)
+ self.state = 830
+ self.match(VfrSyntaxParser.CloseParen)
+ 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 = 836
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 837
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 838
+ self.guidDefinition()
+ self.state = 839
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDisableIfFormSetContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
+
+ def DisableIf(self):
+ return self.getToken(VfrSyntaxParser.DisableIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrFormSetList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDisableIfFormSet
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDisableIfFormSet" ):
+ return visitor.visitVfrStatementDisableIfFormSet(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDisableIfFormSet(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDisableIfFormSetContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 68, self.RULE_vfrStatementDisableIfFormSet)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 841
+ self.match(VfrSyntaxParser.DisableIf)
+ self.state = 842
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 843
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 844
+ self.vfrFormSetList(localctx.Node)
+ self.state = 845
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 846
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfFormSetContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrFormSetList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfFormSet
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfFormSet" ):
+ return visitor.visitVfrStatementSuppressIfFormSet(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfFormSet(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfFormSetContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 70, self.RULE_vfrStatementSuppressIfFormSet)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 848
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 849
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 850
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 851
+ self.vfrFormSetList(localctx.Node)
+ self.state = 852
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 853
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GuidSubDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Guid=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Guid = None
+ self.Guid = Guid
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_guidSubDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGuidSubDefinition" ):
+ return visitor.visitGuidSubDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def guidSubDefinition(self, Guid):
+
+ localctx = VfrSyntaxParser.GuidSubDefinitionContext(self, self._ctx, self.state, Guid)
+ self.enterRule(localctx, 72, self.RULE_guidSubDefinition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 855
+ self.match(VfrSyntaxParser.Number)
+ self.state = 856
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 857
+ self.match(VfrSyntaxParser.Number)
+ self.state = 858
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 859
+ self.match(VfrSyntaxParser.Number)
+ self.state = 860
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 861
+ self.match(VfrSyntaxParser.Number)
+ self.state = 862
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 863
+ self.match(VfrSyntaxParser.Number)
+ self.state = 864
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 865
+ self.match(VfrSyntaxParser.Number)
+ self.state = 866
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 867
+ self.match(VfrSyntaxParser.Number)
+ self.state = 868
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 869
+ self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GuidDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode()
+ self.Guid = EFI_GUID()
+
+ def OpenBrace(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenBrace)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenBrace, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def CloseBrace(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseBrace)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseBrace, i)
+
+ def guidSubDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidSubDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_guidDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGuidDefinition" ):
+ return visitor.visitGuidDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def guidDefinition(self):
+
+ localctx = VfrSyntaxParser.GuidDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 74, self.RULE_guidDefinition)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 871
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 872
+ self.match(VfrSyntaxParser.Number)
+ self.state = 873
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 874
+ self.match(VfrSyntaxParser.Number)
+ self.state = 875
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 876
+ self.match(VfrSyntaxParser.Number)
+ self.state = 877
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 883
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.OpenBrace]:
+ self.state = 878
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 879
+ self.guidSubDefinition(localctx.Guid)
+ self.state = 880
+ self.match(VfrSyntaxParser.CloseBrace)
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 882
+ self.guidSubDefinition(localctx.Guid)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 885
+ self.match(VfrSyntaxParser.CloseBrace)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GetStringIdContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.StringId = ''
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_getStringId
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGetStringId" ):
+ return visitor.visitGetStringId(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def getStringId(self):
+
+ localctx = VfrSyntaxParser.GetStringIdContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 76, self.RULE_getStringId)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 887
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 888
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 889
+ self.match(VfrSyntaxParser.Number)
+ self.state = 890
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrQuestionHeaderContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None, QType=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.QType = None
+ self.Node = Node
+ self.QType = QType
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrQuestionHeader
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionHeader" ):
+ return visitor.visitVfrQuestionHeader(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrQuestionHeader(self, Node, 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 = 892
+ self.vfrQuestionBaseInfo(Node, QType)
+ self.state = 893
+ self.vfrStatementHeader(Node)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrQuestionBaseInfoContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None, QType=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ 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.Node = Node
+ self.QType = QType
+
+ def Name(self):
+ return self.getToken(VfrSyntaxParser.Name, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def VarId(self):
+ return self.getToken(VfrSyntaxParser.VarId, 0)
+
+ def vfrStorageVarId(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
+
+
+ def QuestionId(self):
+ return self.getToken(VfrSyntaxParser.QuestionId, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrQuestionBaseInfo
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionBaseInfo" ):
+ return visitor.visitVfrQuestionBaseInfo(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrQuestionBaseInfo(self, Node, 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 = 899
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Name:
+ self.state = 895
+ self.match(VfrSyntaxParser.Name)
+ self.state = 896
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 897
+ localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 898
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 906
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.VarId:
+ self.state = 901
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 902
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 903
+ self.vfrStorageVarId(localctx.BaseInfo, localctx.CheckFlag)
+ self.state = 904
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 912
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.QuestionId:
+ self.state = 908
+ self.match(VfrSyntaxParser.QuestionId)
+ self.state = 909
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 910
+ localctx.ID = self.match(VfrSyntaxParser.Number)
+ self.state = 911
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementHeaderContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementHeader
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementHeader" ):
+ return visitor.visitVfrStatementHeader(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementHeader(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementHeaderContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 82, self.RULE_vfrStatementHeader)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 914
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 915
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 916
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 917
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 918
+ self.match(VfrSyntaxParser.Number)
+ self.state = 919
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 920
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 921
+ self.match(VfrSyntaxParser.Help)
+ self.state = 922
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 923
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 924
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 925
+ self.match(VfrSyntaxParser.Number)
+ self.state = 926
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class QuestionheaderFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.QHFlag = 0
+ self.O = None # Token
+ self.N = None # Token
+ self.L = None # Token
+
+ def ReadOnlyFlag(self):
+ return self.getToken(VfrSyntaxParser.ReadOnlyFlag, 0)
+
+ def InteractiveFlag(self):
+ return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
+
+ def ResetRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
+
+ def RestStyleFlag(self):
+ return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
+
+ def ReconnectRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
+
+ def OptionOnlyFlag(self):
+ return self.getToken(VfrSyntaxParser.OptionOnlyFlag, 0)
+
+ def NVAccessFlag(self):
+ return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
+
+ def LateCheckFlag(self):
+ return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_questionheaderFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitQuestionheaderFlagsField" ):
+ return visitor.visitQuestionheaderFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def questionheaderFlagsField(self):
+
+ localctx = VfrSyntaxParser.QuestionheaderFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 84, self.RULE_questionheaderFlagsField)
+ try:
+ self.state = 936
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.ReadOnlyFlag]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 928
+ self.match(VfrSyntaxParser.ReadOnlyFlag)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 929
+ self.match(VfrSyntaxParser.InteractiveFlag)
+ pass
+ elif token in [VfrSyntaxParser.ResetRequiredFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 930
+ self.match(VfrSyntaxParser.ResetRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 931
+ self.match(VfrSyntaxParser.RestStyleFlag)
+ pass
+ elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 932
+ self.match(VfrSyntaxParser.ReconnectRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.OptionOnlyFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 933
+ localctx.O = self.match(VfrSyntaxParser.OptionOnlyFlag)
+ pass
+ elif token in [VfrSyntaxParser.NVAccessFlag]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 934
+ localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
+ pass
+ elif token in [VfrSyntaxParser.LateCheckFlag]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 935
+ localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStorageVarIdContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, BaseInfo=None, CheckFlag=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.BaseInfo = None
+ self.CheckFlag = None
+ self.VarIdStr = ''
+ self.BaseInfo = BaseInfo
+ self.CheckFlag = CheckFlag
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStorageVarId
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.BaseInfo = ctx.BaseInfo
+ self.CheckFlag = ctx.CheckFlag
+ self.VarIdStr = ctx.VarIdStr
+
+
+
+ class VfrStorageVarIdRule1Context(VfrStorageVarIdContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrStorageVarIdContext
+ super().__init__(parser)
+ self.SN1 = None # Token
+ self.I = None # Token
+ self.copyFrom(ctx)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStorageVarIdRule1" ):
+ return visitor.visitVfrStorageVarIdRule1(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class VfrStorageVarIdRule2Context(VfrStorageVarIdContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrStorageVarIdContext
+ super().__init__(parser)
+ self.SN2 = None # Token
+ self.copyFrom(ctx)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+ def arrayName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStorageVarIdRule2" ):
+ return visitor.visitVfrStorageVarIdRule2(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def vfrStorageVarId(self, BaseInfo, CheckFlag):
+
+ localctx = VfrSyntaxParser.VfrStorageVarIdContext(self, self._ctx, self.state, BaseInfo, CheckFlag)
+ self.enterRule(localctx, 86, self.RULE_vfrStorageVarId)
+ self._la = 0 # Token type
+ try:
+ self.state = 950
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
+ if la_ == 1:
+ localctx = VfrSyntaxParser.VfrStorageVarIdRule1Context(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 938
+ localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 939
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 940
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 941
+ self.match(VfrSyntaxParser.CloseBracket)
+ pass
+
+ elif la_ == 2:
+ localctx = VfrSyntaxParser.VfrStorageVarIdRule2Context(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 942
+ localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 947
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Dot:
+ self.state = 943
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 944
+ self.arrayName()
+ self.state = 949
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrConstantValueFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ValueList = []
+ self.ListType = False
+ self.ValueType = None
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Negative(self):
+ return self.getToken(VfrSyntaxParser.Negative, 0)
+
+ def TrueSymbol(self):
+ return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
+
+ def FalseSymbol(self):
+ return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
+
+ def One(self):
+ return self.getToken(VfrSyntaxParser.One, 0)
+
+ def Ones(self):
+ return self.getToken(VfrSyntaxParser.Ones, 0)
+
+ def Zero(self):
+ return self.getToken(VfrSyntaxParser.Zero, 0)
+
+ def Colon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Colon)
+ else:
+ return self.getToken(VfrSyntaxParser.Colon, i)
+
+ def Slash(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Slash)
+ else:
+ return self.getToken(VfrSyntaxParser.Slash, i)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def OpenBrace(self):
+ return self.getToken(VfrSyntaxParser.OpenBrace, 0)
+
+ def CloseBrace(self):
+ return self.getToken(VfrSyntaxParser.CloseBrace, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrConstantValueField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrConstantValueField" ):
+ return visitor.visitVfrConstantValueField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrConstantValueField(self):
+
+ localctx = VfrSyntaxParser.VfrConstantValueFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 88, self.RULE_vfrConstantValueField)
+ self._la = 0 # Token type
+ try:
+ self.state = 996
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
+ if la_ == 1:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 953
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Negative:
+ self.state = 952
+ self.match(VfrSyntaxParser.Negative)
+
+
+ self.state = 955
+ self.match(VfrSyntaxParser.Number)
+ pass
+
+ elif la_ == 2:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 956
+ self.match(VfrSyntaxParser.TrueSymbol)
+ pass
+
+ elif la_ == 3:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 957
+ self.match(VfrSyntaxParser.FalseSymbol)
+ pass
+
+ elif la_ == 4:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 958
+ self.match(VfrSyntaxParser.One)
+ pass
+
+ elif la_ == 5:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 959
+ self.match(VfrSyntaxParser.Ones)
+ pass
+
+ elif la_ == 6:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 960
+ self.match(VfrSyntaxParser.Zero)
+ pass
+
+ elif la_ == 7:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 961
+ self.match(VfrSyntaxParser.Number)
+ self.state = 962
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 963
+ self.match(VfrSyntaxParser.Number)
+ self.state = 964
+ self.match(VfrSyntaxParser.Colon)
+ self.state = 965
+ self.match(VfrSyntaxParser.Number)
+ pass
+
+ elif la_ == 8:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 966
+ self.match(VfrSyntaxParser.Number)
+ self.state = 967
+ self.match(VfrSyntaxParser.Slash)
+ self.state = 968
+ self.match(VfrSyntaxParser.Number)
+ self.state = 969
+ self.match(VfrSyntaxParser.Slash)
+ self.state = 970
+ self.match(VfrSyntaxParser.Number)
+ pass
+
+ elif la_ == 9:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 971
+ self.match(VfrSyntaxParser.Number)
+ self.state = 972
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 973
+ self.match(VfrSyntaxParser.Number)
+ self.state = 974
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 975
+ self.guidDefinition()
+ self.state = 976
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 977
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 978
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 979
+ self.match(VfrSyntaxParser.Number)
+ self.state = 980
+ self.match(VfrSyntaxParser.CloseParen)
+ pass
+
+ elif la_ == 10:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 982
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 983
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 984
+ self.match(VfrSyntaxParser.Number)
+ self.state = 985
+ self.match(VfrSyntaxParser.CloseParen)
+ pass
+
+ elif la_ == 11:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 986
+ self.match(VfrSyntaxParser.OpenBrace)
+ self.state = 987
+ self.match(VfrSyntaxParser.Number)
+ self.state = 992
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Comma:
+ self.state = 988
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 989
+ self.match(VfrSyntaxParser.Number)
+ self.state = 994
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 995
+ self.match(VfrSyntaxParser.CloseBrace)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrImageTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_IMAGE_OP)
+
+ def Image(self):
+ return self.getToken(VfrSyntaxParser.Image, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrImageTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrImageTag" ):
+ return visitor.visitVfrImageTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrImageTag(self):
+
+ localctx = VfrSyntaxParser.VfrImageTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 90, self.RULE_vfrImageTag)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 998
+ self.match(VfrSyntaxParser.Image)
+ self.state = 999
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1000
+ self.match(VfrSyntaxParser.T__6)
+ self.state = 1001
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1002
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1003
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrLockedTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_LOCKED_OP)
+
+ def Locked(self):
+ return self.getToken(VfrSyntaxParser.Locked, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrLockedTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrLockedTag" ):
+ return visitor.visitVfrLockedTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrLockedTag(self):
+
+ localctx = VfrSyntaxParser.VfrLockedTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 92, self.RULE_vfrLockedTag)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1005
+ self.match(VfrSyntaxParser.Locked)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrImageTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
+
+
+ def vfrLockedTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatTag" ):
+ return visitor.visitVfrStatementStatTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatTag(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 94, self.RULE_vfrStatementStatTag)
+ try:
+ self.state = 1009
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Image]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1007
+ self.vfrImageTag()
+ pass
+ elif token in [VfrSyntaxParser.Locked]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1008
+ self.vfrLockedTag()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatTagListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrStatementStatTag(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatTagContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatTagList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatTagList" ):
+ return visitor.visitVfrStatementStatTagList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatTagList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementStatTagListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 96, self.RULE_vfrStatementStatTagList)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1011
+ self.vfrStatementStatTag()
+ self.state = 1016
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 1012
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1013
+ self.vfrStatementStatTag()
+ self.state = 1018
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_FORM_OP)
+
+ def Form(self):
+ return self.getToken(VfrSyntaxParser.Form, 0)
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Title(self):
+ return self.getToken(VfrSyntaxParser.Title, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndForm(self):
+ return self.getToken(VfrSyntaxParser.EndForm, 0)
+
+ def vfrForm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormDefinition" ):
+ return visitor.visitVfrFormDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrFormDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 98, self.RULE_vfrFormDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1019
+ self.match(VfrSyntaxParser.Form)
+ self.state = 1020
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1021
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1022
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1023
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1024
+ self.match(VfrSyntaxParser.Title)
+ self.state = 1025
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1026
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1027
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1028
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1029
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1030
+ self.match(VfrSyntaxParser.Semicolon)
+ 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 = 1031
+ self.vfrForm()
+ self.state = 1036
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1037
+ self.match(VfrSyntaxParser.EndForm)
+ self.state = 1038
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementImage(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
+
+
+ def vfrStatementLocked(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLockedContext,0)
+
+
+ def vfrStatementRules(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRulesContext,0)
+
+
+ def vfrStatementDefault(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
+
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def vfrStatementConditional(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
+
+
+ def vfrStatementLabel(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
+
+
+ def vfrStatementBanner(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBannerContext,0)
+
+
+ def vfrStatementInvalid(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def vfrStatementModal(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementModalContext,0)
+
+
+ def vfrStatementRefreshEvent(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrForm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrForm" ):
+ return visitor.visitVfrForm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrForm(self):
+
+ localctx = VfrSyntaxParser.VfrFormContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 100, self.RULE_vfrForm)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1055
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Image]:
+ self.state = 1040
+ self.vfrStatementImage()
+ pass
+ elif token in [VfrSyntaxParser.Locked]:
+ self.state = 1041
+ self.vfrStatementLocked()
+ pass
+ elif token in [VfrSyntaxParser.Rule]:
+ self.state = 1042
+ self.vfrStatementRules()
+ pass
+ elif token in [VfrSyntaxParser.Default]:
+ self.state = 1043
+ self.vfrStatementDefault()
+ pass
+ elif token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text, VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ 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 = 1045
+ self.vfrStatementQuestions()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf, VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
+ self.state = 1046
+ self.vfrStatementConditional()
+ pass
+ elif token in [VfrSyntaxParser.Label]:
+ self.state = 1047
+ self.vfrStatementLabel()
+ pass
+ elif token in [VfrSyntaxParser.Banner]:
+ self.state = 1048
+ self.vfrStatementBanner()
+ pass
+ elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden, VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.state = 1049
+ self.vfrStatementInvalid()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.state = 1050
+ self.vfrStatementExtension()
+ pass
+ elif token in [VfrSyntaxParser.Modal]:
+ self.state = 1051
+ self.vfrStatementModal()
+ pass
+ elif token in [VfrSyntaxParser.RefreshGuid]:
+ self.state = 1052
+ self.vfrStatementRefreshEvent()
+ self.state = 1053
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrFormMapDefinitionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_FORM_MAP_OP)
+ self.S1 = None # Token
+
+ def FormMap(self):
+ return self.getToken(VfrSyntaxParser.FormMap, 0)
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def EndForm(self):
+ return self.getToken(VfrSyntaxParser.EndForm, 0)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def MapTitle(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.MapTitle)
+ else:
+ return self.getToken(VfrSyntaxParser.MapTitle, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def MapGuid(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.MapGuid)
+ else:
+ return self.getToken(VfrSyntaxParser.MapGuid, i)
+
+ def guidDefinition(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
+
+
+ def vfrForm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrFormMapDefinition
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrFormMapDefinition" ):
+ return visitor.visitVfrFormMapDefinition(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrFormMapDefinition(self):
+
+ localctx = VfrSyntaxParser.VfrFormMapDefinitionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 102, self.RULE_vfrFormMapDefinition)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1057
+ self.match(VfrSyntaxParser.FormMap)
+ self.state = 1058
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1059
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1060
+ localctx.S1 = self.match(VfrSyntaxParser.Number)
+ self.state = 1061
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1076
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.MapTitle:
+ self.state = 1062
+ self.match(VfrSyntaxParser.MapTitle)
+ self.state = 1063
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1064
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1065
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1066
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1067
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1068
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1069
+ self.match(VfrSyntaxParser.MapGuid)
+ self.state = 1070
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1071
+ self.guidDefinition()
+ self.state = 1072
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1078
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ 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 = 1079
+ self.vfrForm()
+ self.state = 1084
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1085
+ self.match(VfrSyntaxParser.EndForm)
+ self.state = 1086
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementImageContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrImageTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementImage
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementImage" ):
+ return visitor.visitVfrStatementImage(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementImage(self):
+
+ localctx = VfrSyntaxParser.VfrStatementImageContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 104, self.RULE_vfrStatementImage)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1088
+ self.vfrImageTag()
+ self.state = 1089
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementLockedContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrLockedTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementLocked
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementLocked" ):
+ return visitor.visitVfrStatementLocked(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementLocked(self):
+
+ localctx = VfrSyntaxParser.VfrStatementLockedContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 106, self.RULE_vfrStatementLocked)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1091
+ self.vfrLockedTag()
+ self.state = 1092
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementRulesContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_RULE_OP)
+
+ def Rule(self):
+ return self.getToken(VfrSyntaxParser.Rule, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndRule(self):
+ return self.getToken(VfrSyntaxParser.EndRule, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRules
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRules" ):
+ return visitor.visitVfrStatementRules(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRules(self):
+
+ localctx = VfrSyntaxParser.VfrStatementRulesContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 108, self.RULE_vfrStatementRules)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1094
+ self.match(VfrSyntaxParser.Rule)
+ self.state = 1095
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1096
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1097
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 1098
+ self.match(VfrSyntaxParser.EndRule)
+ self.state = 1099
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementSubTitle(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleContext,0)
+
+
+ def vfrStatementStaticText(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStaticTextContext,0)
+
+
+ def vfrStatementCrossReference(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCrossReferenceContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStat" ):
+ return visitor.visitVfrStatementStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 110, self.RULE_vfrStatementStat)
+ try:
+ self.state = 1104
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Subtitle]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1101
+ self.vfrStatementSubTitle()
+ pass
+ elif token in [VfrSyntaxParser.Text]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1102
+ self.vfrStatementStaticText()
+ pass
+ elif token in [VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1103
+ self.vfrStatementCrossReference()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSubTitleContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_SUBTITLE_OP)
+
+ def Subtitle(self):
+ return self.getToken(VfrSyntaxParser.Subtitle, 0)
+
+ def Text(self):
+ return self.getToken(VfrSyntaxParser.Text, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def EndSubtitle(self):
+ return self.getToken(VfrSyntaxParser.EndSubtitle, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def vfrSubtitleFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrSubtitleFlagsContext,0)
+
+
+ def vfrStatementStatTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
+
+
+ def vfrStatementSubTitleComponent(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementSubTitleComponentContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleComponentContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSubTitle
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSubTitle" ):
+ return visitor.visitVfrStatementSubTitle(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSubTitle(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSubTitleContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 112, self.RULE_vfrStatementSubTitle)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1106
+ self.match(VfrSyntaxParser.Subtitle)
+ self.state = 1107
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1108
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1109
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1110
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1111
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1112
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1117
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
+ if la_ == 1:
+ self.state = 1113
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1114
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1115
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1116
+ self.vfrSubtitleFlags()
+
+
+ self.state = 1139
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
+ if la_ == 1:
+ self.state = 1121
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1119
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1120
+ self.vfrStatementStatTagList(localctx.Node)
+
+
+ self.state = 1123
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+
+ elif la_ == 2:
+ self.state = 1126
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
+ if la_ == 1:
+ self.state = 1124
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1125
+ self.vfrStatementStatTagList(localctx.Node)
+
+
+ self.state = 1135
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1128
+ self.match(VfrSyntaxParser.Comma)
+ 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 = 1129
+ self.vfrStatementSubTitleComponent()
+ self.state = 1134
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+
+
+ self.state = 1137
+ self.match(VfrSyntaxParser.EndSubtitle)
+ self.state = 1138
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSubTitleComponentContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSubTitleComponent
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSubTitleComponent" ):
+ return visitor.visitVfrStatementSubTitleComponent(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSubTitleComponent(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSubTitleComponentContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 114, self.RULE_vfrStatementSubTitleComponent)
+ try:
+ self.state = 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 = 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 = 1142
+ self.vfrStatementQuestions()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrSubtitleFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.SubFlags = 0
+
+ def subtitleFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.SubtitleFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.SubtitleFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrSubtitleFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrSubtitleFlags" ):
+ return visitor.visitVfrSubtitleFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrSubtitleFlags(self):
+
+ localctx = VfrSyntaxParser.VfrSubtitleFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 116, self.RULE_vfrSubtitleFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1145
+ self.subtitleFlagsField()
+ self.state = 1150
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1146
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1147
+ self.subtitleFlagsField()
+ self.state = 1152
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SubtitleFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_subtitleFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSubtitleFlagsField" ):
+ return visitor.visitSubtitleFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def subtitleFlagsField(self):
+
+ localctx = VfrSyntaxParser.SubtitleFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 118, self.RULE_subtitleFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1153
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.T__7 or _la==VfrSyntaxParser.Number):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStaticTextContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_TEXT_OP)
+ self.S1 = None # Token
+ self.S2 = None # Token
+ self.S3 = None # Token
+ self.F = None # Token
+ self.S4 = None # Token
+
+ def Text(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Text)
+ else:
+ return self.getToken(VfrSyntaxParser.Text, i)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def staticTextFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.StaticTextFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.StaticTextFlagsFieldContext,i)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def vfrStatementStatTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStaticText
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStaticText" ):
+ return visitor.visitVfrStatementStaticText(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStaticText(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStaticTextContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 120, self.RULE_vfrStatementStaticText)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1155
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1156
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1157
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1158
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1159
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1160
+ localctx.S1 = self.match(VfrSyntaxParser.Number)
+ self.state = 1161
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1162
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1163
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1164
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1165
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1166
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1167
+ localctx.S2 = self.match(VfrSyntaxParser.Number)
+ self.state = 1168
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1176
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
+ if la_ == 1:
+ self.state = 1169
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1170
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1171
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1172
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1173
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1174
+ localctx.S3 = self.match(VfrSyntaxParser.Number)
+ self.state = 1175
+ self.match(VfrSyntaxParser.CloseParen)
+
+
+ self.state = 1194
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
+ if la_ == 1:
+ self.state = 1178
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1179
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1180
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1181
+ self.staticTextFlagsField()
+ self.state = 1186
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1182
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1183
+ self.staticTextFlagsField()
+ self.state = 1188
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1189
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1190
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1191
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1192
+ localctx.S4 = self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 1198
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1196
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1197
+ self.vfrStatementStatTagList(localctx.Node)
+
+
+ self.state = 1200
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class StaticTextFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_staticTextFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStaticTextFlagsField" ):
+ return visitor.visitStaticTextFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def staticTextFlagsField(self):
+
+ localctx = VfrSyntaxParser.StaticTextFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 122, self.RULE_staticTextFlagsField)
+ try:
+ self.state = 1204
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ 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 = 1203
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementCrossReferenceContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementGoto(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGotoContext,0)
+
+
+ def vfrStatementResetButton(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementResetButtonContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementCrossReference
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementCrossReference" ):
+ return visitor.visitVfrStatementCrossReference(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementCrossReference(self):
+
+ localctx = VfrSyntaxParser.VfrStatementCrossReferenceContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 124, self.RULE_vfrStatementCrossReference)
+ try:
+ self.state = 1208
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Goto]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1206
+ self.vfrStatementGoto()
+ pass
+ elif token in [VfrSyntaxParser.ResetButton]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1207
+ self.vfrStatementResetButton()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGotoContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = 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)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def vfrGotoFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrGotoFlagsContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def DevicePath(self):
+ return self.getToken(VfrSyntaxParser.DevicePath, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def FormSetGuid(self):
+ return self.getToken(VfrSyntaxParser.FormSetGuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Question(self):
+ return self.getToken(VfrSyntaxParser.Question, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGoto
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGoto" ):
+ return visitor.visitVfrStatementGoto(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGoto(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGotoContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 126, self.RULE_vfrStatementGoto)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1210
+ self.match(VfrSyntaxParser.Goto)
+ self.state = 1258
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.DevicePath]:
+ self.state = 1211
+ self.match(VfrSyntaxParser.DevicePath)
+ self.state = 1212
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1213
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1214
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1215
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1216
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1217
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1218
+ self.match(VfrSyntaxParser.FormSetGuid)
+ self.state = 1219
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1220
+ self.guidDefinition()
+ self.state = 1221
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1222
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1223
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1224
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1225
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1226
+ self.match(VfrSyntaxParser.Question)
+ self.state = 1227
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1228
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1229
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.FormSetGuid]:
+ self.state = 1231
+ self.match(VfrSyntaxParser.FormSetGuid)
+ self.state = 1232
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1233
+ self.guidDefinition()
+ self.state = 1234
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1235
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1236
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1237
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1238
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1239
+ self.match(VfrSyntaxParser.Question)
+ self.state = 1240
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1241
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1242
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.FormId]:
+ self.state = 1244
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 1245
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1246
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1247
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1248
+ self.match(VfrSyntaxParser.Question)
+ self.state = 1249
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1254
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 1250
+ localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1251
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 1252
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1253
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ 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 = 1260
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 1265
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
+ if la_ == 1:
+ self.state = 1261
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1262
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1263
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1264
+ self.vfrGotoFlags()
+
+
+ self.state = 1271
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
+ if la_ == 1:
+ self.state = 1267
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1268
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1269
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1270
+ self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 1275
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 1273
+ localctx.E = self.match(VfrSyntaxParser.Comma)
+ self.state = 1274
+ self.vfrStatementQuestionOptionList(localctx.Node)
+
+
+ self.state = 1277
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrGotoFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.GotoFlags = 0
+
+ def gotoFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.GotoFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.GotoFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrGotoFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrGotoFlags" ):
+ return visitor.visitVfrGotoFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrGotoFlags(self):
+
+ 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 = 1279
+ self.gotoFlagsField()
+ self.state = 1284
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1280
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1281
+ self.gotoFlagsField()
+ self.state = 1286
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GotoFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_gotoFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGotoFlagsField" ):
+ return visitor.visitGotoFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def gotoFlagsField(self):
+
+ localctx = VfrSyntaxParser.GotoFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 130, self.RULE_gotoFlagsField)
+ try:
+ self.state = 1289
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ 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 = 1288
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementResetButtonContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_RESET_BUTTON_OP)
+ self.N = None # Token
+
+ def ResetButton(self):
+ return self.getToken(VfrSyntaxParser.ResetButton, 0)
+
+ def DefaultStore(self):
+ return self.getToken(VfrSyntaxParser.DefaultStore, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def EndResetButton(self):
+ return self.getToken(VfrSyntaxParser.EndResetButton, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def vfrStatementStatTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementResetButton
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementResetButton" ):
+ return visitor.visitVfrStatementResetButton(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementResetButton(self):
+
+ localctx = VfrSyntaxParser.VfrStatementResetButtonContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 132, self.RULE_vfrStatementResetButton)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1291
+ self.match(VfrSyntaxParser.ResetButton)
+ self.state = 1292
+ self.match(VfrSyntaxParser.DefaultStore)
+ self.state = 1293
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1294
+ localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1295
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1296
+ self.vfrStatementHeader(localctx.Node)
+ self.state = 1297
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1301
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Image or _la==VfrSyntaxParser.Locked:
+ self.state = 1298
+ self.vfrStatementStatTagList(localctx.Node)
+ self.state = 1299
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1303
+ self.match(VfrSyntaxParser.EndResetButton)
+ self.state = 1304
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementBooleanType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBooleanTypeContext,0)
+
+
+ def vfrStatementDate(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDateContext,0)
+
+
+ def vfrStatementNumericType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericTypeContext,0)
+
+
+ def vfrStatementStringType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringTypeContext,0)
+
+
+ def vfrStatementOrderedList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOrderedListContext,0)
+
+
+ def vfrStatementTime(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementTimeContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestions
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestions" ):
+ return visitor.visitVfrStatementQuestions(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestions(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 134, self.RULE_vfrStatementQuestions)
+ try:
+ self.state = 1312
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.CheckBox, VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1306
+ self.vfrStatementBooleanType()
+ pass
+ elif token in [VfrSyntaxParser.Date]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1307
+ self.vfrStatementDate()
+ pass
+ elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.Numeric]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1308
+ self.vfrStatementNumericType()
+ pass
+ elif token in [VfrSyntaxParser.Password, VfrSyntaxParser.String]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1309
+ self.vfrStatementStringType()
+ pass
+ elif token in [VfrSyntaxParser.OrderedList]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1310
+ self.vfrStatementOrderedList()
+ pass
+ elif token in [VfrSyntaxParser.Time]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1311
+ self.vfrStatementTime()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementStatTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,0)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementInconsistentIf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,0)
+
+
+ def vfrStatementNoSubmitIf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNoSubmitIfContext,0)
+
+
+ def vfrStatementDisableIfQuest(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfQuestContext,0)
+
+
+ def vfrStatementRefresh(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshContext,0)
+
+
+ def vfrStatementVarstoreDevice(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarstoreDeviceContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def vfrStatementRefreshEvent(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0)
+
+
+ def vfrStatementWarningIf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWarningIfContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionTag" ):
+ return visitor.visitVfrStatementQuestionTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionTag(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 136, self.RULE_vfrStatementQuestionTag)
+ try:
+ self.state = 1325
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Image, VfrSyntaxParser.Locked]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1314
+ self.vfrStatementStatTag()
+ self.state = 1315
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.InconsistentIf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1317
+ self.vfrStatementInconsistentIf()
+ pass
+ elif token in [VfrSyntaxParser.NoSubmitIf]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1318
+ self.vfrStatementNoSubmitIf()
+ pass
+ elif token in [VfrSyntaxParser.DisableIf]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1319
+ self.vfrStatementDisableIfQuest()
+ pass
+ elif token in [VfrSyntaxParser.Refresh]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1320
+ self.vfrStatementRefresh()
+ pass
+ elif token in [VfrSyntaxParser.VarstoreDevice]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1321
+ self.vfrStatementVarstoreDevice()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1322
+ self.vfrStatementExtension()
+ pass
+ elif token in [VfrSyntaxParser.RefreshGuid]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1323
+ self.vfrStatementRefreshEvent()
+ pass
+ elif token in [VfrSyntaxParser.WarningIf]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 1324
+ self.vfrStatementWarningIf()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInconsistentIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
+
+ def InconsistentIf(self):
+ return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInconsistentIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInconsistentIf" ):
+ return visitor.visitVfrStatementInconsistentIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInconsistentIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInconsistentIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 138, self.RULE_vfrStatementInconsistentIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1327
+ self.match(VfrSyntaxParser.InconsistentIf)
+ self.state = 1328
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1329
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1330
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1331
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1332
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1333
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1334
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1347
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1335
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1336
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1337
+ self.flagsField()
+ self.state = 1342
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1338
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1339
+ self.flagsField()
+ self.state = 1344
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1345
+ self.match(VfrSyntaxParser.Comma)
+
+
+ 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,92,self._ctx)
+ if la_ == 1:
+ self.state = 1351
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementNoSubmitIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)
+
+ def NoSubmitIf(self):
+ return self.getToken(VfrSyntaxParser.NoSubmitIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementNoSubmitIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementNoSubmitIf" ):
+ return visitor.visitVfrStatementNoSubmitIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementNoSubmitIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementNoSubmitIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 140, self.RULE_vfrStatementNoSubmitIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1354
+ self.match(VfrSyntaxParser.NoSubmitIf)
+ self.state = 1355
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1356
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1357
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1358
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1359
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1360
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1361
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1374
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1362
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1363
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1364
+ self.flagsField()
+ self.state = 1369
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1365
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1366
+ self.flagsField()
+ self.state = 1371
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1372
+ self.match(VfrSyntaxParser.Comma)
+
+
+ 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,95,self._ctx)
+ if la_ == 1:
+ self.state = 1378
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDisableIfQuestContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
+
+ def DisableIf(self):
+ return self.getToken(VfrSyntaxParser.DisableIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDisableIfQuest
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDisableIfQuest" ):
+ return visitor.visitVfrStatementDisableIfQuest(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDisableIfQuest(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDisableIfQuestContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 142, self.RULE_vfrStatementDisableIfQuest)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1381
+ self.match(VfrSyntaxParser.DisableIf)
+ self.state = 1382
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 1383
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1384
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1385
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1387
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
+ if la_ == 1:
+ self.state = 1386
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementRefreshContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_REFRESH_OP)
+
+ def Refresh(self):
+ return self.getToken(VfrSyntaxParser.Refresh, 0)
+
+ def Interval(self):
+ return self.getToken(VfrSyntaxParser.Interval, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRefresh
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRefresh" ):
+ return visitor.visitVfrStatementRefresh(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRefresh(self):
+
+ localctx = VfrSyntaxParser.VfrStatementRefreshContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 144, self.RULE_vfrStatementRefresh)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1389
+ self.match(VfrSyntaxParser.Refresh)
+ self.state = 1390
+ self.match(VfrSyntaxParser.Interval)
+ self.state = 1391
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1392
+ self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementVarstoreDeviceContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)
+
+ def VarstoreDevice(self):
+ return self.getToken(VfrSyntaxParser.VarstoreDevice, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementVarstoreDevice
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementVarstoreDevice" ):
+ return visitor.visitVfrStatementVarstoreDevice(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementVarstoreDevice(self):
+
+ localctx = VfrSyntaxParser.VfrStatementVarstoreDeviceContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 146, self.RULE_vfrStatementVarstoreDevice)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1394
+ self.match(VfrSyntaxParser.VarstoreDevice)
+ self.state = 1395
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1396
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1397
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1398
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1399
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1400
+ self.match(VfrSyntaxParser.Comma)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementRefreshEventContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_REFRESH_ID_OP)
+
+ def RefreshGuid(self):
+ return self.getToken(VfrSyntaxParser.RefreshGuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRefreshEvent
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRefreshEvent" ):
+ return visitor.visitVfrStatementRefreshEvent(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRefreshEvent(self):
+
+ localctx = VfrSyntaxParser.VfrStatementRefreshEventContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 148, self.RULE_vfrStatementRefreshEvent)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1402
+ self.match(VfrSyntaxParser.RefreshGuid)
+ self.state = 1403
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1404
+ self.guidDefinition()
+ self.state = 1405
+ self.match(VfrSyntaxParser.Comma)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementWarningIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_WARNING_IF_OP)
+
+ def WarningIf(self):
+ return self.getToken(VfrSyntaxParser.WarningIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def Timeout(self):
+ return self.getToken(VfrSyntaxParser.Timeout, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementWarningIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementWarningIf" ):
+ return visitor.visitVfrStatementWarningIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementWarningIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementWarningIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 150, self.RULE_vfrStatementWarningIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1407
+ self.match(VfrSyntaxParser.WarningIf)
+ self.state = 1408
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1409
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1410
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1411
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1412
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1413
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1414
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1419
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Timeout:
+ self.state = 1415
+ self.match(VfrSyntaxParser.Timeout)
+ self.state = 1416
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1417
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1418
+ self.match(VfrSyntaxParser.Comma)
+
+
+ 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,98,self._ctx)
+ if la_ == 1:
+ self.state = 1423
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionTagListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrStatementQuestionTag(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionTagContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionTagList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionTagList" ):
+ return visitor.visitVfrStatementQuestionTagList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionTagList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionTagListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 152, self.RULE_vfrStatementQuestionTagList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 1426
+ self.vfrStatementQuestionTag()
+ self.state = 1431
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionOptionTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementSuppressIfQuest(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfQuestContext,0)
+
+
+ def vfrStatementGrayOutIfQuest(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfQuestContext,0)
+
+
+ def vfrStatementValue(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
+
+
+ def vfrStatementDefault(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
+
+
+ def vfrStatementOptions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOptionsContext,0)
+
+
+ def vfrStatementRead(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementReadContext,0)
+
+
+ def vfrStatementWrite(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWriteContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionOptionTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionOptionTag" ):
+ return visitor.visitVfrStatementQuestionOptionTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionOptionTag(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionOptionTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 154, self.RULE_vfrStatementQuestionOptionTag)
+ try:
+ self.state = 1439
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.SuppressIf]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1432
+ self.vfrStatementSuppressIfQuest()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1433
+ self.vfrStatementGrayOutIfQuest()
+ pass
+ elif token in [VfrSyntaxParser.Value]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1434
+ self.vfrStatementValue()
+ pass
+ elif token in [VfrSyntaxParser.Default]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1435
+ self.vfrStatementDefault()
+ pass
+ elif token in [VfrSyntaxParser.Option]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1436
+ self.vfrStatementOptions()
+ pass
+ elif token in [VfrSyntaxParser.Read]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1437
+ self.vfrStatementRead()
+ pass
+ elif token in [VfrSyntaxParser.Write]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1438
+ self.vfrStatementWrite()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.N = None # Token
+ self.L = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def InteractiveFlag(self):
+ return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
+
+ def ManufacturingFlag(self):
+ return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
+
+ def DefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
+
+ def ResetRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
+
+ def ReconnectRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
+
+ def NVAccessFlag(self):
+ return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
+
+ def LateCheckFlag(self):
+ return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_flagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFlagsField" ):
+ return visitor.visitFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def flagsField(self):
+
+ localctx = VfrSyntaxParser.FlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 156, self.RULE_flagsField)
+ try:
+ self.state = 1449
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1441
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1442
+ self.match(VfrSyntaxParser.InteractiveFlag)
+ pass
+ elif token in [VfrSyntaxParser.ManufacturingFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1443
+ self.match(VfrSyntaxParser.ManufacturingFlag)
+ pass
+ elif token in [VfrSyntaxParser.DefaultFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1444
+ self.match(VfrSyntaxParser.DefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.ResetRequiredFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1445
+ self.match(VfrSyntaxParser.ResetRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1446
+ self.match(VfrSyntaxParser.ReconnectRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.NVAccessFlag]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1447
+ localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
+ pass
+ elif token in [VfrSyntaxParser.LateCheckFlag]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1448
+ localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfQuestContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfQuest
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfQuest" ):
+ return visitor.visitVfrStatementSuppressIfQuest(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfQuest(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfQuestContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 158, self.RULE_vfrStatementSuppressIfQuest)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1451
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 1452
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 1453
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1466
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1454
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1455
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1456
+ self.flagsField()
+ self.state = 1461
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1457
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1458
+ self.flagsField()
+ self.state = 1463
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1464
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1468
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1469
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1471
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
+ if la_ == 1:
+ self.state = 1470
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGrayOutIfQuestContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def GrayOutIf(self):
+ return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGrayOutIfQuest
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGrayOutIfQuest" ):
+ return visitor.visitVfrStatementGrayOutIfQuest(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGrayOutIfQuest(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGrayOutIfQuestContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 160, self.RULE_vfrStatementGrayOutIfQuest)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1473
+ self.match(VfrSyntaxParser.GrayOutIf)
+ self.state = 1474
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 1475
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 1488
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1476
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1477
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1478
+ self.flagsField()
+ self.state = 1483
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1479
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1480
+ self.flagsField()
+ self.state = 1485
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1486
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1490
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1491
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 1493
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
+ if la_ == 1:
+ self.state = 1492
+ self.match(VfrSyntaxParser.Semicolon)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDefaultContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = 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 Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrConstantValueField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
+
+
+ def vfrStatementValue(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
+
+
+ def DefaultStore(self):
+ return self.getToken(VfrSyntaxParser.DefaultStore, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDefault
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDefault" ):
+ return visitor.visitVfrStatementDefault(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDefault(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDefaultContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 162, self.RULE_vfrStatementDefault)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1495
+ localctx.D = self.match(VfrSyntaxParser.Default)
+
+ self.state = 1503
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Value]:
+ self.state = 1496
+ localctx.V = self.vfrStatementValue()
+ self.state = 1497
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ elif token in [VfrSyntaxParser.T__5]:
+ self.state = 1499
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1500
+ self.vfrConstantValueField()
+ self.state = 1501
+ self.match(VfrSyntaxParser.Comma)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 1509
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.DefaultStore:
+ self.state = 1505
+ self.match(VfrSyntaxParser.DefaultStore)
+ self.state = 1506
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1507
+ localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1508
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementValueContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_VALUE_OP)
+
+ def Value(self):
+ return self.getToken(VfrSyntaxParser.Value, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementValue
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementValue" ):
+ return visitor.visitVfrStatementValue(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementValue(self):
+
+ localctx = VfrSyntaxParser.VfrStatementValueContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 164, self.RULE_vfrStatementValue)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1511
+ self.match(VfrSyntaxParser.Value)
+ self.state = 1512
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1513
+ self.vfrStatementExpression(localctx.Node)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOptionsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementOneOfOption(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfOptionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOptions
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOptions" ):
+ return visitor.visitVfrStatementOptions(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOptions(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOptionsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 166, self.RULE_vfrStatementOptions)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1515
+ self.vfrStatementOneOfOption()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOneOfOptionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = 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)
+
+ def Text(self):
+ return self.getToken(VfrSyntaxParser.Text, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Value(self):
+ return self.getToken(VfrSyntaxParser.Value, 0)
+
+ def vfrConstantValueField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
+
+
+ def vfrOneOfOptionFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrOneOfOptionFlagsContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def vfrImageTag(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrImageTagContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOneOfOption
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOneOfOption" ):
+ return visitor.visitVfrStatementOneOfOption(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOneOfOption(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOneOfOptionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 168, self.RULE_vfrStatementOneOfOption)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1517
+ self.match(VfrSyntaxParser.Option)
+ self.state = 1518
+ self.match(VfrSyntaxParser.Text)
+ self.state = 1519
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1520
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1521
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1522
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1523
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1524
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1525
+ self.match(VfrSyntaxParser.Value)
+ self.state = 1526
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1527
+ self.vfrConstantValueField()
+ self.state = 1528
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1529
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1530
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1531
+ self.vfrOneOfOptionFlags()
+ self.state = 1536
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
+ if la_ == 1:
+ self.state = 1532
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1533
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1534
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1535
+ localctx.KN = self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 1542
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Comma:
+ self.state = 1538
+ localctx.T = self.match(VfrSyntaxParser.Comma)
+ self.state = 1539
+ self.vfrImageTag()
+ self.state = 1544
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 1545
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrOneOfOptionFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def oneofoptionFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.OneofoptionFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.OneofoptionFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrOneOfOptionFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrOneOfOptionFlags" ):
+ return visitor.visitVfrOneOfOptionFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrOneOfOptionFlags(self):
+
+ localctx = VfrSyntaxParser.VfrOneOfOptionFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 170, self.RULE_vfrOneOfOptionFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1547
+ self.oneofoptionFlagsField()
+ self.state = 1552
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1548
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1549
+ self.oneofoptionFlagsField()
+ self.state = 1554
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class OneofoptionFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.LFlag = 0
+ self.A = None # Token
+ self.L = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def OptionDefault(self):
+ return self.getToken(VfrSyntaxParser.OptionDefault, 0)
+
+ def OptionDefaultMfg(self):
+ return self.getToken(VfrSyntaxParser.OptionDefaultMfg, 0)
+
+ def InteractiveFlag(self):
+ return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
+
+ def ResetRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
+
+ def RestStyleFlag(self):
+ return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
+
+ def ReconnectRequiredFlag(self):
+ return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
+
+ def ManufacturingFlag(self):
+ return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
+
+ def DefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
+
+ def NVAccessFlag(self):
+ return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
+
+ def LateCheckFlag(self):
+ return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_oneofoptionFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitOneofoptionFlagsField" ):
+ return visitor.visitOneofoptionFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def oneofoptionFlagsField(self):
+
+ localctx = VfrSyntaxParser.OneofoptionFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 172, self.RULE_oneofoptionFlagsField)
+ try:
+ self.state = 1566
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1555
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.OptionDefault]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1556
+ self.match(VfrSyntaxParser.OptionDefault)
+ pass
+ elif token in [VfrSyntaxParser.OptionDefaultMfg]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1557
+ self.match(VfrSyntaxParser.OptionDefaultMfg)
+ pass
+ elif token in [VfrSyntaxParser.InteractiveFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1558
+ self.match(VfrSyntaxParser.InteractiveFlag)
+ pass
+ elif token in [VfrSyntaxParser.ResetRequiredFlag]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1559
+ self.match(VfrSyntaxParser.ResetRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.RestStyleFlag]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1560
+ self.match(VfrSyntaxParser.RestStyleFlag)
+ pass
+ elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1561
+ self.match(VfrSyntaxParser.ReconnectRequiredFlag)
+ pass
+ elif token in [VfrSyntaxParser.ManufacturingFlag]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 1562
+ self.match(VfrSyntaxParser.ManufacturingFlag)
+ pass
+ elif token in [VfrSyntaxParser.DefaultFlag]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 1563
+ self.match(VfrSyntaxParser.DefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.NVAccessFlag]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 1564
+ localctx.A = self.match(VfrSyntaxParser.NVAccessFlag)
+ pass
+ elif token in [VfrSyntaxParser.LateCheckFlag]:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 1565
+ localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementReadContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_READ_OP)
+
+ def Read(self):
+ return self.getToken(VfrSyntaxParser.Read, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementRead
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementRead" ):
+ return visitor.visitVfrStatementRead(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementRead(self):
+
+ localctx = VfrSyntaxParser.VfrStatementReadContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 174, self.RULE_vfrStatementRead)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1568
+ self.match(VfrSyntaxParser.Read)
+ self.state = 1569
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 1570
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementWriteContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_WRITE_OP)
+
+ def Write(self):
+ return self.getToken(VfrSyntaxParser.Write, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementWrite
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementWrite" ):
+ return visitor.visitVfrStatementWrite(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementWrite(self):
+
+ localctx = VfrSyntaxParser.VfrStatementWriteContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 176, self.RULE_vfrStatementWrite)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1572
+ self.match(VfrSyntaxParser.Write)
+ self.state = 1573
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 1574
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionOptionListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.Node = Node
+
+ def vfrStatementQuestionOption(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionOptionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionOptionList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionOptionList" ):
+ return visitor.visitVfrStatementQuestionOptionList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionOptionList(self, Node):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionOptionListContext(self, self._ctx, self.state, Node)
+ self.enterRule(localctx, 178, self.RULE_vfrStatementQuestionOptionList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 1576
+ self.vfrStatementQuestionOption()
+ self.state = 1581
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementQuestionOptionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementQuestionTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,0)
+
+
+ def vfrStatementQuestionOptionTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionTagContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementQuestionOption
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementQuestionOption" ):
+ return visitor.visitVfrStatementQuestionOption(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementQuestionOption(self):
+
+ localctx = VfrSyntaxParser.VfrStatementQuestionOptionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 180, self.RULE_vfrStatementQuestionOption)
+ try:
+ self.state = 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 = 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 = 1583
+ self.vfrStatementQuestionOptionTag()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementBooleanTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementCheckBox(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCheckBoxContext,0)
+
+
+ def vfrStatementAction(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementActionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementBooleanType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementBooleanType" ):
+ return visitor.visitVfrStatementBooleanType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementBooleanType(self):
+
+ localctx = VfrSyntaxParser.VfrStatementBooleanTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 182, self.RULE_vfrStatementBooleanType)
+ try:
+ self.state = 1588
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.CheckBox]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1586
+ self.vfrStatementCheckBox()
+ pass
+ elif token in [VfrSyntaxParser.Action]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1587
+ self.vfrStatementAction()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementCheckBoxContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = 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
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndCheckBox(self):
+ return self.getToken(VfrSyntaxParser.EndCheckBox, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def CheckBox(self):
+ return self.getToken(VfrSyntaxParser.CheckBox, 0)
+
+ def vfrCheckBoxFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrCheckBoxFlagsContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementCheckBox
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementCheckBox" ):
+ return visitor.visitVfrStatementCheckBox(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementCheckBox(self):
+
+ localctx = VfrSyntaxParser.VfrStatementCheckBoxContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 184, self.RULE_vfrStatementCheckBox)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 1599
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1594
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1595
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1596
+ self.vfrCheckBoxFlags()
+ self.state = 1597
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1605
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1601
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1602
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1603
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1604
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1607
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1608
+ self.match(VfrSyntaxParser.EndCheckBox)
+ self.state = 1609
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrCheckBoxFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlags = 0
+ self.HFlags = 0
+
+ def checkboxFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.CheckboxFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.CheckboxFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrCheckBoxFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrCheckBoxFlags" ):
+ return visitor.visitVfrCheckBoxFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrCheckBoxFlags(self):
+
+ localctx = VfrSyntaxParser.VfrCheckBoxFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 186, self.RULE_vfrCheckBoxFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1611
+ self.checkboxFlagsField()
+ self.state = 1616
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1612
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1613
+ self.checkboxFlagsField()
+ self.state = 1618
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CheckboxFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlag = 0
+ self.HFlag = 0
+ self.D = None # Token
+ self.M = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def DefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
+
+ def ManufacturingFlag(self):
+ return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
+
+ def CheckBoxDefaultFlag(self):
+ return self.getToken(VfrSyntaxParser.CheckBoxDefaultFlag, 0)
+
+ def CheckBoxDefaultMfgFlag(self):
+ return self.getToken(VfrSyntaxParser.CheckBoxDefaultMfgFlag, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_checkboxFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCheckboxFlagsField" ):
+ return visitor.visitCheckboxFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def checkboxFlagsField(self):
+
+ localctx = VfrSyntaxParser.CheckboxFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 188, self.RULE_checkboxFlagsField)
+ try:
+ self.state = 1625
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1619
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.DefaultFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1620
+ localctx.D = self.match(VfrSyntaxParser.DefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.ManufacturingFlag]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1621
+ localctx.M = self.match(VfrSyntaxParser.ManufacturingFlag)
+ pass
+ elif token in [VfrSyntaxParser.CheckBoxDefaultFlag]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1622
+ self.match(VfrSyntaxParser.CheckBoxDefaultFlag)
+ pass
+ elif token in [VfrSyntaxParser.CheckBoxDefaultMfgFlag]:
+ self.enterOuterAlt(localctx, 5)
+ 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 = 1624
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementActionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_ACTION_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+
+ def Action(self):
+ return self.getToken(VfrSyntaxParser.Action, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Config(self):
+ return self.getToken(VfrSyntaxParser.Config, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def vfrStatementQuestionTagList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagListContext,0)
+
+
+ def EndAction(self):
+ return self.getToken(VfrSyntaxParser.EndAction, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def vfrActionFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrActionFlagsContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementAction
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementAction" ):
+ return visitor.visitVfrStatementAction(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementAction(self):
+
+ localctx = VfrSyntaxParser.VfrStatementActionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 190, self.RULE_vfrStatementAction)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1627
+ self.match(VfrSyntaxParser.Action)
+ self.state = 1628
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 1629
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1635
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1630
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1631
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1632
+ self.vfrActionFlags()
+ self.state = 1633
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1637
+ self.match(VfrSyntaxParser.Config)
+ self.state = 1638
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1639
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1640
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1641
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1642
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1643
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1644
+ self.vfrStatementQuestionTagList(localctx.Node)
+ self.state = 1645
+ self.match(VfrSyntaxParser.EndAction)
+ self.state = 1646
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrActionFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+
+ def actionFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ActionFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ActionFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrActionFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrActionFlags" ):
+ return visitor.visitVfrActionFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrActionFlags(self):
+
+ localctx = VfrSyntaxParser.VfrActionFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 192, self.RULE_vfrActionFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1648
+ self.actionFlagsField()
+ self.state = 1653
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1649
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1650
+ self.actionFlagsField()
+ self.state = 1655
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ActionFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_actionFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitActionFlagsField" ):
+ return visitor.visitActionFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def actionFlagsField(self):
+
+ localctx = VfrSyntaxParser.ActionFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 194, self.RULE_actionFlagsField)
+ try:
+ self.state = 1658
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ 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 = 1657
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementNumericTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementNumeric(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericContext,0)
+
+
+ def vfrStatementOneOf(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementNumericType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementNumericType" ):
+ return visitor.visitVfrStatementNumericType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementNumericType(self):
+
+ localctx = VfrSyntaxParser.VfrStatementNumericTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 196, self.RULE_vfrStatementNumericType)
+ try:
+ self.state = 1662
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Numeric]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1660
+ self.vfrStatementNumeric()
+ pass
+ elif token in [VfrSyntaxParser.OneOf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1661
+ self.vfrStatementOneOf()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementNumericContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_NUMERIC_OP)
+ self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+
+ def Numeric(self):
+ return self.getToken(VfrSyntaxParser.Numeric, 0)
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrSetMinMaxStep(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
+
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndNumeric(self):
+ return self.getToken(VfrSyntaxParser.EndNumeric, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrNumericFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrNumericFlagsContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementNumeric
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementNumeric" ):
+ return visitor.visitVfrStatementNumeric(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementNumeric(self):
+
+ localctx = VfrSyntaxParser.VfrStatementNumericContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 198, self.RULE_vfrStatementNumeric)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 1673
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1668
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1669
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1670
+ self.vfrNumericFlags()
+ self.state = 1671
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1679
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1675
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1676
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1677
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1678
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1681
+ self.vfrSetMinMaxStep(localctx.Node)
+ self.state = 1682
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1683
+ self.match(VfrSyntaxParser.EndNumeric)
+ self.state = 1684
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrSetMinMaxStepContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, Node=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+ self.N1 = None # Token
+ self.I = None # Token
+ self.N2 = None # Token
+ self.A = None # Token
+ self.S = None # Token
+ self.Node = Node
+
+ def Minimum(self):
+ return self.getToken(VfrSyntaxParser.Minimum, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Maximum(self):
+ return self.getToken(VfrSyntaxParser.Maximum, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Step(self):
+ return self.getToken(VfrSyntaxParser.Step, 0)
+
+ def Negative(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Negative)
+ else:
+ return self.getToken(VfrSyntaxParser.Negative, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrSetMinMaxStep
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrSetMinMaxStep" ):
+ return visitor.visitVfrSetMinMaxStep(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrSetMinMaxStep(self, Node):
+
+ 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 = 1686
+ self.match(VfrSyntaxParser.Minimum)
+ self.state = 1687
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1689
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Negative:
+ self.state = 1688
+ localctx.N1 = self.match(VfrSyntaxParser.Negative)
+
+
+ self.state = 1691
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 1692
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1693
+ self.match(VfrSyntaxParser.Maximum)
+ self.state = 1694
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1696
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Negative:
+ self.state = 1695
+ localctx.N2 = self.match(VfrSyntaxParser.Negative)
+
+
+ self.state = 1698
+ localctx.A = self.match(VfrSyntaxParser.Number)
+ self.state = 1699
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1704
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Step:
+ self.state = 1700
+ self.match(VfrSyntaxParser.Step)
+ self.state = 1701
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1702
+ localctx.S = self.match(VfrSyntaxParser.Number)
+ self.state = 1703
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrNumericFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+ self.IsDisplaySpecified = False
+ self.UpdateVarType = False
+
+ def numericFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrNumericFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrNumericFlags" ):
+ return visitor.visitVfrNumericFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrNumericFlags(self):
+
+ localctx = VfrSyntaxParser.VfrNumericFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 202, self.RULE_vfrNumericFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1706
+ self.numericFlagsField()
+ self.state = 1711
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1707
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1708
+ self.numericFlagsField()
+ self.state = 1713
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class NumericFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.IsSetType = False
+ self.IsDisplaySpecified = False
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def NumericSizeOne(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
+
+ def NumericSizeTwo(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
+
+ def NumericSizeFour(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
+
+ def NumericSizeEight(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
+
+ def DisPlayIntDec(self):
+ return self.getToken(VfrSyntaxParser.DisPlayIntDec, 0)
+
+ def DisPlayUIntDec(self):
+ return self.getToken(VfrSyntaxParser.DisPlayUIntDec, 0)
+
+ def DisPlayUIntHex(self):
+ return self.getToken(VfrSyntaxParser.DisPlayUIntHex, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_numericFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitNumericFlagsField" ):
+ return visitor.visitNumericFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def numericFlagsField(self):
+
+ localctx = VfrSyntaxParser.NumericFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 204, self.RULE_numericFlagsField)
+ try:
+ self.state = 1723
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1714
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeOne]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1715
+ self.match(VfrSyntaxParser.NumericSizeOne)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeTwo]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 1716
+ self.match(VfrSyntaxParser.NumericSizeTwo)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeFour]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 1717
+ self.match(VfrSyntaxParser.NumericSizeFour)
+ pass
+ elif token in [VfrSyntaxParser.NumericSizeEight]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 1718
+ self.match(VfrSyntaxParser.NumericSizeEight)
+ pass
+ elif token in [VfrSyntaxParser.DisPlayIntDec]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 1719
+ self.match(VfrSyntaxParser.DisPlayIntDec)
+ pass
+ elif token in [VfrSyntaxParser.DisPlayUIntDec]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 1720
+ self.match(VfrSyntaxParser.DisPlayUIntDec)
+ pass
+ elif token in [VfrSyntaxParser.DisPlayUIntHex]:
+ self.enterOuterAlt(localctx, 8)
+ 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 = 1722
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOneOfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_ONE_OF_OP)
+ self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+
+ def OneOf(self):
+ return self.getToken(VfrSyntaxParser.OneOf, 0)
+
+ def vfrQuestionBaseInfo(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
+
+
+ def vfrStatementHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndOneOf(self):
+ return self.getToken(VfrSyntaxParser.EndOneOf, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrOneofFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrOneofFlagsFieldContext,0)
+
+
+ def vfrSetMinMaxStep(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOneOf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOneOf" ):
+ return visitor.visitVfrStatementOneOf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOneOf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOneOfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 206, self.RULE_vfrStatementOneOf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 1734
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1729
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1730
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1731
+ self.vfrOneofFlagsField()
+ self.state = 1732
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1737
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Minimum:
+ self.state = 1736
+ self.vfrSetMinMaxStep(localctx.Node)
+
+
+ self.state = 1739
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1740
+ self.match(VfrSyntaxParser.EndOneOf)
+ self.state = 1741
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrOneofFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+ self.UpdateVarType = False
+
+ def numericFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrOneofFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrOneofFlagsField" ):
+ return visitor.visitVfrOneofFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrOneofFlagsField(self):
+
+ localctx = VfrSyntaxParser.VfrOneofFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 208, self.RULE_vfrOneofFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1743
+ self.numericFlagsField()
+ self.state = 1748
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1744
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1745
+ self.numericFlagsField()
+ self.state = 1750
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStringTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementString(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringContext,0)
+
+
+ def vfrStatementPassword(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementPasswordContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStringType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStringType" ):
+ return visitor.visitVfrStatementStringType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStringType(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStringTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 210, self.RULE_vfrStatementStringType)
+ try:
+ self.state = 1753
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.String]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1751
+ self.vfrStatementString()
+ pass
+ elif token in [VfrSyntaxParser.Password]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1752
+ self.vfrStatementPassword()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStringContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_STRING_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+ self.Min = None # Token
+ self.Max = None # Token
+
+ def String(self):
+ return self.getToken(VfrSyntaxParser.String, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndString(self):
+ return self.getToken(VfrSyntaxParser.EndString, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def MinSize(self):
+ return self.getToken(VfrSyntaxParser.MinSize, 0)
+
+ def MaxSize(self):
+ return self.getToken(VfrSyntaxParser.MaxSize, 0)
+
+ def vfrStringFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStringFlagsFieldContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementString
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementString" ):
+ return visitor.visitVfrStatementString(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementString(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStringContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 212, self.RULE_vfrStatementString)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1755
+ self.match(VfrSyntaxParser.String)
+ self.state = 1756
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 1757
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1763
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1758
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1759
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1760
+ self.vfrStringFlagsField()
+ self.state = 1761
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1769
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1765
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1766
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1767
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1768
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1771
+ localctx.Min = self.match(VfrSyntaxParser.MinSize)
+ self.state = 1772
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1773
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1774
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1775
+ localctx.Max = self.match(VfrSyntaxParser.MaxSize)
+ self.state = 1776
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1777
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1778
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1779
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1780
+ self.match(VfrSyntaxParser.EndString)
+ self.state = 1781
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStringFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def stringFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.StringFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.StringFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStringFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStringFlagsField" ):
+ return visitor.visitVfrStringFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStringFlagsField(self):
+
+ localctx = VfrSyntaxParser.VfrStringFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 214, self.RULE_vfrStringFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1783
+ self.stringFlagsField()
+ self.state = 1788
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1784
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1785
+ self.stringFlagsField()
+ self.state = 1790
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class StringFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.LFlag = 0
+ self.N = None # Token
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_stringFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStringFlagsField" ):
+ return visitor.visitStringFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def stringFlagsField(self):
+
+ localctx = VfrSyntaxParser.StringFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 216, self.RULE_stringFlagsField)
+ try:
+ self.state = 1794
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1791
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.T__8]:
+ self.enterOuterAlt(localctx, 2)
+ 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 = 1793
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementPasswordContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_PASSWORD_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.F = None # Token
+ self.Min = None # Token
+ self.Max = None # Token
+
+ def Password(self):
+ return self.getToken(VfrSyntaxParser.Password, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndPassword(self):
+ return self.getToken(VfrSyntaxParser.EndPassword, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def MinSize(self):
+ return self.getToken(VfrSyntaxParser.MinSize, 0)
+
+ def MaxSize(self):
+ return self.getToken(VfrSyntaxParser.MaxSize, 0)
+
+ def vfrPasswordFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrPasswordFlagsFieldContext,0)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Encoding(self):
+ return self.getToken(VfrSyntaxParser.Encoding, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementPassword
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementPassword" ):
+ return visitor.visitVfrStatementPassword(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementPassword(self):
+
+ localctx = VfrSyntaxParser.VfrStatementPasswordContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 218, self.RULE_vfrStatementPassword)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1796
+ self.match(VfrSyntaxParser.Password)
+ self.state = 1797
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 1798
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1804
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1799
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1800
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1801
+ self.vfrPasswordFlagsField()
+ self.state = 1802
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1810
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Key:
+ self.state = 1806
+ self.match(VfrSyntaxParser.Key)
+ self.state = 1807
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1808
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1809
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1812
+ localctx.Min = self.match(VfrSyntaxParser.MinSize)
+ self.state = 1813
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1814
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1815
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1816
+ localctx.Max = self.match(VfrSyntaxParser.MaxSize)
+ self.state = 1817
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1818
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1819
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1824
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Encoding:
+ self.state = 1820
+ self.match(VfrSyntaxParser.Encoding)
+ self.state = 1821
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1822
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1823
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1826
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1827
+ self.match(VfrSyntaxParser.EndPassword)
+ self.state = 1828
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrPasswordFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+
+ def passwordFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.PasswordFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.PasswordFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrPasswordFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrPasswordFlagsField" ):
+ return visitor.visitVfrPasswordFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrPasswordFlagsField(self):
+
+ localctx = VfrSyntaxParser.VfrPasswordFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 220, self.RULE_vfrPasswordFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1830
+ self.passwordFlagsField()
+ self.state = 1835
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1831
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1832
+ self.passwordFlagsField()
+ self.state = 1837
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PasswordFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_passwordFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPasswordFlagsField" ):
+ return visitor.visitPasswordFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def passwordFlagsField(self):
+
+ localctx = VfrSyntaxParser.PasswordFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 222, self.RULE_passwordFlagsField)
+ try:
+ self.state = 1840
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ 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 = 1839
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementOrderedListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_ORDERED_LIST_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
+ self.M = None # Token
+ self.F = None # Token
+
+ def OrderedList(self):
+ return self.getToken(VfrSyntaxParser.OrderedList, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def EndList(self):
+ return self.getToken(VfrSyntaxParser.EndList, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def vfrOrderedListFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrOrderedListFlagsContext,0)
+
+
+ def MaxContainers(self):
+ return self.getToken(VfrSyntaxParser.MaxContainers, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementOrderedList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementOrderedList" ):
+ return visitor.visitVfrStatementOrderedList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementOrderedList(self):
+
+ localctx = VfrSyntaxParser.VfrStatementOrderedListContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 224, self.RULE_vfrStatementOrderedList)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1842
+ self.match(VfrSyntaxParser.OrderedList)
+ self.state = 1843
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 1844
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1849
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.MaxContainers:
+ self.state = 1845
+ localctx.M = self.match(VfrSyntaxParser.MaxContainers)
+ self.state = 1846
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1847
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1848
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1856
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1851
+ localctx.F = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1852
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1853
+ self.vfrOrderedListFlags()
+ self.state = 1854
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1858
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ self.state = 1859
+ self.match(VfrSyntaxParser.EndList)
+ self.state = 1860
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrOrderedListFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlags = 0
+ self.LFlags = 0
+
+ def orderedlistFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.OrderedlistFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.OrderedlistFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrOrderedListFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrOrderedListFlags" ):
+ return visitor.visitVfrOrderedListFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrOrderedListFlags(self):
+
+ localctx = VfrSyntaxParser.VfrOrderedListFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 226, self.RULE_vfrOrderedListFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1862
+ self.orderedlistFlagsField()
+ self.state = 1867
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1863
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1864
+ self.orderedlistFlagsField()
+ self.state = 1869
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class OrderedlistFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.HFlag = 0
+ self.LFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def UniQueFlag(self):
+ return self.getToken(VfrSyntaxParser.UniQueFlag, 0)
+
+ def NoEmptyFlag(self):
+ return self.getToken(VfrSyntaxParser.NoEmptyFlag, 0)
+
+ def questionheaderFlagsField(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_orderedlistFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitOrderedlistFlagsField" ):
+ return visitor.visitOrderedlistFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def orderedlistFlagsField(self):
+
+ localctx = VfrSyntaxParser.OrderedlistFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 228, self.RULE_orderedlistFlagsField)
+ try:
+ self.state = 1874
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Number]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1870
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.UniQueFlag]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 1871
+ self.match(VfrSyntaxParser.UniQueFlag)
+ pass
+ elif token in [VfrSyntaxParser.NoEmptyFlag]:
+ self.enterOuterAlt(localctx, 3)
+ 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 = 1873
+ self.questionheaderFlagsField()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDateContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_DATE_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_DATE
+ self.Val = EFI_HII_DATE()
+ self.F1 = None # Token
+ self.F2 = None # Token
+
+ def Date(self):
+ return self.getToken(VfrSyntaxParser.Date, 0)
+
+ def EndDate(self):
+ return self.getToken(VfrSyntaxParser.EndDate, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def Year(self):
+ return self.getToken(VfrSyntaxParser.Year, 0)
+
+ def VarId(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.VarId)
+ else:
+ return self.getToken(VfrSyntaxParser.VarId, i)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+
+ def Prompt(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Prompt)
+ else:
+ return self.getToken(VfrSyntaxParser.Prompt, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Help)
+ else:
+ return self.getToken(VfrSyntaxParser.Help, i)
+
+ def minMaxDateStepDefault(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.MinMaxDateStepDefaultContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.MinMaxDateStepDefaultContext,i)
+
+
+ def Month(self):
+ return self.getToken(VfrSyntaxParser.Month, 0)
+
+ def Day(self):
+ return self.getToken(VfrSyntaxParser.Day, 0)
+
+ def vfrDateFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrDateFlagsContext,0)
+
+
+ def vfrStatementInconsistentIf(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDate
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDate" ):
+ return visitor.visitVfrStatementDate(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDate(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDateContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 230, self.RULE_vfrStatementDate)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1876
+ self.match(VfrSyntaxParser.Date)
+ 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 = 1877
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 1878
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1884
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 1879
+ localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1880
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1881
+ self.vfrDateFlags()
+ self.state = 1882
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1886
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ pass
+ elif token in [VfrSyntaxParser.Year]:
+ self.state = 1888
+ self.match(VfrSyntaxParser.Year)
+ self.state = 1889
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 1890
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1891
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1892
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 1893
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1894
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1895
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1896
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1897
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1898
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1899
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1900
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1901
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1902
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1903
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1904
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1905
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1906
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1907
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1908
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1909
+ self.minMaxDateStepDefault(localctx.Node, localctx.Val, 0)
+ self.state = 1910
+ self.match(VfrSyntaxParser.Month)
+ self.state = 1911
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 1912
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1913
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1914
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 1915
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1916
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1917
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1918
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1919
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1920
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1921
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1922
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1923
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1924
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1925
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1926
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1927
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1928
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1929
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1930
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1931
+ self.minMaxDateStepDefault(localctx.Node, localctx.Val, 1)
+ self.state = 1932
+ self.match(VfrSyntaxParser.Day)
+ self.state = 1933
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 1934
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1935
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1936
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 1937
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 1938
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1939
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 1940
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1941
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1942
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1943
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1944
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 1945
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1946
+ self.match(VfrSyntaxParser.Help)
+ self.state = 1947
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1948
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 1949
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 1950
+ 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 = 1954
+ localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 1955
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1956
+ self.vfrDateFlags()
+ self.state = 1957
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1964
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.InconsistentIf:
+ self.state = 1961
+ self.vfrStatementInconsistentIf()
+ self.state = 1966
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 1969
+ self.match(VfrSyntaxParser.EndDate)
+ self.state = 1970
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MinMaxDateStepDefaultContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, 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
+
+ def Minimum(self):
+ return self.getToken(VfrSyntaxParser.Minimum, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Maximum(self):
+ return self.getToken(VfrSyntaxParser.Maximum, 0)
+
+ def Step(self):
+ return self.getToken(VfrSyntaxParser.Step, 0)
+
+ def Default(self):
+ return self.getToken(VfrSyntaxParser.Default, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_minMaxDateStepDefault
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMinMaxDateStepDefault" ):
+ return visitor.visitMinMaxDateStepDefault(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def minMaxDateStepDefault(self, Node, 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 = 1972
+ self.match(VfrSyntaxParser.Minimum)
+ self.state = 1973
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1974
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1975
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1976
+ self.match(VfrSyntaxParser.Maximum)
+ self.state = 1977
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1978
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1979
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 1984
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Step:
+ self.state = 1980
+ self.match(VfrSyntaxParser.Step)
+ self.state = 1981
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1982
+ self.match(VfrSyntaxParser.Number)
+ self.state = 1983
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 1990
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Default:
+ self.state = 1986
+ self.match(VfrSyntaxParser.Default)
+ self.state = 1987
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 1988
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 1989
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrDateFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlags = 0
+
+ def dateFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.DateFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.DateFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrDateFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrDateFlags" ):
+ return visitor.visitVfrDateFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrDateFlags(self):
+
+ localctx = VfrSyntaxParser.VfrDateFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 234, self.RULE_vfrDateFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 1992
+ self.dateFlagsField()
+ self.state = 1997
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 1993
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 1994
+ self.dateFlagsField()
+ self.state = 1999
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DateFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def YearSupppressFlag(self):
+ return self.getToken(VfrSyntaxParser.YearSupppressFlag, 0)
+
+ def MonthSuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.MonthSuppressFlag, 0)
+
+ def DaySuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.DaySuppressFlag, 0)
+
+ def StorageNormalFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
+
+ def StorageTimeFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
+
+ def StorageWakeUpFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dateFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDateFlagsField" ):
+ return visitor.visitDateFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dateFlagsField(self):
+
+ localctx = VfrSyntaxParser.DateFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 236, self.RULE_dateFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementTimeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_TIME_OP)
+ self.QType = EFI_QUESION_TYPE.QUESTION_TIME
+ self.Val = EFI_HII_TIME()
+ self.F1 = None # Token
+ self.F2 = None # Token
+
+ def Time(self):
+ return self.getToken(VfrSyntaxParser.Time, 0)
+
+ def EndTime(self):
+ return self.getToken(VfrSyntaxParser.EndTime, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def vfrQuestionHeader(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementQuestionOptionList(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListContext,0)
+
+
+ def Hour(self):
+ return self.getToken(VfrSyntaxParser.Hour, 0)
+
+ def VarId(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.VarId)
+ else:
+ return self.getToken(VfrSyntaxParser.VarId, i)
+
+ def StringIdentifier(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringIdentifier)
+ else:
+ return self.getToken(VfrSyntaxParser.StringIdentifier, i)
+
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+
+ def Prompt(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Prompt)
+ else:
+ return self.getToken(VfrSyntaxParser.Prompt, i)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Help)
+ else:
+ return self.getToken(VfrSyntaxParser.Help, i)
+
+ def minMaxTimeStepDefault(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.MinMaxTimeStepDefaultContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.MinMaxTimeStepDefaultContext,i)
+
+
+ def Minute(self):
+ return self.getToken(VfrSyntaxParser.Minute, 0)
+
+ def Second(self):
+ return self.getToken(VfrSyntaxParser.Second, 0)
+
+ def vfrTimeFlags(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrTimeFlagsContext,0)
+
+
+ def vfrStatementInconsistentIf(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i)
+
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementTime
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementTime" ):
+ return visitor.visitVfrStatementTime(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementTime(self):
+
+ localctx = VfrSyntaxParser.VfrStatementTimeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 238, self.RULE_vfrStatementTime)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2002
+ self.match(VfrSyntaxParser.Time)
+ 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 = 2003
+ self.vfrQuestionHeader(localctx.Node, localctx.QType)
+ self.state = 2004
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2010
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2005
+ localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2006
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2007
+ self.vfrTimeFlags()
+ self.state = 2008
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2012
+ self.vfrStatementQuestionOptionList(localctx.Node)
+ pass
+ elif token in [VfrSyntaxParser.Hour]:
+ self.state = 2014
+ self.match(VfrSyntaxParser.Hour)
+ self.state = 2015
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 2016
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2017
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2018
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2019
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2020
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2021
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2022
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2023
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2024
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2025
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2026
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2027
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2028
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2029
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2030
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2031
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2032
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2033
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2034
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2035
+ self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 0)
+ self.state = 2036
+ self.match(VfrSyntaxParser.Minute)
+ self.state = 2037
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 2038
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2039
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2040
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2041
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2042
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2043
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2044
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2045
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2046
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2047
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2048
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2049
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2050
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2051
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2052
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2053
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2054
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2055
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2056
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2057
+ self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 1)
+ self.state = 2058
+ self.match(VfrSyntaxParser.Second)
+ self.state = 2059
+ self.match(VfrSyntaxParser.VarId)
+ self.state = 2060
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2061
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2062
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2063
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2064
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2065
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2066
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2067
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2068
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2069
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2070
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2071
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2072
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2073
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2074
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2075
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2076
+ 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 = 2080
+ localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2081
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2082
+ self.vfrTimeFlags()
+ self.state = 2083
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2090
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.InconsistentIf:
+ self.state = 2087
+ self.vfrStatementInconsistentIf()
+ self.state = 2092
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 2095
+ self.match(VfrSyntaxParser.EndTime)
+ self.state = 2096
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MinMaxTimeStepDefaultContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, 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
+
+ def Minimum(self):
+ return self.getToken(VfrSyntaxParser.Minimum, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Maximum(self):
+ return self.getToken(VfrSyntaxParser.Maximum, 0)
+
+ def Step(self):
+ return self.getToken(VfrSyntaxParser.Step, 0)
+
+ def Default(self):
+ return self.getToken(VfrSyntaxParser.Default, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_minMaxTimeStepDefault
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMinMaxTimeStepDefault" ):
+ return visitor.visitMinMaxTimeStepDefault(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def minMaxTimeStepDefault(self, Node, 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 = 2098
+ self.match(VfrSyntaxParser.Minimum)
+ self.state = 2099
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2100
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2101
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2102
+ self.match(VfrSyntaxParser.Maximum)
+ self.state = 2103
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2104
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2105
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2110
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Step:
+ self.state = 2106
+ self.match(VfrSyntaxParser.Step)
+ self.state = 2107
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2108
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2109
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2116
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Default:
+ self.state = 2112
+ self.match(VfrSyntaxParser.Default)
+ self.state = 2113
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2114
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 2115
+ self.match(VfrSyntaxParser.Comma)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrTimeFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlags = 0
+
+ def timeFlagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.TimeFlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.TimeFlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrTimeFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrTimeFlags" ):
+ return visitor.visitVfrTimeFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrTimeFlags(self):
+
+ localctx = VfrSyntaxParser.VfrTimeFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 242, self.RULE_vfrTimeFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2118
+ self.timeFlagsField()
+ self.state = 2123
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2119
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2120
+ self.timeFlagsField()
+ self.state = 2125
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TimeFlagsFieldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.LFlag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def HourSupppressFlag(self):
+ return self.getToken(VfrSyntaxParser.HourSupppressFlag, 0)
+
+ def MinuteSuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.MinuteSuppressFlag, 0)
+
+ def SecondSuppressFlag(self):
+ return self.getToken(VfrSyntaxParser.SecondSuppressFlag, 0)
+
+ def StorageNormalFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
+
+ def StorageTimeFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
+
+ def StorageWakeUpFlag(self):
+ return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_timeFlagsField
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTimeFlagsField" ):
+ return visitor.visitTimeFlagsField(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def timeFlagsField(self):
+
+ localctx = VfrSyntaxParser.TimeFlagsFieldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 244, self.RULE_timeFlagsField)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementConditionalContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementDisableIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
+
+
+ def vfrStatementSuppressIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatContext,0)
+
+
+ def vfrStatementGrayOutIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatContext,0)
+
+
+ def vfrStatementInconsistentIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementConditional
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementConditional" ):
+ return visitor.visitVfrStatementConditional(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementConditional(self):
+
+ localctx = VfrSyntaxParser.VfrStatementConditionalContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 246, self.RULE_vfrStatementConditional)
+ try:
+ self.state = 2132
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.DisableIf]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2128
+ self.vfrStatementDisableIfStat()
+ pass
+ elif token in [VfrSyntaxParser.SuppressIf]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2129
+ self.vfrStatementSuppressIfStat()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2130
+ self.vfrStatementGrayOutIfStat()
+ pass
+ elif token in [VfrSyntaxParser.InconsistentIf]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2131
+ self.vfrStatementInconsistentIfStat()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementConditionalNewContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementDisableIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
+
+
+ def vfrStatementSuppressIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewContext,0)
+
+
+ def vfrStatementGrayOutIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext,0)
+
+
+ def vfrStatementInconsistentIfStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementConditionalNew
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementConditionalNew" ):
+ return visitor.visitVfrStatementConditionalNew(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementConditionalNew(self):
+
+ localctx = VfrSyntaxParser.VfrStatementConditionalNewContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 248, self.RULE_vfrStatementConditionalNew)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2134
+ self.vfrStatementDisableIfStat()
+ self.state = 2135
+ self.vfrStatementSuppressIfStatNew()
+ self.state = 2136
+ self.vfrStatementGrayOutIfStatNew()
+ self.state = 2137
+ self.vfrStatementInconsistentIfStat()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementSuppressIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfStat" ):
+ return visitor.visitVfrStatementSuppressIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 250, self.RULE_vfrStatementSuppressIfStat)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2139
+ self.vfrStatementSuppressIfStatNew()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGrayOutIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementGrayOutIfStatNew(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGrayOutIfStat" ):
+ return visitor.visitVfrStatementGrayOutIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGrayOutIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 252, self.RULE_vfrStatementGrayOutIfStat)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2141
+ self.vfrStatementGrayOutIfStatNew()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatListContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def vfrStatementConditional(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
+
+
+ def vfrStatementLabel(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
+
+
+ def vfrStatementExtension(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
+
+
+ def vfrStatementInvalid(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatList
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatList" ):
+ return visitor.visitVfrStatementStatList(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatList(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatListContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 254, self.RULE_vfrStatementStatList)
+ try:
+ self.state = 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 = 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 = 2144
+ self.vfrStatementQuestions()
+ pass
+ elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf, VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2145
+ self.vfrStatementConditional()
+ pass
+ elif token in [VfrSyntaxParser.Label]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2146
+ self.vfrStatementLabel()
+ pass
+ elif token in [VfrSyntaxParser.GuidOp]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2147
+ self.vfrStatementExtension()
+ pass
+ elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden, VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2148
+ self.vfrStatementInvalid()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementStatListOldContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def vfrStatementStat(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
+
+
+ def vfrStatementQuestions(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
+
+
+ def vfrStatementLabel(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
+
+
+ def vfrStatementInvalid(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementStatListOld
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementStatListOld" ):
+ return visitor.visitVfrStatementStatListOld(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementStatListOld(self):
+
+ localctx = VfrSyntaxParser.VfrStatementStatListOldContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 256, self.RULE_vfrStatementStatListOld)
+ try:
+ self.state = 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 = 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 = 2152
+ self.vfrStatementQuestions()
+ pass
+ elif token in [VfrSyntaxParser.Label]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2153
+ self.vfrStatementLabel()
+ pass
+ elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden, VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2154
+ self.vfrStatementInvalid()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementDisableIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
+
+ def DisableIf(self):
+ return self.getToken(VfrSyntaxParser.DisableIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def vfrStatementStatList(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementDisableIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementDisableIfStat" ):
+ return visitor.visitVfrStatementDisableIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementDisableIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementDisableIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 258, self.RULE_vfrStatementDisableIfStat)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2157
+ self.match(VfrSyntaxParser.DisableIf)
+ self.state = 2158
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2159
+ self.match(VfrSyntaxParser.Semicolon)
+ 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 = 2160
+ self.vfrStatementStatList()
+ self.state = 2165
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2166
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2167
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementgrayoutIfSuppressIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementgrayoutIfSuppressIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementgrayoutIfSuppressIf" ):
+ return visitor.visitVfrStatementgrayoutIfSuppressIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementgrayoutIfSuppressIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementgrayoutIfSuppressIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 260, self.RULE_vfrStatementgrayoutIfSuppressIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2169
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 2182
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2170
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2171
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2172
+ self.flagsField()
+ self.state = 2177
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2173
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2174
+ self.flagsField()
+ self.state = 2179
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2180
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2184
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2185
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementsuppressIfGrayOutIfContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def GrayOutIf(self):
+ return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementsuppressIfGrayOutIf
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementsuppressIfGrayOutIf" ):
+ return visitor.visitVfrStatementsuppressIfGrayOutIf(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementsuppressIfGrayOutIf(self):
+
+ localctx = VfrSyntaxParser.VfrStatementsuppressIfGrayOutIfContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 262, self.RULE_vfrStatementsuppressIfGrayOutIf)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2187
+ self.match(VfrSyntaxParser.GrayOutIf)
+ self.state = 2200
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2188
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2189
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2190
+ self.flagsField()
+ self.state = 2195
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2191
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2192
+ self.flagsField()
+ self.state = 2197
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2198
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2202
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2203
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementSuppressIfStatNewContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
+
+ def SuppressIf(self):
+ return self.getToken(VfrSyntaxParser.SuppressIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementStatList(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementSuppressIfStatNew
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementSuppressIfStatNew" ):
+ return visitor.visitVfrStatementSuppressIfStatNew(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementSuppressIfStatNew(self):
+
+ localctx = VfrSyntaxParser.VfrStatementSuppressIfStatNewContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 264, self.RULE_vfrStatementSuppressIfStatNew)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2205
+ self.match(VfrSyntaxParser.SuppressIf)
+ self.state = 2218
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2206
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2207
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2208
+ self.flagsField()
+ self.state = 2213
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2209
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2210
+ self.flagsField()
+ self.state = 2215
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2216
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2220
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2221
+ self.match(VfrSyntaxParser.Semicolon)
+ 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 = 2222
+ self.vfrStatementStatList()
+ self.state = 2227
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2228
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2229
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementGrayOutIfStatNewContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)
+
+ def GrayOutIf(self):
+ return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementStatList(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStatNew
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementGrayOutIfStatNew" ):
+ return visitor.visitVfrStatementGrayOutIfStatNew(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementGrayOutIfStatNew(self):
+
+ localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 266, self.RULE_vfrStatementGrayOutIfStatNew)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2231
+ self.match(VfrSyntaxParser.GrayOutIf)
+ self.state = 2244
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2232
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2233
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2234
+ self.flagsField()
+ self.state = 2239
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2235
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2236
+ self.flagsField()
+ self.state = 2241
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2242
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2246
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2247
+ self.match(VfrSyntaxParser.Semicolon)
+ 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 = 2248
+ self.vfrStatementStatList()
+ self.state = 2253
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2254
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2255
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInconsistentIfStatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
+
+ def InconsistentIf(self):
+ return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpression(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
+
+
+ def EndIf(self):
+ return self.getToken(VfrSyntaxParser.EndIf, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInconsistentIfStat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInconsistentIfStat" ):
+ return visitor.visitVfrStatementInconsistentIfStat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInconsistentIfStat(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInconsistentIfStatContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 268, self.RULE_vfrStatementInconsistentIfStat)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2257
+ self.match(VfrSyntaxParser.InconsistentIf)
+ self.state = 2258
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2259
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2260
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2261
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2262
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2263
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2264
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2277
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.FLAGS:
+ self.state = 2265
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2266
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2267
+ self.flagsField()
+ self.state = 2272
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2268
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2269
+ self.flagsField()
+ self.state = 2274
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2275
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2279
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2280
+ self.match(VfrSyntaxParser.EndIf)
+ self.state = 2281
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def vfrStatementInvalidHidden(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidHiddenContext,0)
+
+
+ def vfrStatementInvalidInventory(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidInventoryContext,0)
+
+
+ def vfrStatementInvalidSaveRestoreDefaults(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalid
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalid" ):
+ return visitor.visitVfrStatementInvalid(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalid(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 270, self.RULE_vfrStatementInvalid)
+ try:
+ self.state = 2286
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Hidden]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2283
+ self.vfrStatementInvalidHidden()
+ pass
+ elif token in [VfrSyntaxParser.Inventory]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2284
+ self.vfrStatementInvalidInventory()
+ pass
+ elif token in [VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2285
+ self.vfrStatementInvalidSaveRestoreDefaults()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidHiddenContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Hidden(self):
+ return self.getToken(VfrSyntaxParser.Hidden, 0)
+
+ def Value(self):
+ return self.getToken(VfrSyntaxParser.Value, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalidHidden
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalidHidden" ):
+ return visitor.visitVfrStatementInvalidHidden(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalidHidden(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidHiddenContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 272, self.RULE_vfrStatementInvalidHidden)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2288
+ self.match(VfrSyntaxParser.Hidden)
+ self.state = 2289
+ self.match(VfrSyntaxParser.Value)
+ self.state = 2290
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2291
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2292
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2293
+ self.match(VfrSyntaxParser.Key)
+ self.state = 2294
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2295
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2296
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidInventoryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Inventory(self):
+ return self.getToken(VfrSyntaxParser.Inventory, 0)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Text(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Text)
+ else:
+ return self.getToken(VfrSyntaxParser.Text, i)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalidInventory
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalidInventory" ):
+ return visitor.visitVfrStatementInvalidInventory(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalidInventory(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidInventoryContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 274, self.RULE_vfrStatementInvalidInventory)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2298
+ self.match(VfrSyntaxParser.Inventory)
+ self.state = 2299
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2300
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2301
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2302
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2303
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2304
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2305
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2306
+ self.match(VfrSyntaxParser.Text)
+ self.state = 2307
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2308
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2309
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2310
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2311
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2312
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2319
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Text:
+ self.state = 2313
+ self.match(VfrSyntaxParser.Text)
+ self.state = 2314
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2315
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2316
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2317
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2318
+ self.match(VfrSyntaxParser.CloseParen)
+
+
+ self.state = 2321
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementInvalidSaveRestoreDefaultsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+
+ def Defaults(self):
+ return self.getToken(VfrSyntaxParser.Defaults, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def FormId(self):
+ return self.getToken(VfrSyntaxParser.FormId, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def Prompt(self):
+ return self.getToken(VfrSyntaxParser.Prompt, 0)
+
+ def StringToken(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.StringToken)
+ else:
+ return self.getToken(VfrSyntaxParser.StringToken, i)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def Help(self):
+ return self.getToken(VfrSyntaxParser.Help, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Save(self):
+ return self.getToken(VfrSyntaxParser.Save, 0)
+
+ def Restore(self):
+ return self.getToken(VfrSyntaxParser.Restore, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def flagsField(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
+
+
+ def Key(self):
+ return self.getToken(VfrSyntaxParser.Key, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementInvalidSaveRestoreDefaults
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementInvalidSaveRestoreDefaults" ):
+ return visitor.visitVfrStatementInvalidSaveRestoreDefaults(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementInvalidSaveRestoreDefaults(self):
+
+ localctx = VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 276, self.RULE_vfrStatementInvalidSaveRestoreDefaults)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 2324
+ self.match(VfrSyntaxParser.Defaults)
+ self.state = 2325
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2326
+ self.match(VfrSyntaxParser.FormId)
+ self.state = 2327
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2328
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2329
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2330
+ self.match(VfrSyntaxParser.Prompt)
+ self.state = 2331
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2332
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2333
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2334
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2335
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2336
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2337
+ self.match(VfrSyntaxParser.Help)
+ self.state = 2338
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2339
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2340
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2341
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2342
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2354
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
+ if la_ == 1:
+ self.state = 2343
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2344
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2345
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2346
+ self.flagsField()
+ self.state = 2351
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2347
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2348
+ self.flagsField()
+ self.state = 2353
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+
+
+ self.state = 2360
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 2356
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2357
+ self.match(VfrSyntaxParser.Key)
+ self.state = 2358
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2359
+ self.match(VfrSyntaxParser.Number)
+
+
+ self.state = 2362
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementLabelContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
+
+ def Label(self):
+ return self.getToken(VfrSyntaxParser.Label, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementLabel
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementLabel" ):
+ return visitor.visitVfrStatementLabel(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementLabel(self):
+
+ localctx = VfrSyntaxParser.VfrStatementLabelContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 278, self.RULE_vfrStatementLabel)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2364
+ self.match(VfrSyntaxParser.Label)
+ self.state = 2365
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2366
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementBannerContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
+
+ def Banner(self):
+ return self.getToken(VfrSyntaxParser.Banner, 0)
+
+ def Title(self):
+ return self.getToken(VfrSyntaxParser.Title, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Line(self):
+ return self.getToken(VfrSyntaxParser.Line, 0)
+
+ def Align(self):
+ return self.getToken(VfrSyntaxParser.Align, 0)
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Timeout(self):
+ return self.getToken(VfrSyntaxParser.Timeout, 0)
+
+ def Left(self):
+ return self.getToken(VfrSyntaxParser.Left, 0)
+
+ def Center(self):
+ return self.getToken(VfrSyntaxParser.Center, 0)
+
+ def Right(self):
+ return self.getToken(VfrSyntaxParser.Right, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementBanner
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementBanner" ):
+ return visitor.visitVfrStatementBanner(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementBanner(self):
+
+ localctx = VfrSyntaxParser.VfrStatementBannerContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 280, self.RULE_vfrStatementBanner)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2368
+ self.match(VfrSyntaxParser.Banner)
+ self.state = 2370
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 2369
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2372
+ self.match(VfrSyntaxParser.Title)
+ self.state = 2373
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2374
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2375
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2376
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2377
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2378
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2389
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Line]:
+ self.state = 2379
+ self.match(VfrSyntaxParser.Line)
+ self.state = 2380
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2381
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2382
+ self.match(VfrSyntaxParser.Align)
+ 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 = 2384
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+ elif token in [VfrSyntaxParser.Timeout]:
+ self.state = 2385
+ self.match(VfrSyntaxParser.Timeout)
+ self.state = 2386
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2387
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2388
+ self.match(VfrSyntaxParser.Semicolon)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementExtensionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
+ self.Buffer = None
+ self.Size = 0
+ self.TypeName = ''
+ self.TypeSize = 0
+ self.IsStruct = False
+ self.ArrayNum = 0
+ self.D = None # Token
+
+ def GuidOp(self):
+ return self.getToken(VfrSyntaxParser.GuidOp, 0)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def EndGuidOp(self):
+ return self.getToken(VfrSyntaxParser.EndGuidOp, 0)
+
+ def DataType(self):
+ return self.getToken(VfrSyntaxParser.DataType, 0)
+
+ def Uint64(self):
+ return self.getToken(VfrSyntaxParser.Uint64, 0)
+
+ def Uint32(self):
+ return self.getToken(VfrSyntaxParser.Uint32, 0)
+
+ def Uint16(self):
+ return self.getToken(VfrSyntaxParser.Uint16, 0)
+
+ def Uint8(self):
+ return self.getToken(VfrSyntaxParser.Uint8, 0)
+
+ def Boolean(self):
+ return self.getToken(VfrSyntaxParser.Boolean, 0)
+
+ def EFI_STRING_ID(self):
+ return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
+
+ def EFI_HII_DATE(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
+
+ def EFI_HII_TIME(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
+
+ def EFI_HII_REF(self):
+ return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def vfrExtensionData(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrExtensionDataContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExtensionDataContext,i)
+
+
+ def vfrStatementExtension(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExtensionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,i)
+
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementExtension
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementExtension" ):
+ return visitor.visitVfrStatementExtension(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementExtension(self):
+
+ localctx = VfrSyntaxParser.VfrStatementExtensionContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 282, self.RULE_vfrStatementExtension)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2391
+ self.match(VfrSyntaxParser.GuidOp)
+ self.state = 2392
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 2393
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2394
+ self.guidDefinition()
+ self.state = 2466
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
+ if la_ == 1:
+ self.state = 2395
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2396
+ localctx.D = self.match(VfrSyntaxParser.DataType)
+ self.state = 2397
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2458
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Uint64]:
+ self.state = 2398
+ self.match(VfrSyntaxParser.Uint64)
+ self.state = 2402
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2399
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2400
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2401
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Uint32]:
+ self.state = 2404
+ self.match(VfrSyntaxParser.Uint32)
+ self.state = 2408
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2405
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2406
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2407
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Uint16]:
+ self.state = 2410
+ self.match(VfrSyntaxParser.Uint16)
+ self.state = 2414
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2411
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2412
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2413
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Uint8]:
+ self.state = 2416
+ self.match(VfrSyntaxParser.Uint8)
+ self.state = 2420
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2417
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2418
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2419
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.Boolean]:
+ self.state = 2422
+ self.match(VfrSyntaxParser.Boolean)
+ self.state = 2426
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2423
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2424
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2425
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_STRING_ID]:
+ self.state = 2428
+ self.match(VfrSyntaxParser.EFI_STRING_ID)
+ self.state = 2432
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2429
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2430
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2431
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_DATE]:
+ self.state = 2434
+ self.match(VfrSyntaxParser.EFI_HII_DATE)
+ self.state = 2438
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2435
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2436
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2437
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_TIME]:
+ self.state = 2440
+ self.match(VfrSyntaxParser.EFI_HII_TIME)
+ self.state = 2444
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2441
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2442
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2443
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.EFI_HII_REF]:
+ self.state = 2446
+ self.match(VfrSyntaxParser.EFI_HII_REF)
+ self.state = 2450
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2447
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2448
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2449
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ elif token in [VfrSyntaxParser.StringIdentifier]:
+ self.state = 2452
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2456
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2453
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2454
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2455
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 2463
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 2460
+ self.vfrExtensionData()
+ self.state = 2465
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
+
+
+
+ self.state = 2476
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Comma:
+ self.state = 2468
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2472
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.GuidOp:
+ self.state = 2469
+ self.vfrStatementExtension()
+ self.state = 2474
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2475
+ self.match(VfrSyntaxParser.EndGuidOp)
+
+
+ self.state = 2478
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExtensionDataContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.TFName = ''
+ self.FName = ''
+ self.TFValue = None
+ self.I = None # Token
+ self.N = None # Token
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def Data(self):
+ return self.getToken(VfrSyntaxParser.Data, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+
+ def arrayName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExtensionData
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExtensionData" ):
+ return visitor.visitVfrExtensionData(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExtensionData(self):
+
+ 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 = 2480
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2481
+ self.match(VfrSyntaxParser.Data)
+ self.state = 2485
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.OpenBracket:
+ self.state = 2482
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2483
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 2484
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ self.state = 2491
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Dot:
+ self.state = 2487
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2488
+ self.arrayName()
+ self.state = 2493
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2494
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2495
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementModalContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = None
+
+ def vfrModalTag(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrModalTagContext,0)
+
+
+ def Semicolon(self):
+ return self.getToken(VfrSyntaxParser.Semicolon, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementModal
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementModal" ):
+ return visitor.visitVfrStatementModal(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementModal(self):
+
+ localctx = VfrSyntaxParser.VfrStatementModalContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 286, self.RULE_vfrStatementModal)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2497
+ self.vfrModalTag()
+ self.state = 2498
+ self.match(VfrSyntaxParser.Semicolon)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrModalTagContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Node = IfrTreeNode(EFI_IFR_MODAL_TAG_OP)
+
+ def Modal(self):
+ return self.getToken(VfrSyntaxParser.Modal, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrModalTag
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrModalTag" ):
+ return visitor.visitVfrModalTag(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrModalTag(self):
+
+ localctx = VfrSyntaxParser.VfrModalTagContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 288, self.RULE_vfrModalTag)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2500
+ self.match(VfrSyntaxParser.Modal)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementExpressionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, 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:
+ return self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
+
+
+ def OR(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OR)
+ else:
+ return self.getToken(VfrSyntaxParser.OR, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementExpression
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementExpression" ):
+ return visitor.visitVfrStatementExpression(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementExpression(self, ParentNode):
+
+ 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 = 2502
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2507
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.OR:
+ self.state = 2503
+ localctx.L = self.match(VfrSyntaxParser.OR)
+ self.state = 2504
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2509
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrStatementExpressionSubContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, 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:
+ return self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
+
+
+ def OR(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OR)
+ else:
+ return self.getToken(VfrSyntaxParser.OR, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrStatementExpressionSub
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrStatementExpressionSub" ):
+ return visitor.visitVfrStatementExpressionSub(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrStatementExpressionSub(self, ParentNodes):
+
+ 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 = 2510
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2515
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.OR:
+ self.state = 2511
+ self.match(VfrSyntaxParser.OR)
+ self.state = 2512
+ self.andTerm(localctx.ExpInfo)
+ self.state = 2517
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AndTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.Line = None
+ self.L = None # Token
+ self.ExpInfo = ExpInfo
+
+ def bitwiseorTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.BitwiseorTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.BitwiseorTermContext,i)
+
+
+ def AND(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.AND)
+ else:
+ return self.getToken(VfrSyntaxParser.AND, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_andTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAndTerm" ):
+ return visitor.visitAndTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def andTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AndTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 294, self.RULE_andTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2518
+ self.bitwiseorTerm(ExpInfo)
+ self.state = 2523
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.AND:
+ self.state = 2519
+ localctx.L = self.match(VfrSyntaxParser.AND)
+ self.state = 2520
+ self.bitwiseorTerm(ExpInfo)
+ self.state = 2525
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class BitwiseorTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.Line = None
+ self.L = None # Token
+ self.ExpInfo = ExpInfo
+
+ def bitwiseandTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.BitwiseandTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.BitwiseandTermContext,i)
+
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_bitwiseorTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitBitwiseorTerm" ):
+ return visitor.visitBitwiseorTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def bitwiseorTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.BitwiseorTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 296, self.RULE_bitwiseorTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2526
+ self.bitwiseandTerm(ExpInfo)
+ self.state = 2531
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2527
+ localctx.L = self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2528
+ self.bitwiseandTerm(ExpInfo)
+ self.state = 2533
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class BitwiseandTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.Line = None
+ self.L = None # Token
+ self.ExpInfo = ExpInfo
+
+ def equalTerm(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.EqualTermContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.EqualTermContext,i)
+
+
+ def BitWiseAnd(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseAnd)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseAnd, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_bitwiseandTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitBitwiseandTerm" ):
+ return visitor.visitBitwiseandTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def bitwiseandTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.BitwiseandTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 298, self.RULE_bitwiseandTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2534
+ self.equalTerm(ExpInfo)
+ self.state = 2539
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseAnd:
+ self.state = 2535
+ localctx.L = self.match(VfrSyntaxParser.BitWiseAnd)
+ self.state = 2536
+ self.equalTerm(ExpInfo)
+ self.state = 2541
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class EqualTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.Line = None
+ self.ExpInfo = ExpInfo
+
+ def compareTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
+
+
+ def equalTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.EqualTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.EqualTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_equalTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEqualTerm" ):
+ return visitor.visitEqualTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def equalTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.EqualTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 300, self.RULE_equalTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 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 = 2543
+ self.equalTermSupplementary(ExpInfo)
+ self.state = 2548
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class EqualTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_equalTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.ExpInfo = ctx.ExpInfo
+ self.Nodes = ctx.Nodes
+
+
+
+ class EqualTermEqualRuleContext(EqualTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.EqualTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+ def compareTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEqualTermEqualRule" ):
+ return visitor.visitEqualTermEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class EqualTermNotEqualRuleContext(EqualTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.EqualTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def NotEqual(self):
+ return self.getToken(VfrSyntaxParser.NotEqual, 0)
+ def compareTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitEqualTermNotEqualRule" ):
+ return visitor.visitEqualTermNotEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def equalTermSupplementary(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.EqualTermSupplementaryContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 302, self.RULE_equalTermSupplementary)
+ try:
+ 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 = 2549
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2550
+ self.compareTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.NotEqual]:
+ localctx = VfrSyntaxParser.EqualTermNotEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2551
+ self.match(VfrSyntaxParser.NotEqual)
+ self.state = 2552
+ self.compareTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CompareTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def compareTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.CompareTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.CompareTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_compareTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTerm" ):
+ return visitor.visitCompareTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def compareTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.CompareTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 304, self.RULE_compareTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2555
+ self.shiftTerm(ExpInfo)
+ 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 = 2556
+ self.compareTermSupplementary(ExpInfo)
+ self.state = 2561
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CompareTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_compareTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.ExpInfo = ctx.ExpInfo
+ self.Nodes = ctx.Nodes
+
+
+
+ class CompareTermLessRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermLessRule" ):
+ return visitor.visitCompareTermLessRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class CompareTermGreaterEqualRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermGreaterEqualRule" ):
+ return visitor.visitCompareTermGreaterEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class CompareTermGreaterRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermGreaterRule" ):
+ return visitor.visitCompareTermGreaterRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class CompareTermLessEqualRuleContext(CompareTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.CompareTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+ def shiftTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCompareTermLessEqualRule" ):
+ return visitor.visitCompareTermLessEqualRule(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def compareTermSupplementary(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.CompareTermSupplementaryContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 306, self.RULE_compareTermSupplementary)
+ try:
+ 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 = 2562
+ self.match(VfrSyntaxParser.Less)
+ self.state = 2563
+ self.shiftTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ localctx = VfrSyntaxParser.CompareTermLessEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2564
+ self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2565
+ self.shiftTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ localctx = VfrSyntaxParser.CompareTermGreaterRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2566
+ self.match(VfrSyntaxParser.Greater)
+ self.state = 2567
+ self.shiftTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ localctx = VfrSyntaxParser.CompareTermGreaterEqualRuleContext(self, localctx)
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2568
+ self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2569
+ self.shiftTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ShiftTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def addMinusTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
+
+
+ def shiftTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ShiftTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_shiftTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShiftTerm" ):
+ return visitor.visitShiftTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def shiftTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ShiftTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 308, self.RULE_shiftTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2572
+ self.addMinusTerm(ExpInfo)
+ self.state = 2576
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.T__9 or _la==VfrSyntaxParser.T__10:
+ self.state = 2573
+ self.shiftTermSupplementary(ExpInfo)
+ self.state = 2578
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ShiftTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_shiftTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.ExpInfo = ctx.ExpInfo
+ self.Nodes = ctx.Nodes
+
+
+
+ class ShiftTermRightContext(ShiftTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.ShiftTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def addMinusTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShiftTermRight" ):
+ return visitor.visitShiftTermRight(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class ShiftTermLeftContext(ShiftTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.ShiftTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def addMinusTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitShiftTermLeft" ):
+ return visitor.visitShiftTermLeft(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def shiftTermSupplementary(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ShiftTermSupplementaryContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 310, self.RULE_shiftTermSupplementary)
+ try:
+ 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 = 2579
+ self.match(VfrSyntaxParser.T__9)
+ self.state = 2580
+ self.addMinusTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.T__10]:
+ localctx = VfrSyntaxParser.ShiftTermRightContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2581
+ self.match(VfrSyntaxParser.T__10)
+ self.state = 2582
+ self.addMinusTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AddMinusTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def multdivmodTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
+
+
+ def addMinusTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.AddMinusTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_addMinusTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAddMinusTerm" ):
+ return visitor.visitAddMinusTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def addMinusTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AddMinusTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 312, self.RULE_addMinusTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2585
+ self.multdivmodTerm(ExpInfo)
+ self.state = 2589
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.T__11 or _la==VfrSyntaxParser.Negative:
+ self.state = 2586
+ self.addMinusTermSupplementary(ExpInfo)
+ self.state = 2591
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class AddMinusTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_addMinusTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.ExpInfo = ctx.ExpInfo
+ self.Nodes = ctx.Nodes
+
+
+
+ class AddMinusTermpAddContext(AddMinusTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.AddMinusTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def multdivmodTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAddMinusTermpAdd" ):
+ return visitor.visitAddMinusTermpAdd(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class AddMinusTermSubtractContext(AddMinusTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.AddMinusTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Negative(self):
+ return self.getToken(VfrSyntaxParser.Negative, 0)
+ def multdivmodTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAddMinusTermSubtract" ):
+ return visitor.visitAddMinusTermSubtract(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def addMinusTermSupplementary(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AddMinusTermSupplementaryContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 314, self.RULE_addMinusTermSupplementary)
+ try:
+ 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 = 2592
+ self.match(VfrSyntaxParser.T__11)
+ self.state = 2593
+ self.multdivmodTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Negative]:
+ localctx = VfrSyntaxParser.AddMinusTermSubtractContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2594
+ self.match(VfrSyntaxParser.Negative)
+ self.state = 2595
+ self.multdivmodTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MultdivmodTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def multdivmodTermSupplementary(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.MultdivmodTermSupplementaryContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermSupplementaryContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_multdivmodTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTerm" ):
+ return visitor.visitMultdivmodTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def multdivmodTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.MultdivmodTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 316, self.RULE_multdivmodTerm)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2598
+ self.castTerm(ExpInfo)
+ 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 = 2599
+ self.multdivmodTermSupplementary(ExpInfo)
+ self.state = 2604
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MultdivmodTermSupplementaryContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_multdivmodTermSupplementary
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.ExpInfo = ctx.ExpInfo
+ self.Nodes = ctx.Nodes
+
+
+
+ class MultdivmodTermDivContext(MultdivmodTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.MultdivmodTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def Slash(self):
+ return self.getToken(VfrSyntaxParser.Slash, 0)
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTermDiv" ):
+ return visitor.visitMultdivmodTermDiv(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class MultdivmodTermMulContext(MultdivmodTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.MultdivmodTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTermMul" ):
+ return visitor.visitMultdivmodTermMul(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class MultdivmodTermModuloContext(MultdivmodTermSupplementaryContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.MultdivmodTermSupplementaryContext
+ super().__init__(parser)
+ self.copyFrom(ctx)
+
+ def castTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMultdivmodTermModulo" ):
+ return visitor.visitMultdivmodTermModulo(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def multdivmodTermSupplementary(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.MultdivmodTermSupplementaryContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 318, self.RULE_multdivmodTermSupplementary)
+ try:
+ 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 = 2605
+ self.match(VfrSyntaxParser.T__12)
+ self.state = 2606
+ self.castTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Slash]:
+ localctx = VfrSyntaxParser.MultdivmodTermDivContext(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2607
+ self.match(VfrSyntaxParser.Slash)
+ self.state = 2608
+ self.castTerm(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.T__13]:
+ localctx = VfrSyntaxParser.MultdivmodTermModuloContext(self, localctx)
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2609
+ self.match(VfrSyntaxParser.T__13)
+ self.state = 2610
+ self.castTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class CastTermContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def atomTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
+
+
+ def castTermSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.CastTermSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.CastTermSubContext,i)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_castTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitCastTerm" ):
+ return visitor.visitCastTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def castTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.CastTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 320, self.RULE_castTerm)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2616
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
+ while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+ if _alt==1:
+ self.state = 2613
+ self.castTermSub()
+ self.state = 2618
+ self._errHandler.sync(self)
+ _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
+
+ self.state = 2619
+ self.atomTerm(ExpInfo)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class 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):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionCatenateContext,0)
+
+
+ def vfrExpressionMatch(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatchContext,0)
+
+
+ def vfrExpressionMatch2(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatch2Context,0)
+
+
+ def vfrExpressionParen(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionParenContext,0)
+
+
+ def vfrExpressionBuildInFunction(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionBuildInFunctionContext,0)
+
+
+ def vfrExpressionConstant(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionConstantContext,0)
+
+
+ def vfrExpressionUnaryOp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionUnaryOpContext,0)
+
+
+ def vfrExpressionTernaryOp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionTernaryOpContext,0)
+
+
+ def vfrExpressionMap(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMapContext,0)
+
+
+ def NOT(self):
+ return self.getToken(VfrSyntaxParser.NOT, 0)
+
+ def atomTerm(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_atomTerm
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitAtomTerm" ):
+ return visitor.visitAtomTerm(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def atomTerm(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.AtomTermContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 324, self.RULE_atomTerm)
+ try:
+ self.state = 2636
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Catenate]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2625
+ self.vfrExpressionCatenate(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Match]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2626
+ self.vfrExpressionMatch(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Match2]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2627
+ self.vfrExpressionMatch2(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.OpenParen]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2628
+ self.vfrExpressionParen(ExpInfo)
+ pass
+ 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 = 2629
+ self.vfrExpressionBuildInFunction(ExpInfo)
+ pass
+ 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 = 2630
+ self.vfrExpressionConstant(ExpInfo)
+ pass
+ 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 = 2631
+ self.vfrExpressionUnaryOp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Cond, VfrSyntaxParser.Find, VfrSyntaxParser.Mid, VfrSyntaxParser.Tok, VfrSyntaxParser.Span]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 2632
+ self.vfrExpressionTernaryOp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Map]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 2633
+ self.vfrExpressionMap(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.NOT]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 2634
+ self.match(VfrSyntaxParser.NOT)
+ self.state = 2635
+ self.atomTerm(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionCatenateContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Catenate(self):
+ return self.getToken(VfrSyntaxParser.Catenate, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionCatenate
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionCatenate" ):
+ return visitor.visitVfrExpressionCatenate(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionCatenate(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionCatenateContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 326, self.RULE_vfrExpressionCatenate)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2638
+ self.match(VfrSyntaxParser.Catenate)
+ self.state = 2639
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2640
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2641
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2642
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2643
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionMatchContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Match(self):
+ return self.getToken(VfrSyntaxParser.Match, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionMatch
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionMatch" ):
+ return visitor.visitVfrExpressionMatch(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionMatch(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionMatchContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 328, self.RULE_vfrExpressionMatch)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2645
+ self.match(VfrSyntaxParser.Match)
+ self.state = 2646
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2647
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2648
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2649
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2650
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionMatch2Context(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Match2(self):
+ return self.getToken(VfrSyntaxParser.Match2, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionMatch2
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionMatch2" ):
+ return visitor.visitVfrExpressionMatch2(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionMatch2(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionMatch2Context(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 330, self.RULE_vfrExpressionMatch2)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2652
+ self.match(VfrSyntaxParser.Match2)
+ self.state = 2653
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2654
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2655
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2656
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2657
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2658
+ self.guidDefinition()
+ self.state = 2659
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionParenContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionParen
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionParen" ):
+ return visitor.visitVfrExpressionParen(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionParen(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionParenContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 332, self.RULE_vfrExpressionParen)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2661
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2662
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2663
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionBuildInFunctionContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = None
+ self.ExpInfo = ExpInfo
+
+ def dupExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.DupExpContext,0)
+
+
+ def vareqvalExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VareqvalExpContext,0)
+
+
+ def ideqvalExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.IdeqvalExpContext,0)
+
+
+ def ideqidExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.IdeqidExpContext,0)
+
+
+ def ideqvallistExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.IdeqvallistExpContext,0)
+
+
+ def questionref1Exp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Questionref1ExpContext,0)
+
+
+ def rulerefExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.RulerefExpContext,0)
+
+
+ def stringref1Exp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Stringref1ExpContext,0)
+
+
+ def pushthisExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.PushthisExpContext,0)
+
+
+ def securityExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SecurityExpContext,0)
+
+
+ def getExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GetExpContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionBuildInFunction
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionBuildInFunction" ):
+ return visitor.visitVfrExpressionBuildInFunction(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionBuildInFunction(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionBuildInFunctionContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 334, self.RULE_vfrExpressionBuildInFunction)
+ try:
+ self.state = 2676
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Dup]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2665
+ self.dupExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.VarEqVal]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2666
+ self.vareqvalExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.IdEqVal]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2667
+ self.ideqvalExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.IdEqId]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2668
+ self.ideqidExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.IdEqValList]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2669
+ self.ideqvallistExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.QuestionRef]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2670
+ self.questionref1Exp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.RuleRef]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 2671
+ self.rulerefExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.StringRef]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 2672
+ self.stringref1Exp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.PushThis]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 2673
+ self.pushthisExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Security]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 2674
+ self.securityExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Get]:
+ self.enterOuterAlt(localctx, 11)
+ self.state = 2675
+ self.getExp(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class DupExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = IfrTreeNode(EFI_IFR_DUP_OP)
+ self.ExpInfo = ExpInfo
+
+ def Dup(self):
+ return self.getToken(VfrSyntaxParser.Dup, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_dupExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitDupExp" ):
+ return visitor.visitDupExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def dupExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.DupExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 336, self.RULE_dupExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2678
+ self.match(VfrSyntaxParser.Dup)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VareqvalExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = None
+ self.VN = None # Token
+ self.ExpInfo = ExpInfo
+
+ def VarEqVal(self):
+ return self.getToken(VfrSyntaxParser.VarEqVal, 0)
+
+ def Var(self):
+ return self.getToken(VfrSyntaxParser.Var, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def 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 Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vareqvalExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVareqvalExp" ):
+ return visitor.visitVareqvalExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vareqvalExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VareqvalExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 338, self.RULE_vareqvalExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2680
+ self.match(VfrSyntaxParser.VarEqVal)
+ self.state = 2681
+ self.match(VfrSyntaxParser.Var)
+ self.state = 2682
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2683
+ localctx.VN = self.match(VfrSyntaxParser.Number)
+ self.state = 2684
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2695
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ self.state = 2685
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2686
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ self.state = 2687
+ self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2688
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Less]:
+ self.state = 2689
+ self.match(VfrSyntaxParser.Less)
+ self.state = 2690
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ self.state = 2691
+ self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2692
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ self.state = 2693
+ self.match(VfrSyntaxParser.Greater)
+ self.state = 2694
+ self.match(VfrSyntaxParser.Number)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class IdeqvalExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = None
+ self.I = None # Token
+ self.ExpInfo = ExpInfo
+
+ def vfrQuestionDataFieldName(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,0)
+
+
+ def IdEqVal(self):
+ return self.getToken(VfrSyntaxParser.IdEqVal, 0)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_ideqvalExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdeqvalExp" ):
+ return visitor.visitIdeqvalExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def ideqvalExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.IdeqvalExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 340, self.RULE_ideqvalExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2697
+ localctx.I = self.match(VfrSyntaxParser.IdEqVal)
+ self.state = 2698
+ self.vfrQuestionDataFieldName()
+ self.state = 2709
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ self.state = 2699
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2700
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ self.state = 2701
+ self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2702
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Less]:
+ self.state = 2703
+ self.match(VfrSyntaxParser.Less)
+ self.state = 2704
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ self.state = 2705
+ self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2706
+ self.match(VfrSyntaxParser.Number)
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ self.state = 2707
+ self.match(VfrSyntaxParser.Greater)
+ self.state = 2708
+ self.match(VfrSyntaxParser.Number)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class IdeqidExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = None
+ self.I = None # Token
+ self.E = None # Token
+ self.LE = None # Token
+ self.L = None # Token
+ self.BE = None # Token
+ self.B = None # Token
+ self.ExpInfo = ExpInfo
+
+ def vfrQuestionDataFieldName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrQuestionDataFieldNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,i)
+
+
+ def IdEqId(self):
+ return self.getToken(VfrSyntaxParser.IdEqId, 0)
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def LessEqual(self):
+ return self.getToken(VfrSyntaxParser.LessEqual, 0)
+
+ def Less(self):
+ return self.getToken(VfrSyntaxParser.Less, 0)
+
+ def GreaterEqual(self):
+ return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
+
+ def Greater(self):
+ return self.getToken(VfrSyntaxParser.Greater, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_ideqidExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdeqidExp" ):
+ return visitor.visitIdeqidExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def ideqidExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.IdeqidExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 342, self.RULE_ideqidExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2711
+ localctx.I = self.match(VfrSyntaxParser.IdEqId)
+ self.state = 2712
+ self.vfrQuestionDataFieldName()
+ self.state = 2723
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Equal]:
+ self.state = 2713
+ localctx.E = self.match(VfrSyntaxParser.Equal)
+ self.state = 2714
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.LessEqual]:
+ self.state = 2715
+ localctx.LE = self.match(VfrSyntaxParser.LessEqual)
+ self.state = 2716
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.Less]:
+ self.state = 2717
+ localctx.L = self.match(VfrSyntaxParser.Less)
+ self.state = 2718
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.GreaterEqual]:
+ self.state = 2719
+ localctx.BE = self.match(VfrSyntaxParser.GreaterEqual)
+ self.state = 2720
+ self.vfrQuestionDataFieldName()
+ pass
+ elif token in [VfrSyntaxParser.Greater]:
+ self.state = 2721
+ localctx.B = self.match(VfrSyntaxParser.Greater)
+ self.state = 2722
+ self.vfrQuestionDataFieldName()
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class IdeqvallistExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = None
+ self.ExpInfo = ExpInfo
+
+ def IdEqValList(self):
+ return self.getToken(VfrSyntaxParser.IdEqValList, 0)
+
+ def vfrQuestionDataFieldName(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,0)
+
+
+ def Equal(self):
+ return self.getToken(VfrSyntaxParser.Equal, 0)
+
+ def Number(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Number)
+ else:
+ return self.getToken(VfrSyntaxParser.Number, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_ideqvallistExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitIdeqvallistExp" ):
+ return visitor.visitIdeqvallistExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def ideqvallistExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.IdeqvallistExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 344, self.RULE_ideqvallistExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2725
+ self.match(VfrSyntaxParser.IdEqValList)
+ self.state = 2726
+ self.vfrQuestionDataFieldName()
+ self.state = 2727
+ self.match(VfrSyntaxParser.Equal)
+ self.state = 2729
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while True:
+ self.state = 2728
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2731
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if not (_la==VfrSyntaxParser.Number):
+ break
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrQuestionDataFieldNameContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.QId = EFI_QUESTION_ID_INVALID
+ self.Mask = 0
+ self.VarIdStr = ''
+ self.Line = None
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrQuestionDataFieldName
+
+
+ def copyFrom(self, ctx:ParserRuleContext):
+ super().copyFrom(ctx)
+ self.QId = ctx.QId
+ self.Mask = ctx.Mask
+ self.VarIdStr = ctx.VarIdStr
+ self.Line = ctx.Line
+
+
+
+ class VfrQuestionDataFieldNameRule2Context(VfrQuestionDataFieldNameContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrQuestionDataFieldNameContext
+ super().__init__(parser)
+ self.SN2 = None # Token
+ self.copyFrom(ctx)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Dot(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Dot)
+ else:
+ return self.getToken(VfrSyntaxParser.Dot, i)
+ def arrayName(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
+
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionDataFieldNameRule2" ):
+ return visitor.visitVfrQuestionDataFieldNameRule2(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+ class VfrQuestionDataFieldNameRule1Context(VfrQuestionDataFieldNameContext):
+
+ def __init__(self, parser, ctx:ParserRuleContext): # actually a VfrSyntaxParser.VfrQuestionDataFieldNameContext
+ super().__init__(parser)
+ self.SN1 = None # Token
+ self.I = None # Token
+ self.copyFrom(ctx)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrQuestionDataFieldNameRule1" ):
+ return visitor.visitVfrQuestionDataFieldNameRule1(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+ def vfrQuestionDataFieldName(self):
+
+ localctx = VfrSyntaxParser.VfrQuestionDataFieldNameContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 346, self.RULE_vfrQuestionDataFieldName)
+ self._la = 0 # Token type
+ try:
+ self.state = 2745
+ self._errHandler.sync(self)
+ la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
+ if la_ == 1:
+ localctx = VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context(self, localctx)
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2733
+ localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2734
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2735
+ localctx.I = self.match(VfrSyntaxParser.Number)
+ self.state = 2736
+ self.match(VfrSyntaxParser.CloseBracket)
+ pass
+
+ elif la_ == 2:
+ localctx = VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context(self, localctx)
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2737
+ localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2742
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.Dot:
+ self.state = 2738
+ self.match(VfrSyntaxParser.Dot)
+ self.state = 2739
+ self.arrayName()
+ self.state = 2744
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ pass
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ArrayNameContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.SubStr = ''
+ self.SubStrZ = ''
+ self.N = None # Token
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def OpenBracket(self):
+ return self.getToken(VfrSyntaxParser.OpenBracket, 0)
+
+ def CloseBracket(self):
+ return self.getToken(VfrSyntaxParser.CloseBracket, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_arrayName
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitArrayName" ):
+ return visitor.visitArrayName(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def arrayName(self):
+
+ localctx = VfrSyntaxParser.ArrayNameContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 348, self.RULE_arrayName)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ 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 = 2748
+ self.match(VfrSyntaxParser.OpenBracket)
+ self.state = 2749
+ localctx.N = self.match(VfrSyntaxParser.Number)
+ self.state = 2750
+ self.match(VfrSyntaxParser.CloseBracket)
+
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Questionref1ExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = IfrTreeNode(EFI_IFR_QUESTION_REF1_OP)
+ self.ExpInfo = ExpInfo
+
+ def QuestionRef(self):
+ return self.getToken(VfrSyntaxParser.QuestionRef, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_questionref1Exp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitQuestionref1Exp" ):
+ return visitor.visitQuestionref1Exp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def questionref1Exp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Questionref1ExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 350, self.RULE_questionref1Exp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2753
+ self.match(VfrSyntaxParser.QuestionRef)
+ self.state = 2754
+ self.match(VfrSyntaxParser.OpenParen)
+ 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 = 2756
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class RulerefExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = IfrTreeNode(EFI_IFR_RULE_REF_OP)
+ self.ExpInfo = ExpInfo
+
+ def RuleRef(self):
+ return self.getToken(VfrSyntaxParser.RuleRef, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def StringIdentifier(self):
+ return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_rulerefExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitRulerefExp" ):
+ return visitor.visitRulerefExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def rulerefExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.RulerefExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 352, self.RULE_rulerefExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2758
+ self.match(VfrSyntaxParser.RuleRef)
+ self.state = 2759
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2760
+ self.match(VfrSyntaxParser.StringIdentifier)
+ self.state = 2761
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Stringref1ExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = IfrTreeNode(EFI_IFR_STRING_REF1_OP)
+ self.ExpInfo = ExpInfo
+
+ def StringRef(self):
+ return self.getToken(VfrSyntaxParser.StringRef, 0)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_stringref1Exp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStringref1Exp" ):
+ return visitor.visitStringref1Exp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def stringref1Exp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Stringref1ExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 354, self.RULE_stringref1Exp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2763
+ self.match(VfrSyntaxParser.StringRef)
+ self.state = 2764
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2770
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.StringToken]:
+ self.state = 2765
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2766
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2767
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2768
+ self.match(VfrSyntaxParser.CloseParen)
+ pass
+ elif token in [VfrSyntaxParser.Number]:
+ self.state = 2769
+ self.match(VfrSyntaxParser.Number)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ self.state = 2772
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class PushthisExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = IfrTreeNode(EFI_IFR_THIS_OP)
+ self.ExpInfo = ExpInfo
+
+ def PushThis(self):
+ return self.getToken(VfrSyntaxParser.PushThis, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_pushthisExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitPushthisExp" ):
+ return visitor.visitPushthisExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def pushthisExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.PushthisExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 356, self.RULE_pushthisExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2774
+ self.match(VfrSyntaxParser.PushThis)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SecurityExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = IfrTreeNode(EFI_IFR_SECURITY_OP)
+ self.ExpInfo = ExpInfo
+
+ def Security(self):
+ return self.getToken(VfrSyntaxParser.Security, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_securityExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSecurityExp" ):
+ return visitor.visitSecurityExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def securityExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.SecurityExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 358, self.RULE_securityExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2776
+ self.match(VfrSyntaxParser.Security)
+ self.state = 2777
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2778
+ self.guidDefinition()
+ self.state = 2779
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class NumericVarStoreTypeContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.VarType = None
+
+ def NumericSizeOne(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
+
+ def NumericSizeTwo(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
+
+ def NumericSizeFour(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
+
+ def NumericSizeEight(self):
+ return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_numericVarStoreType
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitNumericVarStoreType" ):
+ return visitor.visitNumericVarStoreType(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def numericVarStoreType(self):
+
+ localctx = VfrSyntaxParser.NumericVarStoreTypeContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 360, self.RULE_numericVarStoreType)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class GetExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.BaseInfo = EFI_VARSTORE_INFO()
+ self.Node = IfrTreeNode(EFI_IFR_GET_OP)
+ self.ExpInfo = ExpInfo
+
+ def Get(self):
+ return self.getToken(VfrSyntaxParser.Get, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStorageVarId(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self):
+ return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def numericVarStoreType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_getExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitGetExp" ):
+ return visitor.visitGetExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def getExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.GetExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 362, self.RULE_getExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2783
+ self.match(VfrSyntaxParser.Get)
+ self.state = 2784
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2785
+ self.vfrStorageVarId(localctx.BaseInfo, False)
+ self.state = 2790
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2786
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2787
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2788
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2789
+ self.numericVarStoreType()
+
+
+ self.state = 2792
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionConstantContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Node = None
+ self.ExpInfo = ExpInfo
+
+ def TrueSymbol(self):
+ return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
+
+ def FalseSymbol(self):
+ return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
+
+ def One(self):
+ return self.getToken(VfrSyntaxParser.One, 0)
+
+ def Ones(self):
+ return self.getToken(VfrSyntaxParser.Ones, 0)
+
+ def Zero(self):
+ return self.getToken(VfrSyntaxParser.Zero, 0)
+
+ def Undefined(self):
+ return self.getToken(VfrSyntaxParser.Undefined, 0)
+
+ def Version(self):
+ return self.getToken(VfrSyntaxParser.Version, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionConstant
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionConstant" ):
+ return visitor.visitVfrExpressionConstant(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionConstant(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionConstantContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 364, self.RULE_vfrExpressionConstant)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionUnaryOpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = None
+ self.ExpInfo = ExpInfo
+
+ def lengthExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.LengthExpContext,0)
+
+
+ def bitwisenotExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.BitwisenotExpContext,0)
+
+
+ def question23refExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Question23refExpContext,0)
+
+
+ def stringref2Exp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.Stringref2ExpContext,0)
+
+
+ def toboolExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ToboolExpContext,0)
+
+
+ def tostringExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.TostringExpContext,0)
+
+
+ def unintExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.UnintExpContext,0)
+
+
+ def toupperExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ToupperExpContext,0)
+
+
+ def tolwerExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.TolwerExpContext,0)
+
+
+ def setExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SetExpContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionUnaryOp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionUnaryOp" ):
+ return visitor.visitVfrExpressionUnaryOp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionUnaryOp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionUnaryOpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 366, self.RULE_vfrExpressionUnaryOp)
+ try:
+ self.state = 2806
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Length]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2796
+ self.lengthExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.BitWiseNot]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2797
+ self.bitwisenotExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.QuestionRefVal]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2798
+ self.question23refExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.StringRefVal]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2799
+ self.stringref2Exp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.BoolVal]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2800
+ self.toboolExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.StringVal]:
+ self.enterOuterAlt(localctx, 6)
+ self.state = 2801
+ self.tostringExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.UnIntVal]:
+ self.enterOuterAlt(localctx, 7)
+ self.state = 2802
+ self.unintExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.ToUpper]:
+ self.enterOuterAlt(localctx, 8)
+ self.state = 2803
+ self.toupperExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.ToLower]:
+ self.enterOuterAlt(localctx, 9)
+ self.state = 2804
+ self.tolwerExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Set]:
+ self.enterOuterAlt(localctx, 10)
+ self.state = 2805
+ self.setExp(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class LengthExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Length(self):
+ return self.getToken(VfrSyntaxParser.Length, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_lengthExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitLengthExp" ):
+ return visitor.visitLengthExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def lengthExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.LengthExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 368, self.RULE_lengthExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2808
+ self.match(VfrSyntaxParser.Length)
+ self.state = 2809
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2810
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2811
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class BitwisenotExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def BitWiseNot(self):
+ return self.getToken(VfrSyntaxParser.BitWiseNot, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_bitwisenotExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitBitwisenotExp" ):
+ return visitor.visitBitwisenotExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def bitwisenotExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.BitwisenotExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 370, self.RULE_bitwisenotExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2813
+ self.match(VfrSyntaxParser.BitWiseNot)
+ self.state = 2814
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2815
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2816
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Question23refExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def QuestionRefVal(self):
+ return self.getToken(VfrSyntaxParser.QuestionRefVal, 0)
+
+ def OpenParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.OpenParen)
+ else:
+ return self.getToken(VfrSyntaxParser.OpenParen, i)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.CloseParen)
+ else:
+ return self.getToken(VfrSyntaxParser.CloseParen, i)
+
+ def DevicePath(self):
+ return self.getToken(VfrSyntaxParser.DevicePath, 0)
+
+ def StringToken(self):
+ return self.getToken(VfrSyntaxParser.StringToken, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Uuid(self):
+ return self.getToken(VfrSyntaxParser.Uuid, 0)
+
+ def guidDefinition(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_question23refExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitQuestion23refExp" ):
+ return visitor.visitQuestion23refExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def question23refExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Question23refExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 372, self.RULE_question23refExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2818
+ self.match(VfrSyntaxParser.QuestionRefVal)
+ self.state = 2819
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2827
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.DevicePath:
+ self.state = 2820
+ self.match(VfrSyntaxParser.DevicePath)
+ self.state = 2821
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2822
+ self.match(VfrSyntaxParser.StringToken)
+ self.state = 2823
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2824
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2825
+ self.match(VfrSyntaxParser.CloseParen)
+ self.state = 2826
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2834
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.Uuid:
+ self.state = 2829
+ self.match(VfrSyntaxParser.Uuid)
+ self.state = 2830
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2831
+ self.guidDefinition()
+ self.state = 2832
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2836
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2837
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class Stringref2ExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def StringRefVal(self):
+ return self.getToken(VfrSyntaxParser.StringRefVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_stringref2Exp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitStringref2Exp" ):
+ return visitor.visitStringref2Exp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def stringref2Exp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.Stringref2ExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 374, self.RULE_stringref2Exp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2839
+ self.match(VfrSyntaxParser.StringRefVal)
+ self.state = 2840
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2841
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2842
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ToboolExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def BoolVal(self):
+ return self.getToken(VfrSyntaxParser.BoolVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_toboolExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitToboolExp" ):
+ return visitor.visitToboolExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def toboolExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ToboolExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 376, self.RULE_toboolExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2844
+ self.match(VfrSyntaxParser.BoolVal)
+ self.state = 2845
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2846
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2847
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TostringExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def StringVal(self):
+ return self.getToken(VfrSyntaxParser.StringVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_tostringExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTostringExp" ):
+ return visitor.visitTostringExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def tostringExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.TostringExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 378, self.RULE_tostringExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2849
+ self.match(VfrSyntaxParser.StringVal)
+ self.state = 2854
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.T__14:
+ self.state = 2850
+ self.match(VfrSyntaxParser.T__14)
+ self.state = 2851
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2852
+ self.match(VfrSyntaxParser.Number)
+ self.state = 2853
+ self.match(VfrSyntaxParser.Comma)
+
+
+ self.state = 2856
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2857
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2858
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class UnintExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def UnIntVal(self):
+ return self.getToken(VfrSyntaxParser.UnIntVal, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_unintExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitUnintExp" ):
+ return visitor.visitUnintExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def unintExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.UnintExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 380, self.RULE_unintExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2860
+ self.match(VfrSyntaxParser.UnIntVal)
+ self.state = 2861
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2862
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2863
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ToupperExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def ToUpper(self):
+ return self.getToken(VfrSyntaxParser.ToUpper, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_toupperExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitToupperExp" ):
+ return visitor.visitToupperExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def toupperExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ToupperExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 382, self.RULE_toupperExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2865
+ self.match(VfrSyntaxParser.ToUpper)
+ self.state = 2866
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2867
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2868
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TolwerExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def ToLower(self):
+ return self.getToken(VfrSyntaxParser.ToLower, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_tolwerExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTolwerExp" ):
+ return visitor.visitTolwerExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def tolwerExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.TolwerExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 384, self.RULE_tolwerExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2870
+ self.match(VfrSyntaxParser.ToLower)
+ self.state = 2871
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2872
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2873
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SetExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.BaseInfo = EFI_VARSTORE_INFO()
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Set(self):
+ return self.getToken(VfrSyntaxParser.Set, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStorageVarId(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
+
+
+ def Comma(self):
+ return self.getToken(VfrSyntaxParser.Comma, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self):
+ return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def numericVarStoreType(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_setExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSetExp" ):
+ return visitor.visitSetExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def setExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.SetExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 386, self.RULE_setExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2875
+ self.match(VfrSyntaxParser.Set)
+ self.state = 2876
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2877
+ self.vfrStorageVarId(localctx.BaseInfo, False)
+ self.state = 2882
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ if _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2878
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2879
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2880
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2881
+ self.numericVarStoreType()
+
+
+ self.state = 2884
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2885
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2886
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionTernaryOpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = None
+ self.ExpInfo = ExpInfo
+
+ def conditionalExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.ConditionalExpContext,0)
+
+
+ def findExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.FindExpContext,0)
+
+
+ def midExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.MidExpContext,0)
+
+
+ def tokenExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.TokenExpContext,0)
+
+
+ def spanExp(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.SpanExpContext,0)
+
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionTernaryOp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionTernaryOp" ):
+ return visitor.visitVfrExpressionTernaryOp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionTernaryOp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionTernaryOpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 388, self.RULE_vfrExpressionTernaryOp)
+ try:
+ self.state = 2893
+ self._errHandler.sync(self)
+ token = self._input.LA(1)
+ if token in [VfrSyntaxParser.Cond]:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2888
+ self.conditionalExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Find]:
+ self.enterOuterAlt(localctx, 2)
+ self.state = 2889
+ self.findExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Mid]:
+ self.enterOuterAlt(localctx, 3)
+ self.state = 2890
+ self.midExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Tok]:
+ self.enterOuterAlt(localctx, 4)
+ self.state = 2891
+ self.tokenExp(ExpInfo)
+ pass
+ elif token in [VfrSyntaxParser.Span]:
+ self.enterOuterAlt(localctx, 5)
+ self.state = 2892
+ self.spanExp(ExpInfo)
+ pass
+ else:
+ raise NoViableAltException(self)
+
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class ConditionalExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Cond(self):
+ return self.getToken(VfrSyntaxParser.Cond, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_conditionalExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitConditionalExp" ):
+ return visitor.visitConditionalExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def conditionalExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.ConditionalExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 390, self.RULE_conditionalExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2895
+ self.match(VfrSyntaxParser.Cond)
+ self.state = 2896
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2897
+ 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
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FindExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Find(self):
+ return self.getToken(VfrSyntaxParser.Find, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def findFormat(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.FindFormatContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.FindFormatContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_findExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFindExp" ):
+ return visitor.visitFindExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def findExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.FindExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 392, self.RULE_findExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2904
+ self.match(VfrSyntaxParser.Find)
+ self.state = 2905
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2906
+ self.findFormat(ExpInfo)
+ self.state = 2911
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2907
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2908
+ self.findFormat(ExpInfo)
+ self.state = 2913
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2914
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2915
+ 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
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class FindFormatContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Format = 0
+ self.ExpInfo = ExpInfo
+
+ def Sensitive(self):
+ return self.getToken(VfrSyntaxParser.Sensitive, 0)
+
+ def Insensitive(self):
+ return self.getToken(VfrSyntaxParser.Insensitive, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_findFormat
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitFindFormat" ):
+ return visitor.visitFindFormat(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def findFormat(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.FindFormatContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 394, self.RULE_findFormat)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2922
+ _la = self._input.LA(1)
+ if not(_la==VfrSyntaxParser.Insensitive or _la==VfrSyntaxParser.Sensitive):
+ self._errHandler.recoverInline(self)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class MidExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Mid(self):
+ return self.getToken(VfrSyntaxParser.Mid, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_midExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitMidExp" ):
+ return visitor.visitMidExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def midExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.MidExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 396, self.RULE_midExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2924
+ self.match(VfrSyntaxParser.Mid)
+ self.state = 2925
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2926
+ 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
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class TokenExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Tok(self):
+ return self.getToken(VfrSyntaxParser.Tok, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_tokenExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitTokenExp" ):
+ return visitor.visitTokenExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def tokenExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.TokenExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 398, self.RULE_tokenExp)
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2933
+ self.match(VfrSyntaxParser.Tok)
+ self.state = 2934
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2935
+ 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
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SpanExpContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.ExpInfo = ExpInfo
+
+ def Span(self):
+ return self.getToken(VfrSyntaxParser.Span, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def FLAGS(self):
+ return self.getToken(VfrSyntaxParser.FLAGS, 0)
+
+ def spanFlags(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.SpanFlagsContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.SpanFlagsContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def vfrStatementExpressionSub(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,i)
+
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def BitWiseOr(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.BitWiseOr)
+ else:
+ return self.getToken(VfrSyntaxParser.BitWiseOr, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_spanExp
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSpanExp" ):
+ return visitor.visitSpanExp(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def spanExp(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.SpanExpContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 400, self.RULE_spanExp)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2942
+ self.match(VfrSyntaxParser.Span)
+ self.state = 2943
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2944
+ self.match(VfrSyntaxParser.FLAGS)
+ self.state = 2945
+ self.match(VfrSyntaxParser.T__5)
+ self.state = 2946
+ self.spanFlags()
+ self.state = 2951
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+ while _la==VfrSyntaxParser.BitWiseOr:
+ self.state = 2947
+ self.match(VfrSyntaxParser.BitWiseOr)
+ self.state = 2948
+ self.spanFlags()
+ self.state = 2953
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2954
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2955
+ 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
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class SpanFlagsContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.Flag = 0
+
+ def Number(self):
+ return self.getToken(VfrSyntaxParser.Number, 0)
+
+ def LastNonMatch(self):
+ return self.getToken(VfrSyntaxParser.LastNonMatch, 0)
+
+ def FirstNonMatch(self):
+ return self.getToken(VfrSyntaxParser.FirstNonMatch, 0)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_spanFlags
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitSpanFlags" ):
+ return visitor.visitSpanFlags(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def spanFlags(self):
+
+ localctx = VfrSyntaxParser.SpanFlagsContext(self, self._ctx, self.state)
+ self.enterRule(localctx, 402, self.RULE_spanFlags)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ 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)
+ else:
+ self._errHandler.reportMatch(self)
+ self.consume()
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
+
+
+ class VfrExpressionMapContext(ParserRuleContext):
+
+ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1, ExpInfo=None):
+ super().__init__(parent, invokingState)
+ self.parser = parser
+ self.ExpInfo = None
+ self.Nodes = []
+ self.Node = IfrTreeNode()
+ self.ExpInfo = ExpInfo
+
+ def Map(self):
+ return self.getToken(VfrSyntaxParser.Map, 0)
+
+ def OpenParen(self):
+ return self.getToken(VfrSyntaxParser.OpenParen, 0)
+
+ def vfrStatementExpressionSub(self):
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,0)
+
+
+ def Colon(self):
+ return self.getToken(VfrSyntaxParser.Colon, 0)
+
+ def CloseParen(self):
+ return self.getToken(VfrSyntaxParser.CloseParen, 0)
+
+ def vfrStatementExpression(self, i:int=None):
+ if i is None:
+ return self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionContext)
+ else:
+ return self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,i)
+
+
+ def Comma(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Comma)
+ else:
+ return self.getToken(VfrSyntaxParser.Comma, i)
+
+ def Semicolon(self, i:int=None):
+ if i is None:
+ return self.getTokens(VfrSyntaxParser.Semicolon)
+ else:
+ return self.getToken(VfrSyntaxParser.Semicolon, i)
+
+ def getRuleIndex(self):
+ return VfrSyntaxParser.RULE_vfrExpressionMap
+
+ def accept(self, visitor:ParseTreeVisitor):
+ if hasattr( visitor, "visitVfrExpressionMap" ):
+ return visitor.visitVfrExpressionMap(self)
+ else:
+ return visitor.visitChildren(self)
+
+
+
+
+ def vfrExpressionMap(self, ExpInfo):
+
+ localctx = VfrSyntaxParser.VfrExpressionMapContext(self, self._ctx, self.state, ExpInfo)
+ self.enterRule(localctx, 404, self.RULE_vfrExpressionMap)
+ self._la = 0 # Token type
+ try:
+ self.enterOuterAlt(localctx, 1)
+ self.state = 2964
+ self.match(VfrSyntaxParser.Map)
+ self.state = 2965
+ self.match(VfrSyntaxParser.OpenParen)
+ self.state = 2966
+ self.vfrStatementExpressionSub(localctx.Nodes)
+ self.state = 2967
+ self.match(VfrSyntaxParser.Colon)
+ 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 = 2968
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2969
+ self.match(VfrSyntaxParser.Comma)
+ self.state = 2970
+ self.vfrStatementExpression(localctx.Node)
+ self.state = 2971
+ self.match(VfrSyntaxParser.Semicolon)
+ self.state = 2977
+ self._errHandler.sync(self)
+ _la = self._input.LA(1)
+
+ self.state = 2978
+ self.match(VfrSyntaxParser.CloseParen)
+ except RecognitionException as re:
+ localctx.exception = re
+ self._errHandler.reportError(self, re)
+ self._errHandler.recover(self, re)
+ finally:
+ self.exitRule()
+ return localctx
diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
new file mode 100644
index 0000000000..622e63347c
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
@@ -0,0 +1,5504 @@
+## @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_OPCODE, ctx.O.line, ctx.O.text
+ )
+
+ elif ctx.NVAccessFlag() != None:
+ gVfrErrorHandle.HandleWarning(
+ EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.N.line, ctx.N.text
+ )
+
+ elif ctx.LateCheckFlag() != None:
+ gVfrErrorHandle.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 = 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_OPCODE, ctx.N.line, ctx.N.text
+ )
+ if ctx.L != None:
+ VfrErrorHandle.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:
+ 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_OPCODE, ctx.A.line, ctx.A.text
+ )
+ if ctx.LateCheckFlag() != None:
+ gVfrErrorHandle.HandleWarning(
+ EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text
+ )
+
+ return ctx.HFlag, ctx.LFlag
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRead.
+ def visitVfrStatementRead(self, ctx: VfrSyntaxParser.VfrStatementReadContext):
+ RObj = 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/__init__.py b/BaseTools/Source/Python/VfrCompiler/__init__.py
new file mode 100644
index 0000000000..72d3a47bb7
--- /dev/null
+++ b/BaseTools/Source/Python/VfrCompiler/__init__.py
@@ -0,0 +1 @@
+__all__ = ["VfrCompiler"]
--
2.39.1.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#110918): https://edk2.groups.io/g/devel/message/110918
Mute This Topic: https://groups.io/mt/102463460/7686176
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [rebecca@openfw.io]
-=-=-=-=-=-=-=-=-=-=-=-
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [edk2-devel] [PATCH] BaseTools: Python VfrCompiler implementation
2023-11-08 12:45 Yuting Yang
@ 2023-11-08 13:45 ` Yuwei Chen
[not found] ` <1795A9DEEBB01830.6123@groups.io>
1 sibling, 0 replies; 4+ messages in thread
From: Yuwei Chen @ 2023-11-08 13:45 UTC (permalink / raw)
To: Rebecca Cran, Gao, Liming, Zimmer, Vincent
Cc: Feng, Bob C, Yang, Yuting2, devel@edk2.groups.io,
Hartung, Stephen
Hi Liming and Cran,
Could you help on quick reviewing this new VfrCompiler python tool, it has the same functions with origin C version VfrCompiler, meanwhile it supports more new features such as generated Vfr files config info into Yaml format.
This feature is urgent for us to use, and we really hope it can be merged into this stable tag. This patch is linked to the edk2-basetools PR: https://github.com/tianocore/edk2-basetools/pull/109. We list all the known issues which will be enhanced in the ReadMe file. And will enhance them one by one after the patch merged.
For the code quality, in this patch, the new tool is not enabled in build process, it just saves in the basetools python folder, which will not influence the current edk2 behaviors. We will enable it with a new patch when everything is ready.
Many thanks~
Hi Vincent, please help add more information if necessary~ Thanks a lot~
Thanks,
Christine
> -----Original Message-----
> From: Yang, Yuting2 <yuting2.yang@intel.com>
> Sent: Wednesday, November 8, 2023 8:46 PM
> To: devel@edk2.groups.io
> Cc: Rebecca Cran <rebecca@bsdio.com>; Gao, Liming
> <gaoliming@byosoft.com.cn>; Feng, Bob C <bob.c.feng@intel.com>; Chen,
> Christine <yuwei.chen@intel.com>
> Subject: [PATCH] BaseTools: Python VfrCompiler implementation
>
> 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>
> Signed-off-by: Yuwei Chen <yuwei.chen@intel.com>
> ---
> .../Source/Python/VfrCompiler/IfrCommon.py | 100 +
> .../Source/Python/VfrCompiler/IfrCompiler.py | 586 +
> .../Source/Python/VfrCompiler/IfrCtypes.py | 1811 ++
> .../Source/Python/VfrCompiler/IfrError.py | 153 +
> .../Source/Python/VfrCompiler/IfrFormPkg.py | 2937 +++
> .../Python/VfrCompiler/IfrPreProcess.py | 245 +
> .../Source/Python/VfrCompiler/IfrTree.py | 1132 +
> .../Source/Python/VfrCompiler/IfrUtility.py | 2226 ++
> BaseTools/Source/Python/VfrCompiler/Readme.md | 68 +
> .../Source/Python/VfrCompiler/VfrSyntax.g4 | 1921 ++
> .../Python/VfrCompiler/VfrSyntaxLexer.py | 1708 ++
> .../Python/VfrCompiler/VfrSyntaxParser.py | 20475 ++++++++++++++++
> .../Python/VfrCompiler/VfrSyntaxVisitor.py | 5504 +++++
> .../Source/Python/VfrCompiler/__init__.py | 1 +
> 14 files changed, 38867 insertions(+)
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrError.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrTree.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/Readme.md
> create mode 100644 BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> create mode 100644
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> create mode 100644
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> create mode 100644
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> create mode 100644 BaseTools/Source/Python/VfrCompiler/__init__.py
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> new file mode 100644
> index 0000000000..7425abe9a9
> --- /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..15bf3d59ba
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> @@ -0,0 +1,586 @@
> +## @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.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..a7f7a32a27
> --- /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..c50288e9e5
> --- /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..35f50b0cef
> --- /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..ed454cdcf3
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> @@ -0,0 +1,245 @@
> +## @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 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._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)
>
> + return UniDict
>
> +
>
> + 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..faa2e4677d
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrTree.py
> @@ -0,0 +1,1132 @@
> +## @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()
>
> + 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 _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
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> new file mode 100644
> index 0000000000..3c5cec25ce
> --- /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
> new file mode 100644
> index 0000000000..7bdc85023a
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/Readme.md
> @@ -0,0 +1,68 @@
> +# 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/VfrSyntax.g4
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> new file mode 100644
> index 0000000000..2895377b74
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> @@ -0,0 +1,1921 @@
> +//// @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
> new file mode 100644
> index 0000000000..0e165a0446
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> @@ -0,0 +1,1708 @@
> +# Generated from VfrSyntax.g4 by ANTLR 4.7.2
>
> +
>
> +import sys
>
> +from antlr4 import *
>
> +from io import StringIO
>
> +from typing import TextIO
>
> +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\2\u010
> 2")
>
> + buf.write("\u0ab7\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
>
> + buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
>
> + buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
>
> + buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
>
> + buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
>
> + buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
>
> + buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
>
> + buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
>
> + buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
>
> + buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
>
> + buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\t")
>
> +
> buf.write("L\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\t")
>
> + buf.write("U\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4")
>
> + buf.write("^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4")
>
> + buf.write("g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4")
>
> + buf.write("p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4")
>
> + buf.write("y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080")
>
> +
> buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083")
>
> +
> buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087")
>
> +
> buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a")
>
> +
> buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e")
>
> +
> buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091")
>
> +
> buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095")
>
> +
> buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098")
>
> +
> buf.write("\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c")
>
> +
> buf.write("\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f")
>
> +
> buf.write("\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3")
>
> +
> buf.write("\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6")
>
> +
> buf.write("\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa")
>
> +
> buf.write("\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad")
>
> +
> buf.write("\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1")
>
> +
> buf.write("\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4")
>
> +
> buf.write("\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8")
>
> +
> buf.write("\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb")
>
> +
> buf.write("\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf")
>
> +
> buf.write("\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2")
>
> +
> buf.write("\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6")
>
> +
> buf.write("\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9")
>
> +
> buf.write("\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd")
>
> +
> buf.write("\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0")
>
> +
> buf.write("\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4")
>
> +
> buf.write("\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7")
>
> +
> buf.write("\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db")
>
> +
> buf.write("\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de")
>
> +
> buf.write("\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2")
>
> +
> buf.write("\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5")
>
> +
> buf.write("\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9")
>
> +
> buf.write("\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec")
>
> +
> buf.write("\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0")
>
> + buf.write("\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3")
>
> + buf.write("\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7")
>
> + buf.write("\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa")
>
> + buf.write("\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe")
>
> +
> buf.write("\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101")
>
> + buf.write("\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3")
>
> + buf.write("\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6")
>
> + buf.write("\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
>
> + buf.write("\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n")
>
> + buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3")
>
> + buf.write("\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20")
>
> + buf.write("\3\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\3\22")
>
> + buf.write("\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
>
> + buf.write("\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
>
> + buf.write("\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30\3\31")
>
> + buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36")
>
> + buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3")
>
> + buf.write("%\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3")
>
> + buf.write(")\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3")
>
> + buf.write("+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3")
>
> + buf.write("-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60")
>
> + buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61")
>
> + buf.write("\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
>
> + buf.write("\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63")
>
> + buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64")
>
> + buf.write("\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
>
> + buf.write("\3\65\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67")
>
> + buf.write("\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\39\39\39\3")
>
> + buf.write("9\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\3")
>
> + buf.write(";\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3")
>
> +
> buf.write(">\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3")
>
> +
> buf.write("A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3")
>
> +
> buf.write("C\3D\3D\3D\3D\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3")
>
> +
> buf.write("G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3")
>
> + buf.write("I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3L\3")
>
> +
> buf.write("L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\
> 3")
>
> +
> buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3"
> )
>
> +
> buf.write("O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3")
>
> +
> buf.write("Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3")
>
> +
> buf.write("T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3")
>
> +
> buf.write("V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\
> 3W\3")
>
> +
> buf.write("W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3")
>
> + buf.write("Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3")
>
> + buf.write("[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
>
> + buf.write("\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3")
>
> + buf.write("^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3")
>
> + buf.write("`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3")
>
> +
> buf.write("c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3")
>
> + buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3")
>
> + buf.write("g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3")
>
> + buf.write("i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3k\3k\3")
>
> + buf.write("k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3")
>
> +
> buf.write("m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3")
>
> +
> buf.write("o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3")
>
> +
> buf.write("p\3p\3p\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3")
>
> + buf.write("r\3r\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3u\3u\3u\3u\3")
>
> +
> buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3")
>
> +
> buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3")
>
> +
> buf.write("w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3"
> )
>
> + buf.write("x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3z\3z\3")
>
> + buf.write("z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3")
>
> + buf.write("{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3")
>
> + buf.write("|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3")
>
> + buf.write("~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3")
>
> +
> buf.write("\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080")
>
> +
> buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081")
>
> +
> buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081")
>
> +
> buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082")
>
> +
> buf.write("\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083")
>
> +
> buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084")
>
> +
> buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085")
>
> +
> buf.write("\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086")
>
> +
> buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087")
>
> +
> buf.write("\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088")
>
> +
> buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089")
>
> +
> buf.write("\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
>
> +
> buf.write("\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
>
> +
> buf.write("\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d")
>
> +
> buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e")
>
> +
> buf.write("\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f")
>
> +
> buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090")
>
> +
> buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090")
>
> +
> buf.write("\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091")
>
> +
> buf.write("\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092")
>
> +
> buf.write("\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094")
>
> +
> buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094")
>
> +
> buf.write("\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096")
>
> +
> buf.write("\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097")
>
> +
> buf.write("\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098")
>
> +
> buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098")
>
> +
> buf.write("\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
>
> +
> buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
>
> +
> buf.write("\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
>
> +
> buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
>
> +
> buf.write("\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b")
>
> +
> buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c")
>
> +
> buf.write("\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d")
>
> +
> buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d")
>
> +
> buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e")
>
> +
> buf.write("\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f")
>
> +
> buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
>
> +
> buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
>
> +
> buf.write("\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0")
>
> +
> buf.write("\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1")
>
> +
> buf.write("\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2")
>
> +
> buf.write("\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3")
>
> +
> buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a4")
>
> +
> buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
>
> +
> buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
>
> +
> buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
>
> +
> buf.write("\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
>
> +
> buf.write("\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
>
> +
> buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8")
>
> +
> buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
>
> +
> buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa")
>
> +
> buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab")
>
> +
> buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
>
> +
> buf.write("\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
>
> +
> buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad")
>
> +
> buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad")
>
> +
> buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae")
>
> +
> buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
>
> +
> buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af")
>
> +
> buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af")
>
> +
> buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0")
>
> +
> buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
>
> +
> buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1")
>
> +
> buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1")
>
> +
> buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2")
>
> +
> buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
>
> +
> buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
>
> +
> buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
>
> +
> buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
>
> +
> buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
>
> +
> buf.write("\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4")
>
> +
> buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5")
>
> +
> buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5")
>
> +
> buf.write("\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
>
> +
> buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
>
> +
> buf.write("\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
>
> +
> buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
>
> +
> buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
>
> +
> buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
>
> +
> buf.write("\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
>
> +
> buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
>
> +
> buf.write("\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
>
> +
> buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
>
> +
> buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb")
>
> +
> buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"
> )
>
> +
> buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc")
>
> +
> buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
>
> +
> buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
>
> +
> buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd"
> )
>
> +
> buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be"
> )
>
> +
> buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
>
> +
> buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
>
> +
> buf.write("\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf")
>
> +
> buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0")
>
> +
> buf.write("\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2")
>
> +
> buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3")
>
> +
> buf.write("\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
>
> +
> buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6")
>
> +
> buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
>
> +
> buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8")
>
> +
> buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
>
> +
> buf.write("\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca")
>
> +
> buf.write("\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
>
> +
> buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
>
> +
> buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc")
>
> +
> buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd")
>
> +
> buf.write("\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce")
>
> +
> buf.write("\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce")
>
> +
> buf.write("\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf")
>
> +
> buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0")
>
> +
> buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1")
>
> +
> buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2")
>
> +
> buf.write("\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3")
>
> +
> buf.write("\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5")
>
> +
> buf.write("\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6")
>
> +
> buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7")
>
> +
> buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8")
>
> +
> buf.write("\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9")
>
> +
> buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da")
>
> +
> buf.write("\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc")
>
> +
> buf.write("\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de")
>
> +
> buf.write("\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df")
>
> +
> buf.write("\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0")
>
> +
> buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1")
>
> +
> buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2")
>
> +
> buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2")
>
> +
> buf.write("\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3")
>
> +
> buf.write("\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4")
>
> +
> buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5")
>
> +
> buf.write("\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6")
>
> +
> buf.write("\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
>
> +
> buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
>
> +
> buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
>
> +
> buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
>
> +
> buf.write("\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea")
>
> +
> buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea")
>
> +
> buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb")
>
> +
> buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb")
>
> +
> buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
>
> +
> buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
>
> +
> buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed")
>
> +
> buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
>
> +
> buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
>
> +
> buf.write("\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
>
> +
> buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
>
> +
> buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
>
> +
> buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
>
> +
> buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0")
>
> +
> buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0")
>
> +
> buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1")
>
> +
> buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1")
>
> +
> buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2")
>
> +
> buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
>
> +
> buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
>
> +
> buf.write("\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
>
> +
> buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
>
> +
> buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4")
>
> +
> buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
>
> +
> buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
>
> +
> buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5")
>
> +
> buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6")
>
> +
> buf.write("\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6")
>
> +
> buf.write("\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
>
> +
> buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
>
> +
> buf.write("\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
>
> +
> buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
>
> +
> buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9")
>
> + buf.write("\3\u00f9\6\u00f9\u0a44\n\u00f9\r\u00f9\16\u00f9\u0a45")
>
> + buf.write("\3\u00f9\6\u00f9\u0a49\n\u00f9\r\u00f9\16\u00f9\u0a4a")
>
> +
> buf.write("\5\u00f9\u0a4d\n\u00f9\3\u00fa\3\u00fa\7\u00fa\u0a51\n")
>
> + buf.write("\u00fa\f\u00fa\16\u00fa\u0a54\13\u00fa\3\u00fb\3\u00fb")
>
> + buf.write("\5\u00fb\u0a58\n\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fb")
>
> + buf.write("\3\u00fb\3\u00fb\3\u00fb\3\u00fb\7\u00fb\u0a62\n\u00fb")
>
> +
> buf.write("\f\u00fb\16\u00fb\u0a65\13\u00fb\3\u00fb\3\u00fb\3\u00fc")
>
> + buf.write("\3\u00fc\5\u00fc\u0a6b\n\u00fc\3\u00fc\3\u00fc\3\u00fc")
>
> + buf.write("\3\u00fc\3\u00fc\3\u00fc\7\u00fc\u0a73\n\u00fc\f\u00fc")
>
> +
> buf.write("\16\u00fc\u0a76\13\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd")
>
> + buf.write("\5\u00fd\u0a7c\n\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd")
>
> + buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\7\u00fd\u0a87")
>
> +
> buf.write("\n\u00fd\f\u00fd\16\u00fd\u0a8a\13\u00fd\3\u00fd\3\u00fd")
>
> + buf.write("\3\u00fe\6\u00fe\u0a8f\n\u00fe\r\u00fe\16\u00fe\u0a90")
>
> + buf.write("\3\u00fe\3\u00fe\3\u00ff\3\u00ff\5\u00ff\u0a97\n\u00ff")
>
> + buf.write("\3\u00ff\5\u00ff\u0a9a\n\u00ff\3\u00ff\3\u00ff\3\u0100")
>
> +
> buf.write("\3\u0100\3\u0100\3\u0100\7\u0100\u0aa2\n\u0100\f\u0100")
>
> +
> buf.write("\16\u0100\u0aa5\13\u0100\3\u0100\3\u0100\3\u0101\3\u0101")
>
> +
> buf.write("\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\7\u0101")
>
> +
> buf.write("\u0ab1\n\u0101\f\u0101\16\u0101\u0ab4\13\u0101\3\u0101")
>
> + buf.write("\3\u0101\2\2\u0102\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n")
>
> + buf.write("\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'")
>
> + buf.write("\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ")
>
> + buf.write("?!A\"C#E$G%I&K\'M(O)Q*S+U,W-
> Y.[/]\60_\61a\62c\63e\64g")
>
> +
> buf.write("\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085")
>
> +
> buf.write("D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095"
> )
>
> +
> buf.write("L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a
> 5")
>
> +
> buf.write("T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5
> ")
>
> +
> buf.write("\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5")
>
> +
> buf.write("d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5")
>
> +
> buf.write("l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5
> ")
>
> +
> buf.write("t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1z\u00f3{\u00f5")
>
> +
> buf.write("|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff\u0081\u0101")
>
> +
> buf.write("\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086")
>
> +
> buf.write("\u010b\u0087\u010d\u0088\u010f\u0089\u0111\u008a\u0113")
>
> +
> buf.write("\u008b\u0115\u008c\u0117\u008d\u0119\u008e\u011b\u008f")
>
> +
> buf.write("\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125")
>
> +
> buf.write("\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098")
>
> +
> buf.write("\u012f\u0099\u0131\u009a\u0133\u009b\u0135\u009c\u0137")
>
> +
> buf.write("\u009d\u0139\u009e\u013b\u009f\u013d\u00a0\u013f\u00a1")
>
> +
> buf.write("\u0141\u00a2\u0143\u00a3\u0145\u00a4\u0147\u00a5\u0149")
>
> +
> buf.write("\u00a6\u014b\u00a7\u014d\u00a8\u014f\u00a9\u0151\u00aa")
>
> +
> buf.write("\u0153\u00ab\u0155\u00ac\u0157\u00ad\u0159\u00ae\u015b")
>
> +
> buf.write("\u00af\u015d\u00b0\u015f\u00b1\u0161\u00b2\u0163\u00b3")
>
> +
> buf.write("\u0165\u00b4\u0167\u00b5\u0169\u00b6\u016b\u00b7\u016d")
>
> +
> buf.write("\u00b8\u016f\u00b9\u0171\u00ba\u0173\u00bb\u0175\u00bc")
>
> +
> buf.write("\u0177\u00bd\u0179\u00be\u017b\u00bf\u017d\u00c0\u017f")
>
> +
> buf.write("\u00c1\u0181\u00c2\u0183\u00c3\u0185\u00c4\u0187\u00c5")
>
> +
> buf.write("\u0189\u00c6\u018b\u00c7\u018d\u00c8\u018f\u00c9\u0191")
>
> +
> buf.write("\u00ca\u0193\u00cb\u0195\u00cc\u0197\u00cd\u0199\u00ce")
>
> +
> buf.write("\u019b\u00cf\u019d\u00d0\u019f\u00d1\u01a1\u00d2\u01a3")
>
> +
> buf.write("\u00d3\u01a5\u00d4\u01a7\u00d5\u01a9\u00d6\u01ab\u00d7")
>
> +
> buf.write("\u01ad\u00d8\u01af\u00d9\u01b1\u00da\u01b3\u00db\u01b5")
>
> +
> buf.write("\u00dc\u01b7\u00dd\u01b9\u00de\u01bb\u00df\u01bd\u00e0")
>
> +
> buf.write("\u01bf\u00e1\u01c1\u00e2\u01c3\u00e3\u01c5\u00e4\u01c7")
>
> +
> buf.write("\u00e5\u01c9\u00e6\u01cb\u00e7\u01cd\u00e8\u01cf\u00e9")
>
> +
> buf.write("\u01d1\u00ea\u01d3\u00eb\u01d5\u00ec\u01d7\u00ed\u01d9")
>
> +
> buf.write("\u00ee\u01db\u00ef\u01dd\u00f0\u01df\u00f1\u01e1\u00f2")
>
> +
> buf.write("\u01e3\u00f3\u01e5\u00f4\u01e7\u00f5\u01e9\u00f6\u01eb")
>
> +
> buf.write("\u00f7\u01ed\u00f8\u01ef\u00f9\u01f1\u00fa\u01f3\u00fb")
>
> + buf.write("\u01f5\u00fc\u01f7\u00fd\u01f9\u00fe\u01fb\u00ff\u01fd")
>
> +
> buf.write("\u0100\u01ff\u0101\u0201\u0102\3\2\t\5\2\62;CHch\3\2\62")
>
> + buf.write(";\5\2C\\aac|\6\2\62;C\\aac|\5\2\f\f\17\17%%\4\2\13\13")
>
> + buf.write("\"\"\4\2\f\f\17\17\2\u0ac5\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
>
> + buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
>
> + buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
>
> + buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
>
> + buf.write("\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2")
>
> + buf.write("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
>
> + buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
>
> + buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2")
>
> + buf.write("\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3")
>
> + buf.write("\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y")
>
> + buf.write("\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2")
>
> + buf.write("c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2")
>
> + buf.write("\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2")
>
> + buf.write("\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3")
>
> + buf.write("\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2")
>
> +
> buf.write("\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d")
>
> + buf.write("\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2")
>
> +
> buf.write("\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b")
>
> + buf.write("\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2")
>
> +
> buf.write("\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9")
>
> + buf.write("\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2")
>
> +
> buf.write("\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7")
>
> + buf.write("\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2")
>
> +
> buf.write("\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5")
>
> + buf.write("\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2")
>
> +
> buf.write("\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3")
>
> + buf.write("\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2")
>
> +
> buf.write("\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1")
>
> + buf.write("\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2")
>
> +
> buf.write("\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef")
>
> + buf.write("\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2")
>
> +
> buf.write("\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd")
>
> + buf.write("\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2")
>
> +
> buf.write("\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b")
>
> + buf.write("\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2")
>
> +
> buf.write("\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119")
>
> + buf.write("\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2")
>
> +
> buf.write("\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u0127")
>
> + buf.write("\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2")
>
> +
> buf.write("\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\2\u0135")
>
> + buf.write("\3\2\2\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2")
>
> +
> buf.write("\2\2\u013d\3\2\2\2\2\u013f\3\2\2\2\2\u0141\3\2\2\2\2\u0143")
>
> + buf.write("\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2")
>
> +
> buf.write("\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151")
>
> + buf.write("\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2")
>
> +
> buf.write("\2\2\u0159\3\2\2\2\2\u015b\3\2\2\2\2\u015d\3\2\2\2\2\u015f")
>
> + buf.write("\3\2\2\2\2\u0161\3\2\2\2\2\u0163\3\2\2\2\2\u0165\3\2\2")
>
> +
> buf.write("\2\2\u0167\3\2\2\2\2\u0169\3\2\2\2\2\u016b\3\2\2\2\2\u016d")
>
> + buf.write("\3\2\2\2\2\u016f\3\2\2\2\2\u0171\3\2\2\2\2\u0173\3\2\2")
>
> +
> buf.write("\2\2\u0175\3\2\2\2\2\u0177\3\2\2\2\2\u0179\3\2\2\2\2\u017b")
>
> + buf.write("\3\2\2\2\2\u017d\3\2\2\2\2\u017f\3\2\2\2\2\u0181\3\2\2")
>
> +
> buf.write("\2\2\u0183\3\2\2\2\2\u0185\3\2\2\2\2\u0187\3\2\2\2\2\u0189")
>
> + buf.write("\3\2\2\2\2\u018b\3\2\2\2\2\u018d\3\2\2\2\2\u018f\3\2\2")
>
> +
> buf.write("\2\2\u0191\3\2\2\2\2\u0193\3\2\2\2\2\u0195\3\2\2\2\2\u0197")
>
> + buf.write("\3\2\2\2\2\u0199\3\2\2\2\2\u019b\3\2\2\2\2\u019d\3\2\2")
>
> +
> buf.write("\2\2\u019f\3\2\2\2\2\u01a1\3\2\2\2\2\u01a3\3\2\2\2\2\u01a5")
>
> + buf.write("\3\2\2\2\2\u01a7\3\2\2\2\2\u01a9\3\2\2\2\2\u01ab\3\2\2")
>
> +
> buf.write("\2\2\u01ad\3\2\2\2\2\u01af\3\2\2\2\2\u01b1\3\2\2\2\2\u01b3")
>
> + buf.write("\3\2\2\2\2\u01b5\3\2\2\2\2\u01b7\3\2\2\2\2\u01b9\3\2\2")
>
> +
> buf.write("\2\2\u01bb\3\2\2\2\2\u01bd\3\2\2\2\2\u01bf\3\2\2\2\2\u01c1")
>
> + buf.write("\3\2\2\2\2\u01c3\3\2\2\2\2\u01c5\3\2\2\2\2\u01c7\3\2\2")
>
> +
> buf.write("\2\2\u01c9\3\2\2\2\2\u01cb\3\2\2\2\2\u01cd\3\2\2\2\2\u01cf")
>
> + buf.write("\3\2\2\2\2\u01d1\3\2\2\2\2\u01d3\3\2\2\2\2\u01d5\3\2\2")
>
> +
> buf.write("\2\2\u01d7\3\2\2\2\2\u01d9\3\2\2\2\2\u01db\3\2\2\2\2\u01dd")
>
> + buf.write("\3\2\2\2\2\u01df\3\2\2\2\2\u01e1\3\2\2\2\2\u01e3\3\2\2")
>
> +
> buf.write("\2\2\u01e5\3\2\2\2\2\u01e7\3\2\2\2\2\u01e9\3\2\2\2\2\u01eb")
>
> + buf.write("\3\2\2\2\2\u01ed\3\2\2\2\2\u01ef\3\2\2\2\2\u01f1\3\2\2")
>
> +
> buf.write("\2\2\u01f3\3\2\2\2\2\u01f5\3\2\2\2\2\u01f7\3\2\2\2\2\u01f9")
>
> + buf.write("\3\2\2\2\2\u01fb\3\2\2\2\2\u01fd\3\2\2\2\2\u01ff\3\2\2")
>
> +
> buf.write("\2\2\u0201\3\2\2\2\3\u0203\3\2\2\2\5\u0208\3\2\2\2\7\u020d")
>
> + buf.write("\3\2\2\2\t\u0211\3\2\2\2\13\u0219\3\2\2\2\r\u021e\3\2")
>
> + buf.write("\2\2\17\u0220\3\2\2\2\21\u022c\3\2\2\2\23\u0237\3\2\2")
>
> + buf.write("\2\25\u0242\3\2\2\2\27\u0245\3\2\2\2\31\u0248\3\2\2\2")
>
> +
> buf.write("\33\u024a\3\2\2\2\35\u024c\3\2\2\2\37\u024e\3\2\2\2!\u0255")
>
> + buf.write("\3\2\2\2#\u0257\3\2\2\2%\u025f\3\2\2\2\'\u0268\3\2\2\2")
>
> + buf.write(")\u0274\3\2\2\2+\u0276\3\2\2\2-\u0278\3\2\2\2/\u027a\3")
>
> + buf.write("\2\2\2\61\u027c\3\2\2\2\63\u027e\3\2\2\2\65\u0280\3\2")
>
> +
> buf.write("\2\2\67\u0282\3\2\2\29\u0284\3\2\2\2;\u0286\3\2\2\2=\u0288")
>
> + buf.write("\3\2\2\2?\u028a\3\2\2\2A\u028c\3\2\2\2C\u028f\3\2\2\2")
>
> +
> buf.write("E\u0292\3\2\2\2G\u0295\3\2\2\2I\u0297\3\2\2\2K\u029a\3")
>
> +
> buf.write("\2\2\2M\u029c\3\2\2\2O\u029e\3\2\2\2Q\u02a0\3\2\2\2S\u02ab"
> )
>
> +
> buf.write("\3\2\2\2U\u02b3\3\2\2\2W\u02bd\3\2\2\2Y\u02c8\3\2\2\2")
>
> + buf.write("[\u02ce\3\2\2\2]\u02d5\3\2\2\2_\u02db\3\2\2\2a\u02e4\3")
>
> +
> buf.write("\2\2\2c\u02eb\3\2\2\2e\u02f7\3\2\2\2g\u0305\3\2\2\2i\u030d")
>
> + buf.write("\3\2\2\2k\u0315\3\2\2\2m\u031a\3\2\2\2o\u0322\3\2\2\2")
>
> +
> buf.write("q\u032b\3\2\2\2s\u0333\3\2\2\2u\u033c\3\2\2\2w\u0348\3")
>
> +
> buf.write("\2\2\2y\u034d\3\2\2\2{\u0352\3\2\2\2}\u0359\3\2\2\2\177")
>
> +
> buf.write("\u035f\3\2\2\2\u0081\u0364\3\2\2\2\u0083\u036c\3\2\2\2")
>
> +
> buf.write("\u0085\u0371\3\2\2\2\u0087\u0377\3\2\2\2\u0089\u037b\3")
>
> +
> buf.write("\2\2\2\u008b\u0380\3\2\2\2\u008d\u0388\3\2\2\2\u008f\u038d")
>
> +
> buf.write("\3\2\2\2\u0091\u0394\3\2\2\2\u0093\u039b\3\2\2\2\u0095")
>
> +
> buf.write("\u03a5\3\2\2\2\u0097\u03ab\3\2\2\2\u0099\u03b3\3\2\2\2")
>
> +
> buf.write("\u009b\u03bd\3\2\2\2\u009d\u03ce\3\2\2\2\u009f\u03d5\3")
>
> +
> buf.write("\2\2\2\u00a1\u03db\3\2\2\2\u00a3\u03e3\3\2\2\2\u00a5\u03ea"
> )
>
> + buf.write("\3\2\2\2\u00a7\u03f1\3\2\2\2\u00a9\u03f8\3\2\2\2\u00ab")
>
> + buf.write("\u03fe\3\2\2\2\u00ad\u040c\3\2\2\2\u00af\u0419\3\2\2\2")
>
> +
> buf.write("\u00b1\u0426\3\2\2\2\u00b3\u0432\3\2\2\2\u00b5\u0437\3")
>
> +
> buf.write("\2\2\2\u00b7\u0440\3\2\2\2\u00b9\u044c\3\2\2\2\u00bb\u0454"
> )
>
> + buf.write("\3\2\2\2\u00bd\u045f\3\2\2\2\u00bf\u0467\3\2\2\2\u00c1")
>
> + buf.write("\u046f\3\2\2\2\u00c3\u0474\3\2\2\2\u00c5\u047c\3\2\2\2")
>
> +
> buf.write("\u00c7\u0485\3\2\2\2\u00c9\u0491\3\2\2\2\u00cb\u0498\3")
>
> +
> buf.write("\2\2\2\u00cd\u04a2\3\2\2\2\u00cf\u04aa\3\2\2\2\u00d1\u04b2")
>
> +
> buf.write("\3\2\2\2\u00d3\u04bb\3\2\2\2\u00d5\u04c6\3\2\2\2\u00d7")
>
> +
> buf.write("\u04d0\3\2\2\2\u00d9\u04d7\3\2\2\2\u00db\u04dc\3\2\2\2")
>
> +
> buf.write("\u00dd\u04e8\3\2\2\2\u00df\u04f7\3\2\2\2\u00e1\u0501\3")
>
> +
> buf.write("\2\2\2\u00e3\u050c\3\2\2\2\u00e5\u0512\3\2\2\2\u00e7\u0516")
>
> +
> buf.write("\3\2\2\2\u00e9\u051e\3\2\2\2\u00eb\u052c\3\2\2\2\u00ed")
>
> + buf.write("\u053d\3\2\2\2\u00ef\u0552\3\2\2\2\u00f1\u055e\3\2\2\2")
>
> +
> buf.write("\u00f3\u0568\3\2\2\2\u00f5\u0577\3\2\2\2\u00f7\u058a\3")
>
> +
> buf.write("\2\2\2\u00f9\u0595\3\2\2\2\u00fb\u059f\3\2\2\2\u00fd\u05ac")
>
> +
> buf.write("\3\2\2\2\u00ff\u05b7\3\2\2\2\u0101\u05bd\3\2\2\2\u0103")
>
> +
> buf.write("\u05c6\3\2\2\2\u0105\u05d0\3\2\2\2\u0107\u05d8\3\2\2\2")
>
> +
> buf.write("\u0109\u05e0\3\2\2\2\u010b\u05e5\3\2\2\2\u010d\u05ee\3")
>
> +
> buf.write("\2\2\2\u010f\u05f5\3\2\2\2\u0111\u05fb\3\2\2\2\u0113\u0600")
>
> +
> buf.write("\3\2\2\2\u0115\u0606\3\2\2\2\u0117\u060d\3\2\2\2\u0119")
>
> +
> buf.write("\u0612\3\2\2\2\u011b\u0617\3\2\2\2\u011d\u061d\3\2\2\2")
>
> +
> buf.write("\u011f\u0626\3\2\2\2\u0121\u0631\3\2\2\2\u0123\u0637\3")
>
> +
> buf.write("\2\2\2\u0125\u063e\3\2\2\2\u0127\u0643\3\2\2\2\u0129\u064b"
> )
>
> +
> buf.write("\3\2\2\2\u012b\u0651\3\2\2\2\u012d\u0656\3\2\2\2\u012f")
>
> +
> buf.write("\u065c\3\2\2\2\u0131\u0668\3\2\2\2\u0133\u0677\3\2\2\2")
>
> +
> buf.write("\u0135\u0684\3\2\2\2\u0137\u068e\3\2\2\2\u0139\u0697\3")
>
> +
> buf.write("\2\2\2\u013b\u06a3\3\2\2\2\u013d\u06ab\3\2\2\2\u013f\u06bd"
> )
>
> +
> buf.write("\3\2\2\2\u0141\u06c4\3\2\2\2\u0143\u06cb\3\2\2\2\u0145")
>
> +
> buf.write("\u06d5\3\2\2\2\u0147\u06dd\3\2\2\2\u0149\u06e6\3\2\2\2")
>
> +
> buf.write("\u014b\u06f5\3\2\2\2\u014d\u06fc\3\2\2\2\u014f\u0706\3")
>
> +
> buf.write("\2\2\2\u0151\u070f\3\2\2\2\u0153\u0714\3\2\2\2\u0155\u071a")
>
> +
> buf.write("\3\2\2\2\u0157\u0725\3\2\2\2\u0159\u0731\3\2\2\2\u015b")
>
> +
> buf.write("\u073e\3\2\2\2\u015d\u074d\3\2\2\2\u015f\u075a\3\2\2\2")
>
> +
> buf.write("\u0161\u0769\3\2\2\2\u0163\u0776\3\2\2\2\u0165\u0788\3")
>
> +
> buf.write("\2\2\2\u0167\u079c\3\2\2\2\u0169\u07a7\3\2\2\2\u016b\u07b2"
> )
>
> + buf.write("\3\2\2\2\u016d\u07c0\3\2\2\2\u016f\u07cf\3\2\2\2\u0171")
>
> +
> buf.write("\u07dc\3\2\2\2\u0173\u07ea\3\2\2\2\u0175\u07fa\3\2\2\2")
>
> +
> buf.write("\u0177\u080a\3\2\2\2\u0179\u0819\3\2\2\2\u017b\u0826\3")
>
> +
> buf.write("\2\2\2\u017d\u0835\3\2\2\2\u017f\u083c\3\2\2\2\u0181\u0844")
>
> +
> buf.write("\3\2\2\2\u0183\u0849\3\2\2\2\u0185\u084e\3\2\2\2\u0187")
>
> +
> buf.write("\u0852\3\2\2\2\u0189\u0858\3\2\2\2\u018b\u085d\3\2\2\2")
>
> +
> buf.write("\u018d\u0861\3\2\2\2\u018f\u086a\3\2\2\2\u0191\u086e\3")
>
> +
> buf.write("\2\2\2\u0193\u0876\3\2\2\2\u0195\u087d\3\2\2\2\u0197\u0889"
> )
>
> +
> buf.write("\3\2\2\2\u0199\u0895\3\2\2\2\u019b\u089d\3\2\2\2\u019d")
>
> +
> buf.write("\u08a7\3\2\2\2\u019f\u08b0\3\2\2\2\u01a1\u08b9\3\2\2\2")
>
> +
> buf.write("\u01a3\u08bd\3\2\2\2\u01a5\u08c2\3\2\2\2\u01a7\u08c8\3")
>
> +
> buf.write("\2\2\2\u01a9\u08cc\3\2\2\2\u01ab\u08d1\3\2\2\2\u01ad\u08d6"
> )
>
> +
> buf.write("\3\2\2\2\u01af\u08e0\3\2\2\2\u01b1\u08e8\3\2\2\2\u01b3")
>
> + buf.write("\u08ef\3\2\2\2\u01b5\u08f3\3\2\2\2\u01b7\u08f6\3\2\2\2")
>
> +
> buf.write("\u01b9\u08fa\3\2\2\2\u01bb\u08fe\3\2\2\2\u01bd\u0900\3")
>
> +
> buf.write("\2\2\2\u01bf\u0908\3\2\2\2\u01c1\u0912\3\2\2\2\u01c3\u091b")
>
> +
> buf.write("\3\2\2\2\u01c5\u0923\3\2\2\2\u01c7\u092b\3\2\2\2\u01c9")
>
> +
> buf.write("\u0931\3\2\2\2\u01cb\u0938\3\2\2\2\u01cd\u0941\3\2\2\2")
>
> +
> buf.write("\u01cf\u0950\3\2\2\2\u01d1\u095d\3\2\2\2\u01d3\u0961\3")
>
> +
> buf.write("\2\2\2\u01d5\u096d\3\2\2\2\u01d7\u097a\3\2\2\2\u01d9\u0989"
> )
>
> +
> buf.write("\3\2\2\2\u01db\u099c\3\2\2\2\u01dd\u09ab\3\2\2\2\u01df")
>
> +
> buf.write("\u09ba\3\2\2\2\u01e1\u09c9\3\2\2\2\u01e3\u09d8\3\2\2\2")
>
> +
> buf.write("\u01e5\u09e8\3\2\2\2\u01e7\u09f9\3\2\2\2\u01e9\u0a0a\3")
>
> +
> buf.write("\2\2\2\u01eb\u0a16\3\2\2\2\u01ed\u0a20\3\2\2\2\u01ef\u0a2f")
>
> + buf.write("\3\2\2\2\u01f1\u0a4c\3\2\2\2\u01f3\u0a4e\3\2\2\2\u01f5")
>
> + buf.write("\u0a55\3\2\2\2\u01f7\u0a68\3\2\2\2\u01f9\u0a79\3\2\2\2")
>
> + buf.write("\u01fb\u0a8e\3\2\2\2\u01fd\u0a99\3\2\2\2\u01ff\u0a9d\3")
>
> +
> buf.write("\2\2\2\u0201\u0aa8\3\2\2\2\u0203\u0204\7u\2\2\u0204\u0205")
>
> + buf.write("\7j\2\2\u0205\u0206\7q\2\2\u0206\u0207\7y\2\2\u0207\4")
>
> +
> buf.write("\3\2\2\2\u0208\u0209\7r\2\2\u0209\u020a\7w\2\2\u020a\u020b"
> )
>
> +
> buf.write("\7u\2\2\u020b\u020c\7j\2\2\u020c\6\3\2\2\2\u020d\u020e")
>
> + buf.write("\7r\2\2\u020e\u020f\7q\2\2\u020f\u0210\7r\2\2\u0210\b")
>
> +
> buf.write("\3\2\2\2\u0211\u0212\7%\2\2\u0212\u0213\7r\2\2\u0213\u0214"
> )
>
> +
> buf.write("\7t\2\2\u0214\u0215\7c\2\2\u0215\u0216\7i\2\2\u0216\u0217")
>
> +
> buf.write("\7o\2\2\u0217\u0218\7c\2\2\u0218\n\3\2\2\2\u0219\u021a")
>
> +
> buf.write("\7r\2\2\u021a\u021b\7c\2\2\u021b\u021c\7e\2\2\u021c\u021d")
>
> + buf.write("\7m\2\2\u021d\f\3\2\2\2\u021e\u021f\7?\2\2\u021f\16\3")
>
> +
> buf.write("\2\2\2\u0220\u0221\7K\2\2\u0221\u0222\7O\2\2\u0222\u0223")
>
> +
> buf.write("\7C\2\2\u0223\u0224\7I\2\2\u0224\u0225\7G\2\2\u0225\u0226")
>
> +
> buf.write("\7a\2\2\u0226\u0227\7V\2\2\u0227\u0228\7Q\2\2\u0228\u0229"
> )
>
> +
> buf.write("\7M\2\2\u0229\u022a\7G\2\2\u022a\u022b\7P\2\2\u022b\20")
>
> +
> buf.write("\3\2\2\2\u022c\u022d\7J\2\2\u022d\u022e\7Q\2\2\u022e\u022f")
>
> +
> buf.write("\7T\2\2\u022f\u0230\7K\2\2\u0230\u0231\7\\\2\2\u0231\u0232")
>
> +
> buf.write("\7Q\2\2\u0232\u0233\7P\2\2\u0233\u0234\7V\2\2\u0234\u0235"
> )
>
> +
> buf.write("\7C\2\2\u0235\u0236\7N\2\2\u0236\22\3\2\2\2\u0237\u0238")
>
> +
> buf.write("\7O\2\2\u0238\u0239\7W\2\2\u0239\u023a\7N\2\2\u023a\u023b
> ")
>
> +
> buf.write("\7V\2\2\u023b\u023c\7K\2\2\u023c\u023d\7a\2\2\u023d\u023e")
>
> +
> buf.write("\7N\2\2\u023e\u023f\7K\2\2\u023f\u0240\7P\2\2\u0240\u0241")
>
> +
> buf.write("\7G\2\2\u0241\24\3\2\2\2\u0242\u0243\7>\2\2\u0243\u0244")
>
> +
> buf.write("\7>\2\2\u0244\26\3\2\2\2\u0245\u0246\7@\2\2\u0246\u0247")
>
> + buf.write("\7@\2\2\u0247\30\3\2\2\2\u0248\u0249\7-
> \2\2\u0249\32\3")
>
> +
> buf.write("\2\2\2\u024a\u024b\7,\2\2\u024b\34\3\2\2\2\u024c\u024d")
>
> +
> buf.write("\7\'\2\2\u024d\36\3\2\2\2\u024e\u024f\7h\2\2\u024f\u0250")
>
> +
> buf.write("\7q\2\2\u0250\u0251\7t\2\2\u0251\u0252\7o\2\2\u0252\u0253")
>
> + buf.write("\7c\2\2\u0253\u0254\7v\2\2\u0254 \3\2\2\2\u0255\u0256")
>
> +
> buf.write("\7A\2\2\u0256\"\3\2\2\2\u0257\u0258\7%\2\2\u0258\u0259")
>
> +
> buf.write("\7f\2\2\u0259\u025a\7g\2\2\u025a\u025b\7h\2\2\u025b\u025c")
>
> +
> buf.write("\7k\2\2\u025c\u025d\7p\2\2\u025d\u025e\7g\2\2\u025e$\3")
>
> +
> buf.write("\2\2\2\u025f\u0260\7%\2\2\u0260\u0261\7k\2\2\u0261\u0262")
>
> +
> buf.write("\7p\2\2\u0262\u0263\7e\2\2\u0263\u0264\7n\2\2\u0264\u0265")
>
> +
> buf.write("\7w\2\2\u0265\u0266\7f\2\2\u0266\u0267\7g\2\2\u0267&\3")
>
> +
> buf.write("\2\2\2\u0268\u0269\7h\2\2\u0269\u026a\7q\2\2\u026a\u026b")
>
> +
> buf.write("\7t\2\2\u026b\u026c\7o\2\2\u026c\u026d\7r\2\2\u026d\u026e")
>
> +
> buf.write("\7m\2\2\u026e\u026f\7i\2\2\u026f\u0270\7v\2\2\u0270\u0271")
>
> +
> buf.write("\7{\2\2\u0271\u0272\7r\2\2\u0272\u0273\7g\2\2\u0273(\3")
>
> +
> buf.write("\2\2\2\u0274\u0275\7}\2\2\u0275*\3\2\2\2\u0276\u0277\7")
>
> + buf.write("\177\2\2\u0277,\3\2\2\2\u0278\u0279\7*\2\2\u0279.\3\2")
>
> +
> buf.write("\2\2\u027a\u027b\7+\2\2\u027b\60\3\2\2\2\u027c\u027d\7")
>
> + buf.write("]\2\2\u027d\62\3\2\2\2\u027e\u027f\7_\2\2\u027f\64\3\2")
>
> +
> buf.write("\2\2\u0280\u0281\7\60\2\2\u0281\66\3\2\2\2\u0282\u0283")
>
> + buf.write("\7/\2\2\u02838\3\2\2\2\u0284\u0285\7<\2\2\u0285:\3\2\2")
>
> +
> buf.write("\2\u0286\u0287\7\61\2\2\u0287<\3\2\2\2\u0288\u0289\7=")
>
> +
> buf.write("\2\2\u0289>\3\2\2\2\u028a\u028b\7.\2\2\u028b@\3\2\2\2")
>
> +
> buf.write("\u028c\u028d\7?\2\2\u028d\u028e\7?\2\2\u028eB\3\2\2\2")
>
> + buf.write("\u028f\u0290\7#\2\2\u0290\u0291\7?\2\2\u0291D\3\2\2\2")
>
> + buf.write("\u0292\u0293\7>\2\2\u0293\u0294\7?\2\2\u0294F\3\2\2\2")
>
> +
> buf.write("\u0295\u0296\7>\2\2\u0296H\3\2\2\2\u0297\u0298\7@\2\2")
>
> +
> buf.write("\u0298\u0299\7?\2\2\u0299J\3\2\2\2\u029a\u029b\7@\2\2")
>
> +
> buf.write("\u029bL\3\2\2\2\u029c\u029d\7~\2\2\u029dN\3\2\2\2\u029e")
>
> + buf.write("\u029f\7(\2\2\u029fP\3\2\2\2\u02a0\u02a1\7f\2\2\u02a1")
>
> +
> buf.write("\u02a2\7g\2\2\u02a2\u02a3\7x\2\2\u02a3\u02a4\7k\2\2\u02a4")
>
> +
> buf.write("\u02a5\7e\2\2\u02a5\u02a6\7g\2\2\u02a6\u02a7\7r\2\2\u02a7")
>
> +
> buf.write("\u02a8\7c\2\2\u02a8\u02a9\7v\2\2\u02a9\u02aa\7j\2\2\u02aa")
>
> +
> buf.write("R\3\2\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7q\2\2\u02ad")
>
> +
> buf.write("\u02ae\7t\2\2\u02ae\u02af\7o\2\2\u02af\u02b0\7u\2\2\u02b0")
>
> +
> buf.write("\u02b1\7g\2\2\u02b1\u02b2\7v\2\2\u02b2T\3\2\2\2\u02b3")
>
> +
> buf.write("\u02b4\7h\2\2\u02b4\u02b5\7q\2\2\u02b5\u02b6\7t\2\2\u02b6")
>
> +
> buf.write("\u02b7\7o\2\2\u02b7\u02b8\7u\2\2\u02b8\u02b9\7g\2\2\u02b9"
> )
>
> +
> buf.write("\u02ba\7v\2\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7f\2\2\u02bc")
>
> + buf.write("V\3\2\2\2\u02bd\u02be\7g\2\2\u02be\u02bf\7p\2\2\u02bf")
>
> +
> buf.write("\u02c0\7f\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2\7q\2\2\u02c2")
>
> +
> buf.write("\u02c3\7t\2\2\u02c3\u02c4\7o\2\2\u02c4\u02c5\7u\2\2\u02c5")
>
> + buf.write("\u02c6\7g\2\2\u02c6\u02c7\7v\2\2\u02c7X\3\2\2\2\u02c8")
>
> +
> buf.write("\u02c9\7v\2\2\u02c9\u02ca\7k\2\2\u02ca\u02cb\7v\2\2\u02cb")
>
> + buf.write("\u02cc\7n\2\2\u02cc\u02cd\7g\2\2\u02cdZ\3\2\2\2\u02ce")
>
> +
> buf.write("\u02cf\7h\2\2\u02cf\u02d0\7q\2\2\u02d0\u02d1\7t\2\2\u02d1")
>
> +
> buf.write("\u02d2\7o\2\2\u02d2\u02d3\7k\2\2\u02d3\u02d4\7f\2\2\u02d4")
>
> +
> buf.write("\\\3\2\2\2\u02d5\u02d6\7q\2\2\u02d6\u02d7\7p\2\2\u02d7")
>
> +
> buf.write("\u02d8\7g\2\2\u02d8\u02d9\7q\2\2\u02d9\u02da\7h\2\2\u02da"
> )
>
> +
> buf.write("^\3\2\2\2\u02db\u02dc\7g\2\2\u02dc\u02dd\7p\2\2\u02dd")
>
> +
> buf.write("\u02de\7f\2\2\u02de\u02df\7q\2\2\u02df\u02e0\7p\2\2\u02e0")
>
> +
> buf.write("\u02e1\7g\2\2\u02e1\u02e2\7q\2\2\u02e2\u02e3\7h\2\2\u02e3")
>
> + buf.write("`\3\2\2\2\u02e4\u02e5\7r\2\2\u02e5\u02e6\7t\2\2\u02e6")
>
> +
> buf.write("\u02e7\7q\2\2\u02e7\u02e8\7o\2\2\u02e8\u02e9\7r\2\2\u02e9")
>
> + buf.write("\u02ea\7v\2\2\u02eab\3\2\2\2\u02eb\u02ec\7q\2\2\u02ec")
>
> +
> buf.write("\u02ed\7t\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef\7g\2\2\u02ef")
>
> +
> buf.write("\u02f0\7t\2\2\u02f0\u02f1\7g\2\2\u02f1\u02f2\7f\2\2\u02f2")
>
> +
> buf.write("\u02f3\7n\2\2\u02f3\u02f4\7k\2\2\u02f4\u02f5\7u\2\2\u02f5")
>
> + buf.write("\u02f6\7v\2\2\u02f6d\3\2\2\2\u02f7\u02f8\7o\2\2\u02f8")
>
> +
> buf.write("\u02f9\7c\2\2\u02f9\u02fa\7z\2\2\u02fa\u02fb\7e\2\2\u02fb")
>
> +
> buf.write("\u02fc\7q\2\2\u02fc\u02fd\7p\2\2\u02fd\u02fe\7v\2\2\u02fe")
>
> +
> buf.write("\u02ff\7c\2\2\u02ff\u0300\7k\2\2\u0300\u0301\7p\2\2\u0301")
>
> +
> buf.write("\u0302\7g\2\2\u0302\u0303\7t\2\2\u0303\u0304\7u\2\2\u0304")
>
> + buf.write("f\3\2\2\2\u0305\u0306\7g\2\2\u0306\u0307\7p\2\2\u0307")
>
> +
> buf.write("\u0308\7f\2\2\u0308\u0309\7n\2\2\u0309\u030a\7k\2\2\u030a")
>
> +
> buf.write("\u030b\7u\2\2\u030b\u030c\7v\2\2\u030ch\3\2\2\2\u030d")
>
> +
> buf.write("\u030e\7g\2\2\u030e\u030f\7p\2\2\u030f\u0310\7f\2\2\u0310")
>
> +
> buf.write("\u0311\7h\2\2\u0311\u0312\7q\2\2\u0312\u0313\7t\2\2\u0313")
>
> + buf.write("\u0314\7o\2\2\u0314j\3\2\2\2\u0315\u0316\7h\2\2\u0316")
>
> +
> buf.write("\u0317\7q\2\2\u0317\u0318\7t\2\2\u0318\u0319\7o\2\2\u0319")
>
> + buf.write("l\3\2\2\2\u031a\u031b\7h\2\2\u031b\u031c\7q\2\2\u031c")
>
> +
> buf.write("\u031d\7t\2\2\u031d\u031e\7o\2\2\u031e\u031f\7o\2\2\u031f")
>
> + buf.write("\u0320\7c\2\2\u0320\u0321\7r\2\2\u0321n\3\2\2\2\u0322")
>
> +
> buf.write("\u0323\7o\2\2\u0323\u0324\7c\2\2\u0324\u0325\7r\2\2\u0325")
>
> +
> buf.write("\u0326\7v\2\2\u0326\u0327\7k\2\2\u0327\u0328\7v\2\2\u0328")
>
> +
> buf.write("\u0329\7n\2\2\u0329\u032a\7g\2\2\u032ap\3\2\2\2\u032b")
>
> +
> buf.write("\u032c\7o\2\2\u032c\u032d\7c\2\2\u032d\u032e\7r\2\2\u032e")
>
> +
> buf.write("\u032f\7i\2\2\u032f\u0330\7w\2\2\u0330\u0331\7k\2\2\u0331")
>
> + buf.write("\u0332\7f\2\2\u0332r\3\2\2\2\u0333\u0334\7u\2\2\u0334")
>
> +
> buf.write("\u0335\7w\2\2\u0335\u0336\7d\2\2\u0336\u0337\7v\2\2\u0337"
> )
>
> +
> buf.write("\u0338\7k\2\2\u0338\u0339\7v\2\2\u0339\u033a\7n\2\2\u033a")
>
> + buf.write("\u033b\7g\2\2\u033bt\3\2\2\2\u033c\u033d\7g\2\2\u033d")
>
> +
> buf.write("\u033e\7p\2\2\u033e\u033f\7f\2\2\u033f\u0340\7u\2\2\u0340")
>
> +
> buf.write("\u0341\7w\2\2\u0341\u0342\7d\2\2\u0342\u0343\7v\2\2\u0343"
> )
>
> +
> buf.write("\u0344\7k\2\2\u0344\u0345\7v\2\2\u0345\u0346\7n\2\2\u0346")
>
> + buf.write("\u0347\7g\2\2\u0347v\3\2\2\2\u0348\u0349\7j\2\2\u0349")
>
> +
> buf.write("\u034a\7g\2\2\u034a\u034b\7n\2\2\u034b\u034c\7r\2\2\u034c")
>
> + buf.write("x\3\2\2\2\u034d\u034e\7v\2\2\u034e\u034f\7g\2\2\u034f")
>
> + buf.write("\u0350\7z\2\2\u0350\u0351\7v\2\2\u0351z\3\2\2\2\u0352")
>
> +
> buf.write("\u0353\7q\2\2\u0353\u0354\7r\2\2\u0354\u0355\7v\2\2\u0355")
>
> +
> buf.write("\u0356\7k\2\2\u0356\u0357\7q\2\2\u0357\u0358\7p\2\2\u0358")
>
> +
> buf.write("|\3\2\2\2\u0359\u035a\7h\2\2\u035a\u035b\7n\2\2\u035b")
>
> +
> buf.write("\u035c\7c\2\2\u035c\u035d\7i\2\2\u035d\u035e\7u\2\2\u035e")
>
> + buf.write("~\3\2\2\2\u035f\u0360\7f\2\2\u0360\u0361\7c\2\2\u0361")
>
> +
> buf.write("\u0362\7v\2\2\u0362\u0363\7g\2\2\u0363\u0080\3\2\2\2\u0364"
> )
>
> +
> buf.write("\u0365\7g\2\2\u0365\u0366\7p\2\2\u0366\u0367\7f\2\2\u0367")
>
> +
> buf.write("\u0368\7f\2\2\u0368\u0369\7c\2\2\u0369\u036a\7v\2\2\u036a")
>
> +
> buf.write("\u036b\7g\2\2\u036b\u0082\3\2\2\2\u036c\u036d\7{\2\2\u036d"
> )
>
> +
> buf.write("\u036e\7g\2\2\u036e\u036f\7c\2\2\u036f\u0370\7t\2\2\u0370")
>
> +
> buf.write("\u0084\3\2\2\2\u0371\u0372\7o\2\2\u0372\u0373\7q\2\2\u0373"
> )
>
> +
> buf.write("\u0374\7p\2\2\u0374\u0375\7v\2\2\u0375\u0376\7j\2\2\u0376")
>
> +
> buf.write("\u0086\3\2\2\2\u0377\u0378\7f\2\2\u0378\u0379\7c\2\2\u0379")
>
> +
> buf.write("\u037a\7{\2\2\u037a\u0088\3\2\2\2\u037b\u037c\7v\2\2\u037c")
>
> +
> buf.write("\u037d\7k\2\2\u037d\u037e\7o\2\2\u037e\u037f\7g\2\2\u037f")
>
> +
> buf.write("\u008a\3\2\2\2\u0380\u0381\7g\2\2\u0381\u0382\7p\2\2\u0382"
> )
>
> +
> buf.write("\u0383\7f\2\2\u0383\u0384\7v\2\2\u0384\u0385\7k\2\2\u0385")
>
> +
> buf.write("\u0386\7o\2\2\u0386\u0387\7g\2\2\u0387\u008c\3\2\2\2\u0388"
> )
>
> +
> buf.write("\u0389\7j\2\2\u0389\u038a\7q\2\2\u038a\u038b\7w\2\2\u038b")
>
> +
> buf.write("\u038c\7t\2\2\u038c\u008e\3\2\2\2\u038d\u038e\7o\2\2\u038e")
>
> +
> buf.write("\u038f\7k\2\2\u038f\u0390\7p\2\2\u0390\u0391\7w\2\2\u0391")
>
> +
> buf.write("\u0392\7v\2\2\u0392\u0393\7g\2\2\u0393\u0090\3\2\2\2\u0394"
> )
>
> +
> buf.write("\u0395\7u\2\2\u0395\u0396\7g\2\2\u0396\u0397\7e\2\2\u0397")
>
> +
> buf.write("\u0398\7q\2\2\u0398\u0399\7p\2\2\u0399\u039a\7f\2\2\u039a")
>
> +
> buf.write("\u0092\3\2\2\2\u039b\u039c\7i\2\2\u039c\u039d\7t\2\2\u039d")
>
> +
> buf.write("\u039e\7c\2\2\u039e\u039f\7{\2\2\u039f\u03a0\7q\2\2\u03a0")
>
> +
> buf.write("\u03a1\7w\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7k\2\2\u03a3")
>
> +
> buf.write("\u03a4\7h\2\2\u03a4\u0094\3\2\2\2\u03a5\u03a6\7n\2\2\u03a6"
> )
>
> +
> buf.write("\u03a7\7c\2\2\u03a7\u03a8\7d\2\2\u03a8\u03a9\7g\2\2\u03a9")
>
> +
> buf.write("\u03aa\7n\2\2\u03aa\u0096\3\2\2\2\u03ab\u03ac\7v\2\2\u03ac"
> )
>
> +
> buf.write("\u03ad\7k\2\2\u03ad\u03ae\7o\2\2\u03ae\u03af\7g\2\2\u03af")
>
> +
> buf.write("\u03b0\7q\2\2\u03b0\u03b1\7w\2\2\u03b1\u03b2\7v\2\2\u03b2"
> )
>
> +
> buf.write("\u0098\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7p\2\2\u03b5
> ")
>
> +
> buf.write("\u03b6\7x\2\2\u03b6\u03b7\7g\2\2\u03b7\u03b8\7p\2\2\u03b8"
> )
>
> +
> buf.write("\u03b9\7v\2\2\u03b9\u03ba\7q\2\2\u03ba\u03bb\7t\2\2\u03bb")
>
> +
> buf.write("\u03bc\7{\2\2\u03bc\u009a\3\2\2\2\u03bd\u03be\7a\2\2\u03be"
> )
>
> +
> buf.write("\u03bf\7P\2\2\u03bf\u03c0\7Q\2\2\u03c0\u03c1\7P\2\2\u03c1")
>
> +
> buf.write("\u03c2\7a\2\2\u03c2\u03c3\7P\2\2\u03c3\u03c4\7X\2\2\u03c4")
>
> +
> buf.write("\u03c5\7a\2\2\u03c5\u03c6\7F\2\2\u03c6\u03c7\7C\2\2\u03c7")
>
> +
> buf.write("\u03c8\7V\2\2\u03c8\u03c9\7C\2\2\u03c9\u03ca\7a\2\2\u03ca")
>
> +
> buf.write("\u03cb\7O\2\2\u03cb\u03cc\7C\2\2\u03cc\u03cd\7R\2\2\u03cd")
>
> +
> buf.write("\u009c\3\2\2\2\u03ce\u03cf\7u\2\2\u03cf\u03d0\7v\2\2\u03d0")
>
> +
> buf.write("\u03d1\7t\2\2\u03d1\u03d2\7w\2\2\u03d2\u03d3\7e\2\2\u03d3"
> )
>
> +
> buf.write("\u03d4\7v\2\2\u03d4\u009e\3\2\2\2\u03d5\u03d6\7w\2\2\u03d6
> ")
>
> +
> buf.write("\u03d7\7p\2\2\u03d7\u03d8\7k\2\2\u03d8\u03d9\7q\2\2\u03d9"
> )
>
> +
> buf.write("\u03da\7p\2\2\u03da\u00a0\3\2\2\2\u03db\u03dc\7D\2\2\u03dc
> ")
>
> +
> buf.write("\u03dd\7Q\2\2\u03dd\u03de\7Q\2\2\u03de\u03df\7N\2\2\u03df"
> )
>
> +
> buf.write("\u03e0\7G\2\2\u03e0\u03e1\7C\2\2\u03e1\u03e2\7P\2\2\u03e2")
>
> +
> buf.write("\u00a2\3\2\2\2\u03e3\u03e4\7W\2\2\u03e4\u03e5\7K\2\2\u03e5
> ")
>
> +
> buf.write("\u03e6\7P\2\2\u03e6\u03e7\7V\2\2\u03e7\u03e8\78\2\2\u03e8")
>
> +
> buf.write("\u03e9\7\66\2\2\u03e9\u00a4\3\2\2\2\u03ea\u03eb\7W\2\2")
>
> +
> buf.write("\u03eb\u03ec\7K\2\2\u03ec\u03ed\7P\2\2\u03ed\u03ee\7V")
>
> +
> buf.write("\2\2\u03ee\u03ef\7\65\2\2\u03ef\u03f0\7\64\2\2\u03f0\u00a6")
>
> +
> buf.write("\3\2\2\2\u03f1\u03f2\7W\2\2\u03f2\u03f3\7K\2\2\u03f3\u03f4")
>
> + buf.write("\7P\2\2\u03f4\u03f5\7V\2\2\u03f5\u03f6\7\63\2\2\u03f6")
>
> +
> buf.write("\u03f7\78\2\2\u03f7\u00a8\3\2\2\2\u03f8\u03f9\7W\2\2\u03f9")
>
> +
> buf.write("\u03fa\7K\2\2\u03fa\u03fb\7P\2\2\u03fb\u03fc\7V\2\2\u03fc")
>
> +
> buf.write("\u03fd\7:\2\2\u03fd\u00aa\3\2\2\2\u03fe\u03ff\7G\2\2\u03ff")
>
> +
> buf.write("\u0400\7H\2\2\u0400\u0401\7K\2\2\u0401\u0402\7a\2\2\u0402")
>
> +
> buf.write("\u0403\7U\2\2\u0403\u0404\7V\2\2\u0404\u0405\7T\2\2\u0405")
>
> +
> buf.write("\u0406\7K\2\2\u0406\u0407\7P\2\2\u0407\u0408\7I\2\2\u0408")
>
> +
> buf.write("\u0409\7a\2\2\u0409\u040a\7K\2\2\u040a\u040b\7F\2\2\u040b")
>
> +
> buf.write("\u00ac\3\2\2\2\u040c\u040d\7G\2\2\u040d\u040e\7H\2\2\u040e
> ")
>
> +
> buf.write("\u040f\7K\2\2\u040f\u0410\7a\2\2\u0410\u0411\7J\2\2\u0411")
>
> +
> buf.write("\u0412\7K\2\2\u0412\u0413\7K\2\2\u0413\u0414\7a\2\2\u0414")
>
> +
> buf.write("\u0415\7F\2\2\u0415\u0416\7C\2\2\u0416\u0417\7V\2\2\u0417")
>
> +
> buf.write("\u0418\7G\2\2\u0418\u00ae\3\2\2\2\u0419\u041a\7G\2\2\u041a
> ")
>
> +
> buf.write("\u041b\7H\2\2\u041b\u041c\7K\2\2\u041c\u041d\7a\2\2\u041d")
>
> +
> buf.write("\u041e\7J\2\2\u041e\u041f\7K\2\2\u041f\u0420\7K\2\2\u0420")
>
> +
> buf.write("\u0421\7a\2\2\u0421\u0422\7V\2\2\u0422\u0423\7K\2\2\u0423")
>
> +
> buf.write("\u0424\7O\2\2\u0424\u0425\7G\2\2\u0425\u00b0\3\2\2\2\u0426
> ")
>
> +
> buf.write("\u0427\7G\2\2\u0427\u0428\7H\2\2\u0428\u0429\7K\2\2\u0429"
> )
>
> +
> buf.write("\u042a\7a\2\2\u042a\u042b\7J\2\2\u042b\u042c\7K\2\2\u042c")
>
> +
> buf.write("\u042d\7K\2\2\u042d\u042e\7a\2\2\u042e\u042f\7T\2\2\u042f")
>
> +
> buf.write("\u0430\7G\2\2\u0430\u0431\7H\2\2\u0431\u00b2\3\2\2\2\u0432
> ")
>
> +
> buf.write("\u0433\7i\2\2\u0433\u0434\7w\2\2\u0434\u0435\7k\2\2\u0435")
>
> +
> buf.write("\u0436\7f\2\2\u0436\u00b4\3\2\2\2\u0437\u0438\7e\2\2\u0438"
> )
>
> +
> buf.write("\u0439\7j\2\2\u0439\u043a\7g\2\2\u043a\u043b\7e\2\2\u043b")
>
> +
> buf.write("\u043c\7m\2\2\u043c\u043d\7d\2\2\u043d\u043e\7q\2\2\u043e"
> )
>
> +
> buf.write("\u043f\7z\2\2\u043f\u00b6\3\2\2\2\u0440\u0441\7g\2\2\u0441")
>
> +
> buf.write("\u0442\7p\2\2\u0442\u0443\7f\2\2\u0443\u0444\7e\2\2\u0444")
>
> +
> buf.write("\u0445\7j\2\2\u0445\u0446\7g\2\2\u0446\u0447\7e\2\2\u0447")
>
> +
> buf.write("\u0448\7m\2\2\u0448\u0449\7d\2\2\u0449\u044a\7q\2\2\u044a"
> )
>
> +
> buf.write("\u044b\7z\2\2\u044b\u00b8\3\2\2\2\u044c\u044d\7p\2\2\u044d"
> )
>
> +
> buf.write("\u044e\7w\2\2\u044e\u044f\7o\2\2\u044f\u0450\7g\2\2\u0450")
>
> +
> buf.write("\u0451\7t\2\2\u0451\u0452\7k\2\2\u0452\u0453\7e\2\2\u0453")
>
> +
> buf.write("\u00ba\3\2\2\2\u0454\u0455\7g\2\2\u0455\u0456\7p\2\2\u0456"
> )
>
> +
> buf.write("\u0457\7f\2\2\u0457\u0458\7p\2\2\u0458\u0459\7w\2\2\u0459")
>
> +
> buf.write("\u045a\7o\2\2\u045a\u045b\7g\2\2\u045b\u045c\7t\2\2\u045c")
>
> +
> buf.write("\u045d\7k\2\2\u045d\u045e\7e\2\2\u045e\u00bc\3\2\2\2\u045f")
>
> +
> buf.write("\u0460\7o\2\2\u0460\u0461\7k\2\2\u0461\u0462\7p\2\2\u0462")
>
> +
> buf.write("\u0463\7k\2\2\u0463\u0464\7o\2\2\u0464\u0465\7w\2\2\u0465"
> )
>
> +
> buf.write("\u0466\7o\2\2\u0466\u00be\3\2\2\2\u0467\u0468\7o\2\2\u0468"
> )
>
> +
> buf.write("\u0469\7c\2\2\u0469\u046a\7z\2\2\u046a\u046b\7k\2\2\u046b")
>
> +
> buf.write("\u046c\7o\2\2\u046c\u046d\7w\2\2\u046d\u046e\7o\2\2\u046e"
> )
>
> +
> buf.write("\u00c0\3\2\2\2\u046f\u0470\7u\2\2\u0470\u0471\7v\2\2\u0471")
>
> +
> buf.write("\u0472\7g\2\2\u0472\u0473\7r\2\2\u0473\u00c2\3\2\2\2\u0474")
>
> +
> buf.write("\u0475\7f\2\2\u0475\u0476\7g\2\2\u0476\u0477\7h\2\2\u0477")
>
> +
> buf.write("\u0478\7c\2\2\u0478\u0479\7w\2\2\u0479\u047a\7n\2\2\u047a")
>
> +
> buf.write("\u047b\7v\2\2\u047b\u00c4\3\2\2\2\u047c\u047d\7r\2\2\u047d")
>
> +
> buf.write("\u047e\7c\2\2\u047e\u047f\7u\2\2\u047f\u0480\7u\2\2\u0480")
>
> +
> buf.write("\u0481\7y\2\2\u0481\u0482\7q\2\2\u0482\u0483\7t\2\2\u0483")
>
> +
> buf.write("\u0484\7f\2\2\u0484\u00c6\3\2\2\2\u0485\u0486\7g\2\2\u0486")
>
> +
> buf.write("\u0487\7p\2\2\u0487\u0488\7f\2\2\u0488\u0489\7r\2\2\u0489")
>
> +
> buf.write("\u048a\7c\2\2\u048a\u048b\7u\2\2\u048b\u048c\7u\2\2\u048c")
>
> +
> buf.write("\u048d\7y\2\2\u048d\u048e\7q\2\2\u048e\u048f\7t\2\2\u048f")
>
> +
> buf.write("\u0490\7f\2\2\u0490\u00c8\3\2\2\2\u0491\u0492\7u\2\2\u0492")
>
> +
> buf.write("\u0493\7v\2\2\u0493\u0494\7t\2\2\u0494\u0495\7k\2\2\u0495")
>
> +
> buf.write("\u0496\7p\2\2\u0496\u0497\7i\2\2\u0497\u00ca\3\2\2\2\u0498")
>
> +
> buf.write("\u0499\7g\2\2\u0499\u049a\7p\2\2\u049a\u049b\7f\2\2\u049b")
>
> +
> buf.write("\u049c\7u\2\2\u049c\u049d\7v\2\2\u049d\u049e\7t\2\2\u049e")
>
> +
> buf.write("\u049f\7k\2\2\u049f\u04a0\7p\2\2\u04a0\u04a1\7i\2\2\u04a1")
>
> +
> buf.write("\u00cc\3\2\2\2\u04a2\u04a3\7o\2\2\u04a3\u04a4\7k\2\2\u04a4")
>
> +
> buf.write("\u04a5\7p\2\2\u04a5\u04a6\7u\2\2\u04a6\u04a7\7k\2\2\u04a7")
>
> +
> buf.write("\u04a8\7|\2\2\u04a8\u04a9\7g\2\2\u04a9\u00ce\3\2\2\2\u04aa")
>
> +
> buf.write("\u04ab\7o\2\2\u04ab\u04ac\7c\2\2\u04ac\u04ad\7z\2\2\u04ad")
>
> +
> buf.write("\u04ae\7u\2\2\u04ae\u04af\7k\2\2\u04af\u04b0\7|\2\2\u04b0")
>
> +
> buf.write("\u04b1\7g\2\2\u04b1\u00d0\3\2\2\2\u04b2\u04b3\7g\2\2\u04b3
> ")
>
> +
> buf.write("\u04b4\7p\2\2\u04b4\u04b5\7e\2\2\u04b5\u04b6\7q\2\2\u04b6"
> )
>
> +
> buf.write("\u04b7\7f\2\2\u04b7\u04b8\7k\2\2\u04b8\u04b9\7p\2\2\u04b9")
>
> +
> buf.write("\u04ba\7i\2\2\u04ba\u00d2\3\2\2\2\u04bb\u04bc\7u\2\2\u04bc"
> )
>
> +
> buf.write("\u04bd\7w\2\2\u04bd\u04be\7r\2\2\u04be\u04bf\7r\2\2\u04bf")
>
> +
> buf.write("\u04c0\7t\2\2\u04c0\u04c1\7g\2\2\u04c1\u04c2\7u\2\2\u04c2")
>
> +
> buf.write("\u04c3\7u\2\2\u04c3\u04c4\7k\2\2\u04c4\u04c5\7h\2\2\u04c5")
>
> +
> buf.write("\u00d4\3\2\2\2\u04c6\u04c7\7f\2\2\u04c7\u04c8\7k\2\2\u04c8")
>
> +
> buf.write("\u04c9\7u\2\2\u04c9\u04ca\7c\2\2\u04ca\u04cb\7d\2\2\u04cb")
>
> +
> buf.write("\u04cc\7n\2\2\u04cc\u04cd\7g\2\2\u04cd\u04ce\7k\2\2\u04ce")
>
> +
> buf.write("\u04cf\7h\2\2\u04cf\u00d6\3\2\2\2\u04d0\u04d1\7j\2\2\u04d1")
>
> +
> buf.write("\u04d2\7k\2\2\u04d2\u04d3\7f\2\2\u04d3\u04d4\7f\2\2\u04d4")
>
> +
> buf.write("\u04d5\7g\2\2\u04d5\u04d6\7p\2\2\u04d6\u00d8\3\2\2\2\u04d7
> ")
>
> +
> buf.write("\u04d8\7i\2\2\u04d8\u04d9\7q\2\2\u04d9\u04da\7v\2\2\u04da")
>
> +
> buf.write("\u04db\7q\2\2\u04db\u00da\3\2\2\2\u04dc\u04dd\7h\2\2\u04dd
> ")
>
> +
> buf.write("\u04de\7q\2\2\u04de\u04df\7t\2\2\u04df\u04e0\7o\2\2\u04e0")
>
> +
> buf.write("\u04e1\7u\2\2\u04e1\u04e2\7g\2\2\u04e2\u04e3\7v\2\2\u04e3")
>
> +
> buf.write("\u04e4\7i\2\2\u04e4\u04e5\7w\2\2\u04e5\u04e6\7k\2\2\u04e6")
>
> +
> buf.write("\u04e7\7f\2\2\u04e7\u00dc\3\2\2\2\u04e8\u04e9\7k\2\2\u04e9")
>
> +
> buf.write("\u04ea\7p\2\2\u04ea\u04eb\7e\2\2\u04eb\u04ec\7q\2\2\u04ec")
>
> +
> buf.write("\u04ed\7p\2\2\u04ed\u04ee\7u\2\2\u04ee\u04ef\7k\2\2\u04ef")
>
> +
> buf.write("\u04f0\7u\2\2\u04f0\u04f1\7v\2\2\u04f1\u04f2\7g\2\2\u04f2")
>
> +
> buf.write("\u04f3\7p\2\2\u04f3\u04f4\7v\2\2\u04f4\u04f5\7k\2\2\u04f5")
>
> +
> buf.write("\u04f6\7h\2\2\u04f6\u00de\3\2\2\2\u04f7\u04f8\7y\2\2\u04f8")
>
> +
> buf.write("\u04f9\7c\2\2\u04f9\u04fa\7t\2\2\u04fa\u04fb\7p\2\2\u04fb")
>
> +
> buf.write("\u04fc\7k\2\2\u04fc\u04fd\7p\2\2\u04fd\u04fe\7i\2\2\u04fe")
>
> +
> buf.write("\u04ff\7k\2\2\u04ff\u0500\7h\2\2\u0500\u00e0\3\2\2\2\u0501")
>
> +
> buf.write("\u0502\7p\2\2\u0502\u0503\7q\2\2\u0503\u0504\7u\2\2\u0504")
>
> +
> buf.write("\u0505\7w\2\2\u0505\u0506\7d\2\2\u0506\u0507\7o\2\2\u0507"
> )
>
> +
> buf.write("\u0508\7k\2\2\u0508\u0509\7v\2\2\u0509\u050a\7k\2\2\u050a")
>
> +
> buf.write("\u050b\7h\2\2\u050b\u00e2\3\2\2\2\u050c\u050d\7g\2\2\u050d"
> )
>
> +
> buf.write("\u050e\7p\2\2\u050e\u050f\7f\2\2\u050f\u0510\7k\2\2\u0510")
>
> +
> buf.write("\u0511\7h\2\2\u0511\u00e4\3\2\2\2\u0512\u0513\7m\2\2\u0513
> ")
>
> +
> buf.write("\u0514\7g\2\2\u0514\u0515\7{\2\2\u0515\u00e6\3\2\2\2\u0516")
>
> +
> buf.write("\u0517\7F\2\2\u0517\u0518\7G\2\2\u0518\u0519\7H\2\2\u0519"
> )
>
> +
> buf.write("\u051a\7C\2\2\u051a\u051b\7W\2\2\u051b\u051c\7N\2\2\u051c"
> )
>
> +
> buf.write("\u051d\7V\2\2\u051d\u00e8\3\2\2\2\u051e\u051f\7O\2\2\u051f"
> )
>
> +
> buf.write("\u0520\7C\2\2\u0520\u0521\7P\2\2\u0521\u0522\7W\2\2\u0522"
> )
>
> +
> buf.write("\u0523\7H\2\2\u0523\u0524\7C\2\2\u0524\u0525\7E\2\2\u0525")
>
> +
> buf.write("\u0526\7V\2\2\u0526\u0527\7W\2\2\u0527\u0528\7T\2\2\u0528"
> )
>
> +
> buf.write("\u0529\7K\2\2\u0529\u052a\7P\2\2\u052a\u052b\7I\2\2\u052b")
>
> +
> buf.write("\u00ea\3\2\2\2\u052c\u052d\7E\2\2\u052d\u052e\7J\2\2\u052e")
>
> +
> buf.write("\u052f\7G\2\2\u052f\u0530\7E\2\2\u0530\u0531\7M\2\2\u0531")
>
> +
> buf.write("\u0532\7D\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7Z\2\2\u0534"
> )
>
> +
> buf.write("\u0535\7a\2\2\u0535\u0536\7F\2\2\u0536\u0537\7G\2\2\u0537")
>
> +
> buf.write("\u0538\7H\2\2\u0538\u0539\7C\2\2\u0539\u053a\7W\2\2\u053a
> ")
>
> +
> buf.write("\u053b\7N\2\2\u053b\u053c\7V\2\2\u053c\u00ec\3\2\2\2\u053d"
> )
>
> +
> buf.write("\u053e\7E\2\2\u053e\u053f\7J\2\2\u053f\u0540\7G\2\2\u0540")
>
> +
> buf.write("\u0541\7E\2\2\u0541\u0542\7M\2\2\u0542\u0543\7D\2\2\u0543"
> )
>
> +
> buf.write("\u0544\7Q\2\2\u0544\u0545\7Z\2\2\u0545\u0546\7a\2\2\u0546")
>
> +
> buf.write("\u0547\7F\2\2\u0547\u0548\7G\2\2\u0548\u0549\7H\2\2\u0549"
> )
>
> +
> buf.write("\u054a\7C\2\2\u054a\u054b\7W\2\2\u054b\u054c\7N\2\2\u054c"
> )
>
> +
> buf.write("\u054d\7V\2\2\u054d\u054e\7a\2\2\u054e\u054f\7O\2\2\u054f")
>
> +
> buf.write("\u0550\7H\2\2\u0550\u0551\7I\2\2\u0551\u00ee\3\2\2\2\u0552"
> )
>
> +
> buf.write("\u0553\7K\2\2\u0553\u0554\7P\2\2\u0554\u0555\7V\2\2\u0555")
>
> +
> buf.write("\u0556\7G\2\2\u0556\u0557\7T\2\2\u0557\u0558\7C\2\2\u0558")
>
> +
> buf.write("\u0559\7E\2\2\u0559\u055a\7V\2\2\u055a\u055b\7K\2\2\u055b")
>
> +
> buf.write("\u055c\7X\2\2\u055c\u055d\7G\2\2\u055d\u00f0\3\2\2\2\u055e"
> )
>
> +
> buf.write("\u055f\7P\2\2\u055f\u0560\7X\2\2\u0560\u0561\7a\2\2\u0561")
>
> +
> buf.write("\u0562\7C\2\2\u0562\u0563\7E\2\2\u0563\u0564\7E\2\2\u0564")
>
> +
> buf.write("\u0565\7G\2\2\u0565\u0566\7U\2\2\u0566\u0567\7U\2\2\u0567"
> )
>
> +
> buf.write("\u00f2\3\2\2\2\u0568\u0569\7T\2\2\u0569\u056a\7G\2\2\u056a"
> )
>
> +
> buf.write("\u056b\7U\2\2\u056b\u056c\7G\2\2\u056c\u056d\7V\2\2\u056d"
> )
>
> +
> buf.write("\u056e\7a\2\2\u056e\u056f\7T\2\2\u056f\u0570\7G\2\2\u0570")
>
> +
> buf.write("\u0571\7S\2\2\u0571\u0572\7W\2\2\u0572\u0573\7K\2\2\u0573"
> )
>
> +
> buf.write("\u0574\7T\2\2\u0574\u0575\7G\2\2\u0575\u0576\7F\2\2\u0576")
>
> +
> buf.write("\u00f4\3\2\2\2\u0577\u0578\7T\2\2\u0578\u0579\7G\2\2\u0579"
> )
>
> +
> buf.write("\u057a\7E\2\2\u057a\u057b\7Q\2\2\u057b\u057c\7P\2\2\u057c")
>
> +
> buf.write("\u057d\7P\2\2\u057d\u057e\7G\2\2\u057e\u057f\7E\2\2\u057f")
>
> +
> buf.write("\u0580\7V\2\2\u0580\u0581\7a\2\2\u0581\u0582\7T\2\2\u0582")
>
> +
> buf.write("\u0583\7G\2\2\u0583\u0584\7S\2\2\u0584\u0585\7W\2\2\u0585"
> )
>
> +
> buf.write("\u0586\7K\2\2\u0586\u0587\7T\2\2\u0587\u0588\7G\2\2\u0588")
>
> +
> buf.write("\u0589\7F\2\2\u0589\u00f6\3\2\2\2\u058a\u058b\7N\2\2\u058b"
> )
>
> +
> buf.write("\u058c\7C\2\2\u058c\u058d\7V\2\2\u058d\u058e\7G\2\2\u058e")
>
> +
> buf.write("\u058f\7a\2\2\u058f\u0590\7E\2\2\u0590\u0591\7J\2\2\u0591")
>
> +
> buf.write("\u0592\7G\2\2\u0592\u0593\7E\2\2\u0593\u0594\7M\2\2\u0594"
> )
>
> +
> buf.write("\u00f8\3\2\2\2\u0595\u0596\7T\2\2\u0596\u0597\7G\2\2\u0597"
> )
>
> +
> buf.write("\u0598\7C\2\2\u0598\u0599\7F\2\2\u0599\u059a\7a\2\2\u059a")
>
> +
> buf.write("\u059b\7Q\2\2\u059b\u059c\7P\2\2\u059c\u059d\7N\2\2\u059d"
> )
>
> +
> buf.write("\u059e\7[\2\2\u059e\u00fa\3\2\2\2\u059f\u05a0\7Q\2\2\u05a0")
>
> +
> buf.write("\u05a1\7R\2\2\u05a1\u05a2\7V\2\2\u05a2\u05a3\7K\2\2\u05a3")
>
> +
> buf.write("\u05a4\7Q\2\2\u05a4\u05a5\7P\2\2\u05a5\u05a6\7U\2\2\u05a6"
> )
>
> +
> buf.write("\u05a7\7a\2\2\u05a7\u05a8\7Q\2\2\u05a8\u05a9\7P\2\2\u05a9")
>
> +
> buf.write("\u05aa\7N\2\2\u05aa\u05ab\7[\2\2\u05ab\u00fc\3\2\2\2\u05ac")
>
> +
> buf.write("\u05ad\7T\2\2\u05ad\u05ae\7G\2\2\u05ae\u05af\7U\2\2\u05af")
>
> +
> buf.write("\u05b0\7V\2\2\u05b0\u05b1\7a\2\2\u05b1\u05b2\7U\2\2\u05b2"
> )
>
> +
> buf.write("\u05b3\7V\2\2\u05b3\u05b4\7[\2\2\u05b4\u05b5\7N\2\2\u05b5"
> )
>
> +
> buf.write("\u05b6\7G\2\2\u05b6\u00fe\3\2\2\2\u05b7\u05b8\7e\2\2\u05b8"
> )
>
> +
> buf.write("\u05b9\7n\2\2\u05b9\u05ba\7c\2\2\u05ba\u05bb\7u\2\2\u05bb"
> )
>
> +
> buf.write("\u05bc\7u\2\2\u05bc\u0100\3\2\2\2\u05bd\u05be\7u\2\2\u05be
> ")
>
> +
> buf.write("\u05bf\7w\2\2\u05bf\u05c0\7d\2\2\u05c0\u05c1\7e\2\2\u05c1")
>
> +
> buf.write("\u05c2\7n\2\2\u05c2\u05c3\7c\2\2\u05c3\u05c4\7u\2\2\u05c4")
>
> +
> buf.write("\u05c5\7u\2\2\u05c5\u0102\3\2\2\2\u05c6\u05c7\7e\2\2\u05c7")
>
> +
> buf.write("\u05c8\7n\2\2\u05c8\u05c9\7c\2\2\u05c9\u05ca\7u\2\2\u05ca")
>
> +
> buf.write("\u05cb\7u\2\2\u05cb\u05cc\7i\2\2\u05cc\u05cd\7w\2\2\u05cd")
>
> +
> buf.write("\u05ce\7k\2\2\u05ce\u05cf\7f\2\2\u05cf\u0104\3\2\2\2\u05d0")
>
> +
> buf.write("\u05d1\7v\2\2\u05d1\u05d2\7{\2\2\u05d2\u05d3\7r\2\2\u05d3")
>
> +
> buf.write("\u05d4\7g\2\2\u05d4\u05d5\7f\2\2\u05d5\u05d6\7g\2\2\u05d6")
>
> +
> buf.write("\u05d7\7h\2\2\u05d7\u0106\3\2\2\2\u05d8\u05d9\7t\2\2\u05d9"
> )
>
> +
> buf.write("\u05da\7g\2\2\u05da\u05db\7u\2\2\u05db\u05dc\7v\2\2\u05dc")
>
> +
> buf.write("\u05dd\7q\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7g\2\2\u05df")
>
> +
> buf.write("\u0108\3\2\2\2\u05e0\u05e1\7u\2\2\u05e1\u05e2\7c\2\2\u05e2"
> )
>
> +
> buf.write("\u05e3\7x\2\2\u05e3\u05e4\7g\2\2\u05e4\u010a\3\2\2\2\u05e5"
> )
>
> +
> buf.write("\u05e6\7f\2\2\u05e6\u05e7\7g\2\2\u05e7\u05e8\7h\2\2\u05e8")
>
> +
> buf.write("\u05e9\7c\2\2\u05e9\u05ea\7w\2\2\u05ea\u05eb\7n\2\2\u05eb"
> )
>
> +
> buf.write("\u05ec\7v\2\2\u05ec\u05ed\7u\2\2\u05ed\u010c\3\2\2\2\u05ee")
>
> +
> buf.write("\u05ef\7d\2\2\u05ef\u05f0\7c\2\2\u05f0\u05f1\7p\2\2\u05f1")
>
> +
> buf.write("\u05f2\7p\2\2\u05f2\u05f3\7g\2\2\u05f3\u05f4\7t\2\2\u05f4")
>
> +
> buf.write("\u010e\3\2\2\2\u05f5\u05f6\7c\2\2\u05f6\u05f7\7n\2\2\u05f7")
>
> +
> buf.write("\u05f8\7k\2\2\u05f8\u05f9\7i\2\2\u05f9\u05fa\7p\2\2\u05fa")
>
> +
> buf.write("\u0110\3\2\2\2\u05fb\u05fc\7n\2\2\u05fc\u05fd\7g\2\2\u05fd")
>
> +
> buf.write("\u05fe\7h\2\2\u05fe\u05ff\7v\2\2\u05ff\u0112\3\2\2\2\u0600")
>
> +
> buf.write("\u0601\7t\2\2\u0601\u0602\7k\2\2\u0602\u0603\7i\2\2\u0603")
>
> +
> buf.write("\u0604\7j\2\2\u0604\u0605\7v\2\2\u0605\u0114\3\2\2\2\u0606")
>
> +
> buf.write("\u0607\7e\2\2\u0607\u0608\7g\2\2\u0608\u0609\7p\2\2\u0609")
>
> +
> buf.write("\u060a\7v\2\2\u060a\u060b\7g\2\2\u060b\u060c\7t\2\2\u060c")
>
> +
> buf.write("\u0116\3\2\2\2\u060d\u060e\7n\2\2\u060e\u060f\7k\2\2\u060f")
>
> +
> buf.write("\u0610\7p\2\2\u0610\u0611\7g\2\2\u0611\u0118\3\2\2\2\u0612"
> )
>
> +
> buf.write("\u0613\7p\2\2\u0613\u0614\7c\2\2\u0614\u0615\7o\2\2\u0615")
>
> +
> buf.write("\u0616\7g\2\2\u0616\u011a\3\2\2\2\u0617\u0618\7x\2\2\u0618"
> )
>
> +
> buf.write("\u0619\7c\2\2\u0619\u061a\7t\2\2\u061a\u061b\7k\2\2\u061b")
>
> +
> buf.write("\u061c\7f\2\2\u061c\u011c\3\2\2\2\u061d\u061e\7s\2\2\u061e")
>
> +
> buf.write("\u061f\7w\2\2\u061f\u0620\7g\2\2\u0620\u0621\7u\2\2\u0621")
>
> +
> buf.write("\u0622\7v\2\2\u0622\u0623\7k\2\2\u0623\u0624\7q\2\2\u0624")
>
> +
> buf.write("\u0625\7p\2\2\u0625\u011e\3\2\2\2\u0626\u0627\7s\2\2\u0627"
> )
>
> +
> buf.write("\u0628\7w\2\2\u0628\u0629\7g\2\2\u0629\u062a\7u\2\2\u062a"
> )
>
> +
> buf.write("\u062b\7v\2\2\u062b\u062c\7k\2\2\u062c\u062d\7q\2\2\u062d")
>
> +
> buf.write("\u062e\7p\2\2\u062e\u062f\7k\2\2\u062f\u0630\7f\2\2\u0630")
>
> +
> buf.write("\u0120\3\2\2\2\u0631\u0632\7k\2\2\u0632\u0633\7o\2\2\u0633"
> )
>
> +
> buf.write("\u0634\7c\2\2\u0634\u0635\7i\2\2\u0635\u0636\7g\2\2\u0636")
>
> +
> buf.write("\u0122\3\2\2\2\u0637\u0638\7n\2\2\u0638\u0639\7q\2\2\u0639"
> )
>
> +
> buf.write("\u063a\7e\2\2\u063a\u063b\7m\2\2\u063b\u063c\7g\2\2\u063c")
>
> +
> buf.write("\u063d\7f\2\2\u063d\u0124\3\2\2\2\u063e\u063f\7t\2\2\u063f")
>
> +
> buf.write("\u0640\7w\2\2\u0640\u0641\7n\2\2\u0641\u0642\7g\2\2\u0642"
> )
>
> +
> buf.write("\u0126\3\2\2\2\u0643\u0644\7g\2\2\u0644\u0645\7p\2\2\u0645"
> )
>
> +
> buf.write("\u0646\7f\2\2\u0646\u0647\7t\2\2\u0647\u0648\7w\2\2\u0648")
>
> +
> buf.write("\u0649\7n\2\2\u0649\u064a\7g\2\2\u064a\u0128\3\2\2\2\u064b"
> )
>
> +
> buf.write("\u064c\7x\2\2\u064c\u064d\7c\2\2\u064d\u064e\7n\2\2\u064e")
>
> +
> buf.write("\u064f\7w\2\2\u064f\u0650\7g\2\2\u0650\u012a\3\2\2\2\u0651")
>
> +
> buf.write("\u0652\7t\2\2\u0652\u0653\7g\2\2\u0653\u0654\7c\2\2\u0654")
>
> +
> buf.write("\u0655\7f\2\2\u0655\u012c\3\2\2\2\u0656\u0657\7y\2\2\u0657")
>
> +
> buf.write("\u0658\7t\2\2\u0658\u0659\7k\2\2\u0659\u065a\7v\2\2\u065a")
>
> +
> buf.write("\u065b\7g\2\2\u065b\u012e\3\2\2\2\u065c\u065d\7t\2\2\u065d"
> )
>
> +
> buf.write("\u065e\7g\2\2\u065e\u065f\7u\2\2\u065f\u0660\7g\2\2\u0660")
>
> +
> buf.write("\u0661\7v\2\2\u0661\u0662\7d\2\2\u0662\u0663\7w\2\2\u0663"
> )
>
> +
> buf.write("\u0664\7v\2\2\u0664\u0665\7v\2\2\u0665\u0666\7q\2\2\u0666")
>
> +
> buf.write("\u0667\7p\2\2\u0667\u0130\3\2\2\2\u0668\u0669\7g\2\2\u0669"
> )
>
> +
> buf.write("\u066a\7p\2\2\u066a\u066b\7f\2\2\u066b\u066c\7t\2\2\u066c")
>
> +
> buf.write("\u066d\7g\2\2\u066d\u066e\7u\2\2\u066e\u066f\7g\2\2\u066f")
>
> +
> buf.write("\u0670\7v\2\2\u0670\u0671\7d\2\2\u0671\u0672\7w\2\2\u0672"
> )
>
> +
> buf.write("\u0673\7v\2\2\u0673\u0674\7v\2\2\u0674\u0675\7q\2\2\u0675")
>
> +
> buf.write("\u0676\7p\2\2\u0676\u0132\3\2\2\2\u0677\u0678\7f\2\2\u0678"
> )
>
> +
> buf.write("\u0679\7g\2\2\u0679\u067a\7h\2\2\u067a\u067b\7c\2\2\u067b")
>
> +
> buf.write("\u067c\7w\2\2\u067c\u067d\7n\2\2\u067d\u067e\7v\2\2\u067e")
>
> +
> buf.write("\u067f\7u\2\2\u067f\u0680\7v\2\2\u0680\u0681\7q\2\2\u0681")
>
> +
> buf.write("\u0682\7t\2\2\u0682\u0683\7g\2\2\u0683\u0134\3\2\2\2\u0684")
>
> +
> buf.write("\u0685\7c\2\2\u0685\u0686\7v\2\2\u0686\u0687\7v\2\2\u0687")
>
> +
> buf.write("\u0688\7t\2\2\u0688\u0689\7k\2\2\u0689\u068a\7d\2\2\u068a")
>
> +
> buf.write("\u068b\7w\2\2\u068b\u068c\7v\2\2\u068c\u068d\7g\2\2\u068d")
>
> +
> buf.write("\u0136\3\2\2\2\u068e\u068f\7x\2\2\u068f\u0690\7c\2\2\u0690")
>
> +
> buf.write("\u0691\7t\2\2\u0691\u0692\7u\2\2\u0692\u0693\7v\2\2\u0693")
>
> +
> buf.write("\u0694\7q\2\2\u0694\u0695\7t\2\2\u0695\u0696\7g\2\2\u0696")
>
> +
> buf.write("\u0138\3\2\2\2\u0697\u0698\7g\2\2\u0698\u0699\7h\2\2\u0699"
> )
>
> +
> buf.write("\u069a\7k\2\2\u069a\u069b\7x\2\2\u069b\u069c\7c\2\2\u069c")
>
> +
> buf.write("\u069d\7t\2\2\u069d\u069e\7u\2\2\u069e\u069f\7v\2\2\u069f")
>
> +
> buf.write("\u06a0\7q\2\2\u06a0\u06a1\7t\2\2\u06a1\u06a2\7g\2\2\u06a2")
>
> +
> buf.write("\u013a\3\2\2\2\u06a3\u06a4\7x\2\2\u06a4\u06a5\7c\2\2\u06a5"
> )
>
> +
> buf.write("\u06a6\7t\2\2\u06a6\u06a7\7u\2\2\u06a7\u06a8\7k\2\2\u06a8")
>
> +
> buf.write("\u06a9\7|\2\2\u06a9\u06aa\7g\2\2\u06aa\u013c\3\2\2\2\u06ab"
> )
>
> +
> buf.write("\u06ac\7p\2\2\u06ac\u06ad\7c\2\2\u06ad\u06ae\7o\2\2\u06ae")
>
> +
> buf.write("\u06af\7g\2\2\u06af\u06b0\7x\2\2\u06b0\u06b1\7c\2\2\u06b1")
>
> +
> buf.write("\u06b2\7n\2\2\u06b2\u06b3\7w\2\2\u06b3\u06b4\7g\2\2\u06b4"
> )
>
> +
> buf.write("\u06b5\7x\2\2\u06b5\u06b6\7c\2\2\u06b6\u06b7\7t\2\2\u06b7")
>
> +
> buf.write("\u06b8\7u\2\2\u06b8\u06b9\7v\2\2\u06b9\u06ba\7q\2\2\u06ba"
> )
>
> +
> buf.write("\u06bb\7t\2\2\u06bb\u06bc\7g\2\2\u06bc\u013e\3\2\2\2\u06bd"
> )
>
> +
> buf.write("\u06be\7c\2\2\u06be\u06bf\7e\2\2\u06bf\u06c0\7v\2\2\u06c0")
>
> +
> buf.write("\u06c1\7k\2\2\u06c1\u06c2\7q\2\2\u06c2\u06c3\7p\2\2\u06c3")
>
> +
> buf.write("\u0140\3\2\2\2\u06c4\u06c5\7e\2\2\u06c5\u06c6\7q\2\2\u06c6")
>
> +
> buf.write("\u06c7\7p\2\2\u06c7\u06c8\7h\2\2\u06c8\u06c9\7k\2\2\u06c9")
>
> +
> buf.write("\u06ca\7i\2\2\u06ca\u0142\3\2\2\2\u06cb\u06cc\7g\2\2\u06cc")
>
> +
> buf.write("\u06cd\7p\2\2\u06cd\u06ce\7f\2\2\u06ce\u06cf\7c\2\2\u06cf")
>
> +
> buf.write("\u06d0\7e\2\2\u06d0\u06d1\7v\2\2\u06d1\u06d2\7k\2\2\u06d2")
>
> +
> buf.write("\u06d3\7q\2\2\u06d3\u06d4\7p\2\2\u06d4\u0144\3\2\2\2\u06d5
> ")
>
> +
> buf.write("\u06d6\7t\2\2\u06d6\u06d7\7g\2\2\u06d7\u06d8\7h\2\2\u06d8")
>
> +
> buf.write("\u06d9\7t\2\2\u06d9\u06da\7g\2\2\u06da\u06db\7u\2\2\u06db")
>
> +
> buf.write("\u06dc\7j\2\2\u06dc\u0146\3\2\2\2\u06dd\u06de\7k\2\2\u06de")
>
> +
> buf.write("\u06df\7p\2\2\u06df\u06e0\7v\2\2\u06e0\u06e1\7g\2\2\u06e1")
>
> +
> buf.write("\u06e2\7t\2\2\u06e2\u06e3\7x\2\2\u06e3\u06e4\7c\2\2\u06e4")
>
> +
> buf.write("\u06e5\7n\2\2\u06e5\u0148\3\2\2\2\u06e6\u06e7\7x\2\2\u06e7"
> )
>
> +
> buf.write("\u06e8\7c\2\2\u06e8\u06e9\7t\2\2\u06e9\u06ea\7u\2\2\u06ea")
>
> +
> buf.write("\u06eb\7v\2\2\u06eb\u06ec\7q\2\2\u06ec\u06ed\7t\2\2\u06ed")
>
> +
> buf.write("\u06ee\7g\2\2\u06ee\u06ef\7f\2\2\u06ef\u06f0\7g\2\2\u06f0")
>
> +
> buf.write("\u06f1\7x\2\2\u06f1\u06f2\7k\2\2\u06f2\u06f3\7e\2\2\u06f3")
>
> +
> buf.write("\u06f4\7g\2\2\u06f4\u014a\3\2\2\2\u06f5\u06f6\7i\2\2\u06f6")
>
> +
> buf.write("\u06f7\7w\2\2\u06f7\u06f8\7k\2\2\u06f8\u06f9\7f\2\2\u06f9")
>
> +
> buf.write("\u06fa\7q\2\2\u06fa\u06fb\7r\2\2\u06fb\u014c\3\2\2\2\u06fc")
>
> +
> buf.write("\u06fd\7g\2\2\u06fd\u06fe\7p\2\2\u06fe\u06ff\7f\2\2\u06ff")
>
> +
> buf.write("\u0700\7i\2\2\u0700\u0701\7w\2\2\u0701\u0702\7k\2\2\u0702")
>
> +
> buf.write("\u0703\7f\2\2\u0703\u0704\7q\2\2\u0704\u0705\7r\2\2\u0705")
>
> +
> buf.write("\u014e\3\2\2\2\u0706\u0707\7f\2\2\u0707\u0708\7c\2\2\u0708")
>
> +
> buf.write("\u0709\7v\2\2\u0709\u070a\7c\2\2\u070a\u070b\7v\2\2\u070b")
>
> +
> buf.write("\u070c\7{\2\2\u070c\u070d\7r\2\2\u070d\u070e\7g\2\2\u070e")
>
> +
> buf.write("\u0150\3\2\2\2\u070f\u0710\7f\2\2\u0710\u0711\7c\2\2\u0711")
>
> +
> buf.write("\u0712\7v\2\2\u0712\u0713\7c\2\2\u0713\u0152\3\2\2\2\u0714"
> )
>
> +
> buf.write("\u0715\7o\2\2\u0715\u0716\7q\2\2\u0716\u0717\7f\2\2\u0717")
>
> +
> buf.write("\u0718\7c\2\2\u0718\u0719\7n\2\2\u0719\u0154\3\2\2\2\u071a"
> )
>
> +
> buf.write("\u071b\7P\2\2\u071b\u071c\7Q\2\2\u071c\u071d\7P\2\2\u071d")
>
> +
> buf.write("\u071e\7a\2\2\u071e\u071f\7F\2\2\u071f\u0720\7G\2\2\u0720")
>
> +
> buf.write("\u0721\7X\2\2\u0721\u0722\7K\2\2\u0722\u0723\7E\2\2\u0723")
>
> +
> buf.write("\u0724\7G\2\2\u0724\u0156\3\2\2\2\u0725\u0726\7F\2\2\u0726"
> )
>
> +
> buf.write("\u0727\7K\2\2\u0727\u0728\7U\2\2\u0728\u0729\7M\2\2\u0729"
> )
>
> +
> buf.write("\u072a\7a\2\2\u072a\u072b\7F\2\2\u072b\u072c\7G\2\2\u072c")
>
> +
> buf.write("\u072d\7X\2\2\u072d\u072e\7K\2\2\u072e\u072f\7E\2\2\u072f")
>
> +
> buf.write("\u0730\7G\2\2\u0730\u0158\3\2\2\2\u0731\u0732\7X\2\2\u0732"
> )
>
> +
> buf.write("\u0733\7K\2\2\u0733\u0734\7F\2\2\u0734\u0735\7G\2\2\u0735")
>
> +
> buf.write("\u0736\7Q\2\2\u0736\u0737\7a\2\2\u0737\u0738\7F\2\2\u0738")
>
> +
> buf.write("\u0739\7G\2\2\u0739\u073a\7X\2\2\u073a\u073b\7K\2\2\u073b"
> )
>
> +
> buf.write("\u073c\7E\2\2\u073c\u073d\7G\2\2\u073d\u015a\3\2\2\2\u073e"
> )
>
> +
> buf.write("\u073f\7P\2\2\u073f\u0740\7G\2\2\u0740\u0741\7V\2\2\u0741")
>
> +
> buf.write("\u0742\7Y\2\2\u0742\u0743\7Q\2\2\u0743\u0744\7T\2\2\u0744")
>
> +
> buf.write("\u0745\7M\2\2\u0745\u0746\7a\2\2\u0746\u0747\7F\2\2\u0747"
> )
>
> +
> buf.write("\u0748\7G\2\2\u0748\u0749\7X\2\2\u0749\u074a\7K\2\2\u074a")
>
> +
> buf.write("\u074b\7E\2\2\u074b\u074c\7G\2\2\u074c\u015c\3\2\2\2\u074d"
> )
>
> +
> buf.write("\u074e\7K\2\2\u074e\u074f\7P\2\2\u074f\u0750\7R\2\2\u0750")
>
> +
> buf.write("\u0751\7W\2\2\u0751\u0752\7V\2\2\u0752\u0753\7a\2\2\u0753"
> )
>
> +
> buf.write("\u0754\7F\2\2\u0754\u0755\7G\2\2\u0755\u0756\7X\2\2\u0756")
>
> +
> buf.write("\u0757\7K\2\2\u0757\u0758\7E\2\2\u0758\u0759\7G\2\2\u0759")
>
> +
> buf.write("\u015e\3\2\2\2\u075a\u075b\7Q\2\2\u075b\u075c\7P\2\2\u075c"
> )
>
> +
> buf.write("\u075d\7D\2\2\u075d\u075e\7Q\2\2\u075e\u075f\7C\2\2\u075f")
>
> +
> buf.write("\u0760\7T\2\2\u0760\u0761\7F\2\2\u0761\u0762\7a\2\2\u0762")
>
> +
> buf.write("\u0763\7F\2\2\u0763\u0764\7G\2\2\u0764\u0765\7X\2\2\u0765")
>
> +
> buf.write("\u0766\7K\2\2\u0766\u0767\7E\2\2\u0767\u0768\7G\2\2\u0768")
>
> +
> buf.write("\u0160\3\2\2\2\u0769\u076a\7Q\2\2\u076a\u076b\7V\2\2\u076b
> ")
>
> +
> buf.write("\u076c\7J\2\2\u076c\u076d\7G\2\2\u076d\u076e\7T\2\2\u076e")
>
> +
> buf.write("\u076f\7a\2\2\u076f\u0770\7F\2\2\u0770\u0771\7G\2\2\u0771")
>
> +
> buf.write("\u0772\7X\2\2\u0772\u0773\7K\2\2\u0773\u0774\7E\2\2\u0774")
>
> +
> buf.write("\u0775\7G\2\2\u0775\u0162\3\2\2\2\u0776\u0777\7U\2\2\u0777
> ")
>
> +
> buf.write("\u0778\7G\2\2\u0778\u0779\7V\2\2\u0779\u077a\7W\2\2\u077a
> ")
>
> +
> buf.write("\u077b\7R\2\2\u077b\u077c\7a\2\2\u077c\u077d\7C\2\2\u077d")
>
> +
> buf.write("\u077e\7R\2\2\u077e\u077f\7R\2\2\u077f\u0780\7N\2\2\u0780")
>
> +
> buf.write("\u0781\7K\2\2\u0781\u0782\7E\2\2\u0782\u0783\7C\2\2\u0783")
>
> +
> buf.write("\u0784\7V\2\2\u0784\u0785\7K\2\2\u0785\u0786\7Q\2\2\u0786"
> )
>
> +
> buf.write("\u0787\7P\2\2\u0787\u0164\3\2\2\2\u0788\u0789\7I\2\2\u0789")
>
> +
> buf.write("\u078a\7G\2\2\u078a\u078b\7P\2\2\u078b\u078c\7G\2\2\u078c")
>
> +
> buf.write("\u078d\7T\2\2\u078d\u078e\7C\2\2\u078e\u078f\7N\2\2\u078f")
>
> +
> buf.write("\u0790\7a\2\2\u0790\u0791\7C\2\2\u0791\u0792\7R\2\2\u0792")
>
> +
> buf.write("\u0793\7R\2\2\u0793\u0794\7N\2\2\u0794\u0795\7K\2\2\u0795")
>
> +
> buf.write("\u0796\7E\2\2\u0796\u0797\7C\2\2\u0797\u0798\7V\2\2\u0798")
>
> +
> buf.write("\u0799\7K\2\2\u0799\u079a\7Q\2\2\u079a\u079b\7P\2\2\u079b"
> )
>
> +
> buf.write("\u0166\3\2\2\2\u079c\u079d\7H\2\2\u079d\u079e\7T\2\2\u079e"
> )
>
> +
> buf.write("\u079f\7Q\2\2\u079f\u07a0\7P\2\2\u07a0\u07a1\7V\2\2\u07a1")
>
> +
> buf.write("\u07a2\7a\2\2\u07a2\u07a3\7R\2\2\u07a3\u07a4\7C\2\2\u07a4")
>
> +
> buf.write("\u07a5\7I\2\2\u07a5\u07a6\7G\2\2\u07a6\u0168\3\2\2\2\u07a7"
> )
>
> +
> buf.write("\u07a8\7U\2\2\u07a8\u07a9\7K\2\2\u07a9\u07aa\7P\2\2\u07aa")
>
> +
> buf.write("\u07ab\7I\2\2\u07ab\u07ac\7N\2\2\u07ac\u07ad\7G\2\2\u07ad")
>
> +
> buf.write("\u07ae\7a\2\2\u07ae\u07af\7W\2\2\u07af\u07b0\7U\2\2\u07b0")
>
> +
> buf.write("\u07b1\7G\2\2\u07b1\u016a\3\2\2\2\u07b2\u07b3\7[\2\2\u07b3
> ")
>
> +
> buf.write("\u07b4\7G\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7T\2\2\u07b6"
> )
>
> +
> buf.write("\u07b7\7a\2\2\u07b7\u07b8\7U\2\2\u07b8\u07b9\7W\2\2\u07b9
> ")
>
> +
> buf.write("\u07ba\7R\2\2\u07ba\u07bb\7R\2\2\u07bb\u07bc\7T\2\2\u07bc"
> )
>
> +
> buf.write("\u07bd\7G\2\2\u07bd\u07be\7U\2\2\u07be\u07bf\7U\2\2\u07bf"
> )
>
> +
> buf.write("\u016c\3\2\2\2\u07c0\u07c1\7O\2\2\u07c1\u07c2\7Q\2\2\u07c2")
>
> +
> buf.write("\u07c3\7P\2\2\u07c3\u07c4\7V\2\2\u07c4\u07c5\7J\2\2\u07c5")
>
> +
> buf.write("\u07c6\7a\2\2\u07c6\u07c7\7U\2\2\u07c7\u07c8\7W\2\2\u07c8")
>
> +
> buf.write("\u07c9\7R\2\2\u07c9\u07ca\7R\2\2\u07ca\u07cb\7T\2\2\u07cb")
>
> +
> buf.write("\u07cc\7G\2\2\u07cc\u07cd\7U\2\2\u07cd\u07ce\7U\2\2\u07ce")
>
> +
> buf.write("\u016e\3\2\2\2\u07cf\u07d0\7F\2\2\u07d0\u07d1\7C\2\2\u07d1"
> )
>
> +
> buf.write("\u07d2\7[\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d4\7U\2\2\u07d4"
> )
>
> +
> buf.write("\u07d5\7W\2\2\u07d5\u07d6\7R\2\2\u07d6\u07d7\7R\2\2\u07d7
> ")
>
> +
> buf.write("\u07d8\7T\2\2\u07d8\u07d9\7G\2\2\u07d9\u07da\7U\2\2\u07da
> ")
>
> +
> buf.write("\u07db\7U\2\2\u07db\u0170\3\2\2\2\u07dc\u07dd\7J\2\2\u07dd
> ")
>
> +
> buf.write("\u07de\7Q\2\2\u07de\u07df\7W\2\2\u07df\u07e0\7T\2\2\u07e0"
> )
>
> +
> buf.write("\u07e1\7a\2\2\u07e1\u07e2\7U\2\2\u07e2\u07e3\7W\2\2\u07e3
> ")
>
> +
> buf.write("\u07e4\7R\2\2\u07e4\u07e5\7R\2\2\u07e5\u07e6\7T\2\2\u07e6")
>
> +
> buf.write("\u07e7\7G\2\2\u07e7\u07e8\7U\2\2\u07e8\u07e9\7U\2\2\u07e9"
> )
>
> +
> buf.write("\u0172\3\2\2\2\u07ea\u07eb\7O\2\2\u07eb\u07ec\7K\2\2\u07ec"
> )
>
> +
> buf.write("\u07ed\7P\2\2\u07ed\u07ee\7W\2\2\u07ee\u07ef\7V\2\2\u07ef")
>
> +
> buf.write("\u07f0\7G\2\2\u07f0\u07f1\7a\2\2\u07f1\u07f2\7U\2\2\u07f2")
>
> +
> buf.write("\u07f3\7W\2\2\u07f3\u07f4\7R\2\2\u07f4\u07f5\7R\2\2\u07f5")
>
> +
> buf.write("\u07f6\7T\2\2\u07f6\u07f7\7G\2\2\u07f7\u07f8\7U\2\2\u07f8")
>
> +
> buf.write("\u07f9\7U\2\2\u07f9\u0174\3\2\2\2\u07fa\u07fb\7U\2\2\u07fb")
>
> +
> buf.write("\u07fc\7G\2\2\u07fc\u07fd\7E\2\2\u07fd\u07fe\7Q\2\2\u07fe")
>
> +
> buf.write("\u07ff\7P\2\2\u07ff\u0800\7F\2\2\u0800\u0801\7a\2\2\u0801")
>
> +
> buf.write("\u0802\7U\2\2\u0802\u0803\7W\2\2\u0803\u0804\7R\2\2\u0804
> ")
>
> +
> buf.write("\u0805\7R\2\2\u0805\u0806\7T\2\2\u0806\u0807\7G\2\2\u0807")
>
> +
> buf.write("\u0808\7U\2\2\u0808\u0809\7U\2\2\u0809\u0176\3\2\2\2\u080a
> ")
>
> +
> buf.write("\u080b\7U\2\2\u080b\u080c\7V\2\2\u080c\u080d\7Q\2\2\u080d"
> )
>
> +
> buf.write("\u080e\7T\2\2\u080e\u080f\7C\2\2\u080f\u0810\7I\2\2\u0810")
>
> +
> buf.write("\u0811\7G\2\2\u0811\u0812\7a\2\2\u0812\u0813\7P\2\2\u0813")
>
> +
> buf.write("\u0814\7Q\2\2\u0814\u0815\7T\2\2\u0815\u0816\7O\2\2\u0816"
> )
>
> +
> buf.write("\u0817\7C\2\2\u0817\u0818\7N\2\2\u0818\u0178\3\2\2\2\u0819
> ")
>
> +
> buf.write("\u081a\7U\2\2\u081a\u081b\7V\2\2\u081b\u081c\7Q\2\2\u081c"
> )
>
> +
> buf.write("\u081d\7T\2\2\u081d\u081e\7C\2\2\u081e\u081f\7I\2\2\u081f")
>
> +
> buf.write("\u0820\7G\2\2\u0820\u0821\7a\2\2\u0821\u0822\7V\2\2\u0822")
>
> +
> buf.write("\u0823\7K\2\2\u0823\u0824\7O\2\2\u0824\u0825\7G\2\2\u0825"
> )
>
> +
> buf.write("\u017a\3\2\2\2\u0826\u0827\7U\2\2\u0827\u0828\7V\2\2\u0828
> ")
>
> +
> buf.write("\u0829\7Q\2\2\u0829\u082a\7T\2\2\u082a\u082b\7C\2\2\u082b"
> )
>
> +
> buf.write("\u082c\7I\2\2\u082c\u082d\7G\2\2\u082d\u082e\7a\2\2\u082e")
>
> +
> buf.write("\u082f\7Y\2\2\u082f\u0830\7C\2\2\u0830\u0831\7M\2\2\u0831")
>
> +
> buf.write("\u0832\7G\2\2\u0832\u0833\7W\2\2\u0833\u0834\7R\2\2\u0834
> ")
>
> +
> buf.write("\u017c\3\2\2\2\u0835\u0836\7W\2\2\u0836\u0837\7P\2\2\u0837
> ")
>
> +
> buf.write("\u0838\7K\2\2\u0838\u0839\7S\2\2\u0839\u083a\7W\2\2\u083a"
> )
>
> +
> buf.write("\u083b\7G\2\2\u083b\u017e\3\2\2\2\u083c\u083d\7P\2\2\u083d
> ")
>
> +
> buf.write("\u083e\7Q\2\2\u083e\u083f\7G\2\2\u083f\u0840\7O\2\2\u0840")
>
> +
> buf.write("\u0841\7R\2\2\u0841\u0842\7V\2\2\u0842\u0843\7[\2\2\u0843")
>
> +
> buf.write("\u0180\3\2\2\2\u0844\u0845\7e\2\2\u0845\u0846\7q\2\2\u0846"
> )
>
> +
> buf.write("\u0847\7p\2\2\u0847\u0848\7f\2\2\u0848\u0182\3\2\2\2\u0849"
> )
>
> +
> buf.write("\u084a\7h\2\2\u084a\u084b\7k\2\2\u084b\u084c\7p\2\2\u084c")
>
> +
> buf.write("\u084d\7f\2\2\u084d\u0184\3\2\2\2\u084e\u084f\7o\2\2\u084f")
>
> +
> buf.write("\u0850\7k\2\2\u0850\u0851\7f\2\2\u0851\u0186\3\2\2\2\u0852")
>
> +
> buf.write("\u0853\7v\2\2\u0853\u0854\7q\2\2\u0854\u0855\7m\2\2\u0855"
> )
>
> +
> buf.write("\u0856\7g\2\2\u0856\u0857\7p\2\2\u0857\u0188\3\2\2\2\u0858"
> )
>
> +
> buf.write("\u0859\7u\2\2\u0859\u085a\7r\2\2\u085a\u085b\7c\2\2\u085b")
>
> +
> buf.write("\u085c\7p\2\2\u085c\u018a\3\2\2\2\u085d\u085e\7f\2\2\u085e")
>
> +
> buf.write("\u085f\7w\2\2\u085f\u0860\7r\2\2\u0860\u018c\3\2\2\2\u0861")
>
> +
> buf.write("\u0862\7x\2\2\u0862\u0863\7c\2\2\u0863\u0864\7t\2\2\u0864")
>
> +
> buf.write("\u0865\7g\2\2\u0865\u0866\7s\2\2\u0866\u0867\7x\2\2\u0867")
>
> +
> buf.write("\u0868\7c\2\2\u0868\u0869\7n\2\2\u0869\u018e\3\2\2\2\u086a"
> )
>
> +
> buf.write("\u086b\7x\2\2\u086b\u086c\7c\2\2\u086c\u086d\7t\2\2\u086d")
>
> +
> buf.write("\u0190\3\2\2\2\u086e\u086f\7k\2\2\u086f\u0870\7f\2\2\u0870")
>
> +
> buf.write("\u0871\7g\2\2\u0871\u0872\7s\2\2\u0872\u0873\7x\2\2\u0873")
>
> +
> buf.write("\u0874\7c\2\2\u0874\u0875\7n\2\2\u0875\u0192\3\2\2\2\u0876"
> )
>
> +
> buf.write("\u0877\7k\2\2\u0877\u0878\7f\2\2\u0878\u0879\7g\2\2\u0879")
>
> +
> buf.write("\u087a\7s\2\2\u087a\u087b\7k\2\2\u087b\u087c\7f\2\2\u087c")
>
> +
> buf.write("\u0194\3\2\2\2\u087d\u087e\7k\2\2\u087e\u087f\7f\2\2\u087f")
>
> +
> buf.write("\u0880\7g\2\2\u0880\u0881\7s\2\2\u0881\u0882\7x\2\2\u0882")
>
> +
> buf.write("\u0883\7c\2\2\u0883\u0884\7n\2\2\u0884\u0885\7n\2\2\u0885")
>
> +
> buf.write("\u0886\7k\2\2\u0886\u0887\7u\2\2\u0887\u0888\7v\2\2\u0888")
>
> +
> buf.write("\u0196\3\2\2\2\u0889\u088a\7s\2\2\u088a\u088b\7w\2\2\u088b
> ")
>
> +
> buf.write("\u088c\7g\2\2\u088c\u088d\7u\2\2\u088d\u088e\7v\2\2\u088e")
>
> +
> buf.write("\u088f\7k\2\2\u088f\u0890\7q\2\2\u0890\u0891\7p\2\2\u0891")
>
> +
> buf.write("\u0892\7t\2\2\u0892\u0893\7g\2\2\u0893\u0894\7h\2\2\u0894")
>
> +
> buf.write("\u0198\3\2\2\2\u0895\u0896\7t\2\2\u0896\u0897\7w\2\2\u0897"
> )
>
> +
> buf.write("\u0898\7n\2\2\u0898\u0899\7g\2\2\u0899\u089a\7t\2\2\u089a")
>
> +
> buf.write("\u089b\7g\2\2\u089b\u089c\7h\2\2\u089c\u019a\3\2\2\2\u089d"
> )
>
> +
> buf.write("\u089e\7u\2\2\u089e\u089f\7v\2\2\u089f\u08a0\7t\2\2\u08a0")
>
> +
> buf.write("\u08a1\7k\2\2\u08a1\u08a2\7p\2\2\u08a2\u08a3\7i\2\2\u08a3")
>
> +
> buf.write("\u08a4\7t\2\2\u08a4\u08a5\7g\2\2\u08a5\u08a6\7h\2\2\u08a6")
>
> +
> buf.write("\u019c\3\2\2\2\u08a7\u08a8\7r\2\2\u08a8\u08a9\7w\2\2\u08a9"
> )
>
> +
> buf.write("\u08aa\7u\2\2\u08aa\u08ab\7j\2\2\u08ab\u08ac\7v\2\2\u08ac")
>
> +
> buf.write("\u08ad\7j\2\2\u08ad\u08ae\7k\2\2\u08ae\u08af\7u\2\2\u08af")
>
> +
> buf.write("\u019e\3\2\2\2\u08b0\u08b1\7u\2\2\u08b1\u08b2\7g\2\2\u08b2
> ")
>
> +
> buf.write("\u08b3\7e\2\2\u08b3\u08b4\7w\2\2\u08b4\u08b5\7t\2\2\u08b5"
> )
>
> +
> buf.write("\u08b6\7k\2\2\u08b6\u08b7\7v\2\2\u08b7\u08b8\7{\2\2\u08b8")
>
> +
> buf.write("\u01a0\3\2\2\2\u08b9\u08ba\7i\2\2\u08ba\u08bb\7g\2\2\u08bb"
> )
>
> +
> buf.write("\u08bc\7v\2\2\u08bc\u01a2\3\2\2\2\u08bd\u08be\7V\2\2\u08be"
> )
>
> +
> buf.write("\u08bf\7T\2\2\u08bf\u08c0\7W\2\2\u08c0\u08c1\7G\2\2\u08c1")
>
> +
> buf.write("\u01a4\3\2\2\2\u08c2\u08c3\7H\2\2\u08c3\u08c4\7C\2\2\u08c4")
>
> +
> buf.write("\u08c5\7N\2\2\u08c5\u08c6\7U\2\2\u08c6\u08c7\7G\2\2\u08c7")
>
> +
> buf.write("\u01a6\3\2\2\2\u08c8\u08c9\7Q\2\2\u08c9\u08ca\7P\2\2\u08ca")
>
> +
> buf.write("\u08cb\7G\2\2\u08cb\u01a8\3\2\2\2\u08cc\u08cd\7Q\2\2\u08cd"
> )
>
> +
> buf.write("\u08ce\7P\2\2\u08ce\u08cf\7G\2\2\u08cf\u08d0\7U\2\2\u08d0")
>
> +
> buf.write("\u01aa\3\2\2\2\u08d1\u08d2\7\\\2\2\u08d2\u08d3\7G\2\2")
>
> +
> buf.write("\u08d3\u08d4\7T\2\2\u08d4\u08d5\7Q\2\2\u08d5\u01ac\3\2")
>
> +
> buf.write("\2\2\u08d6\u08d7\7W\2\2\u08d7\u08d8\7P\2\2\u08d8\u08d9")
>
> +
> buf.write("\7F\2\2\u08d9\u08da\7G\2\2\u08da\u08db\7H\2\2\u08db\u08dc"
> )
>
> +
> buf.write("\7K\2\2\u08dc\u08dd\7P\2\2\u08dd\u08de\7G\2\2\u08de\u08df"
> )
>
> +
> buf.write("\7F\2\2\u08df\u01ae\3\2\2\2\u08e0\u08e1\7X\2\2\u08e1\u08e2")
>
> +
> buf.write("\7G\2\2\u08e2\u08e3\7T\2\2\u08e3\u08e4\7U\2\2\u08e4\u08e5"
> )
>
> +
> buf.write("\7K\2\2\u08e5\u08e6\7Q\2\2\u08e6\u08e7\7P\2\2\u08e7\u01b0"
> )
>
> +
> buf.write("\3\2\2\2\u08e8\u08e9\7n\2\2\u08e9\u08ea\7g\2\2\u08ea\u08eb"
> )
>
> +
> buf.write("\7p\2\2\u08eb\u08ec\7i\2\2\u08ec\u08ed\7v\2\2\u08ed\u08ee")
>
> +
> buf.write("\7j\2\2\u08ee\u01b2\3\2\2\2\u08ef\u08f0\7C\2\2\u08f0\u08f1")
>
> +
> buf.write("\7P\2\2\u08f1\u08f2\7F\2\2\u08f2\u01b4\3\2\2\2\u08f3\u08f4")
>
> +
> buf.write("\7Q\2\2\u08f4\u08f5\7T\2\2\u08f5\u01b6\3\2\2\2\u08f6\u08f7")
>
> +
> buf.write("\7P\2\2\u08f7\u08f8\7Q\2\2\u08f8\u08f9\7V\2\2\u08f9\u01b8")
>
> +
> buf.write("\3\2\2\2\u08fa\u08fb\7u\2\2\u08fb\u08fc\7g\2\2\u08fc\u08fd")
>
> +
> buf.write("\7v\2\2\u08fd\u01ba\3\2\2\2\u08fe\u08ff\7\u0080\2\2\u08ff")
>
> +
> buf.write("\u01bc\3\2\2\2\u0900\u0901\7d\2\2\u0901\u0902\7q\2\2\u0902"
> )
>
> +
> buf.write("\u0903\7q\2\2\u0903\u0904\7n\2\2\u0904\u0905\7x\2\2\u0905")
>
> +
> buf.write("\u0906\7c\2\2\u0906\u0907\7n\2\2\u0907\u01be\3\2\2\2\u0908"
> )
>
> +
> buf.write("\u0909\7u\2\2\u0909\u090a\7v\2\2\u090a\u090b\7t\2\2\u090b")
>
> +
> buf.write("\u090c\7k\2\2\u090c\u090d\7p\2\2\u090d\u090e\7i\2\2\u090e")
>
> +
> buf.write("\u090f\7x\2\2\u090f\u0910\7c\2\2\u0910\u0911\7n\2\2\u0911")
>
> +
> buf.write("\u01c0\3\2\2\2\u0912\u0913\7w\2\2\u0913\u0914\7p\2\2\u0914
> ")
>
> +
> buf.write("\u0915\7k\2\2\u0915\u0916\7p\2\2\u0916\u0917\7v\2\2\u0917")
>
> +
> buf.write("\u0918\7x\2\2\u0918\u0919\7c\2\2\u0919\u091a\7n\2\2\u091a")
>
> +
> buf.write("\u01c2\3\2\2\2\u091b\u091c\7v\2\2\u091c\u091d\7q\2\2\u091d"
> )
>
> +
> buf.write("\u091e\7w\2\2\u091e\u091f\7r\2\2\u091f\u0920\7r\2\2\u0920")
>
> +
> buf.write("\u0921\7g\2\2\u0921\u0922\7t\2\2\u0922\u01c4\3\2\2\2\u0923")
>
> +
> buf.write("\u0924\7v\2\2\u0924\u0925\7q\2\2\u0925\u0926\7n\2\2\u0926")
>
> +
> buf.write("\u0927\7q\2\2\u0927\u0928\7y\2\2\u0928\u0929\7g\2\2\u0929")
>
> +
> buf.write("\u092a\7t\2\2\u092a\u01c6\3\2\2\2\u092b\u092c\7o\2\2\u092c")
>
> +
> buf.write("\u092d\7c\2\2\u092d\u092e\7v\2\2\u092e\u092f\7e\2\2\u092f")
>
> +
> buf.write("\u0930\7j\2\2\u0930\u01c8\3\2\2\2\u0931\u0932\7o\2\2\u0932")
>
> +
> buf.write("\u0933\7c\2\2\u0933\u0934\7v\2\2\u0934\u0935\7e\2\2\u0935")
>
> +
> buf.write("\u0936\7j\2\2\u0936\u0937\7\64\2\2\u0937\u01ca\3\2\2\2")
>
> +
> buf.write("\u0938\u0939\7e\2\2\u0939\u093a\7c\2\2\u093a\u093b\7v")
>
> +
> buf.write("\2\2\u093b\u093c\7g\2\2\u093c\u093d\7p\2\2\u093d\u093e")
>
> +
> buf.write("\7c\2\2\u093e\u093f\7v\2\2\u093f\u0940\7g\2\2\u0940\u01cc")
>
> +
> buf.write("\3\2\2\2\u0941\u0942\7s\2\2\u0942\u0943\7w\2\2\u0943\u0944"
> )
>
> +
> buf.write("\7g\2\2\u0944\u0945\7u\2\2\u0945\u0946\7v\2\2\u0946\u0947")
>
> +
> buf.write("\7k\2\2\u0947\u0948\7q\2\2\u0948\u0949\7p\2\2\u0949\u094a")
>
> +
> buf.write("\7t\2\2\u094a\u094b\7g\2\2\u094b\u094c\7h\2\2\u094c\u094d")
>
> +
> buf.write("\7x\2\2\u094d\u094e\7c\2\2\u094e\u094f\7n\2\2\u094f\u01ce")
>
> +
> buf.write("\3\2\2\2\u0950\u0951\7u\2\2\u0951\u0952\7v\2\2\u0952\u0953"
> )
>
> +
> buf.write("\7t\2\2\u0953\u0954\7k\2\2\u0954\u0955\7p\2\2\u0955\u0956")
>
> +
> buf.write("\7i\2\2\u0956\u0957\7t\2\2\u0957\u0958\7g\2\2\u0958\u0959")
>
> +
> buf.write("\7h\2\2\u0959\u095a\7x\2\2\u095a\u095b\7c\2\2\u095b\u095c")
>
> +
> buf.write("\7n\2\2\u095c\u01d0\3\2\2\2\u095d\u095e\7o\2\2\u095e\u095f"
> )
>
> +
> buf.write("\7c\2\2\u095f\u0960\7r\2\2\u0960\u01d2\3\2\2\2\u0961\u0962")
>
> +
> buf.write("\7t\2\2\u0962\u0963\7g\2\2\u0963\u0964\7h\2\2\u0964\u0965")
>
> +
> buf.write("\7t\2\2\u0965\u0966\7g\2\2\u0966\u0967\7u\2\2\u0967\u0968")
>
> +
> buf.write("\7j\2\2\u0968\u0969\7i\2\2\u0969\u096a\7w\2\2\u096a\u096b")
>
> +
> buf.write("\7k\2\2\u096b\u096c\7f\2\2\u096c\u01d4\3\2\2\2\u096d\u096e")
>
> +
> buf.write("\7U\2\2\u096e\u096f\7V\2\2\u096f\u0970\7T\2\2\u0970\u0971")
>
> +
> buf.write("\7K\2\2\u0971\u0972\7P\2\2\u0972\u0973\7I\2\2\u0973\u0974")
>
> +
> buf.write("\7a\2\2\u0974\u0975\7V\2\2\u0975\u0976\7Q\2\2\u0976\u0977"
> )
>
> +
> buf.write("\7M\2\2\u0977\u0978\7G\2\2\u0978\u0979\7P\2\2\u0979\u01d6
> ")
>
> +
> buf.write("\3\2\2\2\u097a\u097b\7Q\2\2\u097b\u097c\7R\2\2\u097c\u097d
> ")
>
> +
> buf.write("\7V\2\2\u097d\u097e\7K\2\2\u097e\u097f\7Q\2\2\u097f\u0980")
>
> +
> buf.write("\7P\2\2\u0980\u0981\7a\2\2\u0981\u0982\7F\2\2\u0982\u0983")
>
> +
> buf.write("\7G\2\2\u0983\u0984\7H\2\2\u0984\u0985\7C\2\2\u0985\u0986"
> )
>
> +
> buf.write("\7W\2\2\u0986\u0987\7N\2\2\u0987\u0988\7V\2\2\u0988\u01d8
> ")
>
> +
> buf.write("\3\2\2\2\u0989\u098a\7Q\2\2\u098a\u098b\7R\2\2\u098b\u098c
> ")
>
> +
> buf.write("\7V\2\2\u098c\u098d\7K\2\2\u098d\u098e\7Q\2\2\u098e\u098f")
>
> +
> buf.write("\7P\2\2\u098f\u0990\7a\2\2\u0990\u0991\7F\2\2\u0991\u0992")
>
> +
> buf.write("\7G\2\2\u0992\u0993\7H\2\2\u0993\u0994\7C\2\2\u0994\u0995"
> )
>
> +
> buf.write("\7W\2\2\u0995\u0996\7N\2\2\u0996\u0997\7V\2\2\u0997\u0998
> ")
>
> +
> buf.write("\7a\2\2\u0998\u0999\7O\2\2\u0999\u099a\7H\2\2\u099a\u099b"
> )
>
> +
> buf.write("\7I\2\2\u099b\u01da\3\2\2\2\u099c\u099d\7P\2\2\u099d\u099e"
> )
>
> +
> buf.write("\7W\2\2\u099e\u099f\7O\2\2\u099f\u09a0\7G\2\2\u09a0\u09a1"
> )
>
> +
> buf.write("\7T\2\2\u09a1\u09a2\7K\2\2\u09a2\u09a3\7E\2\2\u09a3\u09a4")
>
> +
> buf.write("\7a\2\2\u09a4\u09a5\7U\2\2\u09a5\u09a6\7K\2\2\u09a6\u09a7")
>
> +
> buf.write("\7\\\2\2\u09a7\u09a8\7G\2\2\u09a8\u09a9\7a\2\2\u09a9\u09aa"
> )
>
> +
> buf.write("\7\63\2\2\u09aa\u01dc\3\2\2\2\u09ab\u09ac\7P\2\2\u09ac")
>
> +
> buf.write("\u09ad\7W\2\2\u09ad\u09ae\7O\2\2\u09ae\u09af\7G\2\2\u09af"
> )
>
> +
> buf.write("\u09b0\7T\2\2\u09b0\u09b1\7K\2\2\u09b1\u09b2\7E\2\2\u09b2"
> )
>
> +
> buf.write("\u09b3\7a\2\2\u09b3\u09b4\7U\2\2\u09b4\u09b5\7K\2\2\u09b5"
> )
>
> +
> buf.write("\u09b6\7\\\2\2\u09b6\u09b7\7G\2\2\u09b7\u09b8\7a\2\2\u09b8
> ")
>
> +
> buf.write("\u09b9\7\64\2\2\u09b9\u01de\3\2\2\2\u09ba\u09bb\7P\2\2")
>
> +
> buf.write("\u09bb\u09bc\7W\2\2\u09bc\u09bd\7O\2\2\u09bd\u09be\7G")
>
> +
> buf.write("\2\2\u09be\u09bf\7T\2\2\u09bf\u09c0\7K\2\2\u09c0\u09c1")
>
> +
> buf.write("\7E\2\2\u09c1\u09c2\7a\2\2\u09c2\u09c3\7U\2\2\u09c3\u09c4")
>
> +
> buf.write("\7K\2\2\u09c4\u09c5\7\\\2\2\u09c5\u09c6\7G\2\2\u09c6\u09c7")
>
> +
> buf.write("\7a\2\2\u09c7\u09c8\7\66\2\2\u09c8\u01e0\3\2\2\2\u09c9")
>
> +
> buf.write("\u09ca\7P\2\2\u09ca\u09cb\7W\2\2\u09cb\u09cc\7O\2\2\u09cc")
>
> +
> buf.write("\u09cd\7G\2\2\u09cd\u09ce\7T\2\2\u09ce\u09cf\7K\2\2\u09cf")
>
> +
> buf.write("\u09d0\7E\2\2\u09d0\u09d1\7a\2\2\u09d1\u09d2\7U\2\2\u09d2"
> )
>
> +
> buf.write("\u09d3\7K\2\2\u09d3\u09d4\7\\\2\2\u09d4\u09d5\7G\2\2\u09d5
> ")
>
> +
> buf.write("\u09d6\7a\2\2\u09d6\u09d7\7:\2\2\u09d7\u01e2\3\2\2\2\u09d8"
> )
>
> +
> buf.write("\u09d9\7F\2\2\u09d9\u09da\7K\2\2\u09da\u09db\7U\2\2\u09db"
> )
>
> +
> buf.write("\u09dc\7R\2\2\u09dc\u09dd\7N\2\2\u09dd\u09de\7C\2\2\u09de"
> )
>
> +
> buf.write("\u09df\7[\2\2\u09df\u09e0\7a\2\2\u09e0\u09e1\7K\2\2\u09e1")
>
> +
> buf.write("\u09e2\7P\2\2\u09e2\u09e3\7V\2\2\u09e3\u09e4\7a\2\2\u09e4")
>
> +
> buf.write("\u09e5\7F\2\2\u09e5\u09e6\7G\2\2\u09e6\u09e7\7E\2\2\u09e7")
>
> +
> buf.write("\u01e4\3\2\2\2\u09e8\u09e9\7F\2\2\u09e9\u09ea\7K\2\2\u09ea"
> )
>
> +
> buf.write("\u09eb\7U\2\2\u09eb\u09ec\7R\2\2\u09ec\u09ed\7N\2\2\u09ed"
> )
>
> +
> buf.write("\u09ee\7C\2\2\u09ee\u09ef\7[\2\2\u09ef\u09f0\7a\2\2\u09f0")
>
> +
> buf.write("\u09f1\7W\2\2\u09f1\u09f2\7K\2\2\u09f2\u09f3\7P\2\2\u09f3")
>
> +
> buf.write("\u09f4\7V\2\2\u09f4\u09f5\7a\2\2\u09f5\u09f6\7F\2\2\u09f6")
>
> +
> buf.write("\u09f7\7G\2\2\u09f7\u09f8\7E\2\2\u09f8\u01e6\3\2\2\2\u09f9")
>
> +
> buf.write("\u09fa\7F\2\2\u09fa\u09fb\7K\2\2\u09fb\u09fc\7U\2\2\u09fc")
>
> +
> buf.write("\u09fd\7R\2\2\u09fd\u09fe\7N\2\2\u09fe\u09ff\7C\2\2\u09ff")
>
> +
> buf.write("\u0a00\7[\2\2\u0a00\u0a01\7a\2\2\u0a01\u0a02\7W\2\2\u0a02"
> )
>
> +
> buf.write("\u0a03\7K\2\2\u0a03\u0a04\7P\2\2\u0a04\u0a05\7V\2\2\u0a05")
>
> +
> buf.write("\u0a06\7a\2\2\u0a06\u0a07\7J\2\2\u0a07\u0a08\7G\2\2\u0a08")
>
> +
> buf.write("\u0a09\7Z\2\2\u0a09\u01e8\3\2\2\2\u0a0a\u0a0b\7K\2\2\u0a0b"
> )
>
> +
> buf.write("\u0a0c\7P\2\2\u0a0c\u0a0d\7U\2\2\u0a0d\u0a0e\7G\2\2\u0a0e")
>
> +
> buf.write("\u0a0f\7P\2\2\u0a0f\u0a10\7U\2\2\u0a10\u0a11\7K\2\2\u0a11")
>
> +
> buf.write("\u0a12\7V\2\2\u0a12\u0a13\7K\2\2\u0a13\u0a14\7X\2\2\u0a14")
>
> +
> buf.write("\u0a15\7G\2\2\u0a15\u01ea\3\2\2\2\u0a16\u0a17\7U\2\2\u0a17
> ")
>
> +
> buf.write("\u0a18\7G\2\2\u0a18\u0a19\7P\2\2\u0a19\u0a1a\7U\2\2\u0a1a"
> )
>
> +
> buf.write("\u0a1b\7K\2\2\u0a1b\u0a1c\7V\2\2\u0a1c\u0a1d\7K\2\2\u0a1d")
>
> +
> buf.write("\u0a1e\7X\2\2\u0a1e\u0a1f\7G\2\2\u0a1f\u01ec\3\2\2\2\u0a20")
>
> +
> buf.write("\u0a21\7N\2\2\u0a21\u0a22\7C\2\2\u0a22\u0a23\7U\2\2\u0a23"
> )
>
> +
> buf.write("\u0a24\7V\2\2\u0a24\u0a25\7a\2\2\u0a25\u0a26\7P\2\2\u0a26")
>
> +
> buf.write("\u0a27\7Q\2\2\u0a27\u0a28\7P\2\2\u0a28\u0a29\7a\2\2\u0a29")
>
> +
> buf.write("\u0a2a\7O\2\2\u0a2a\u0a2b\7C\2\2\u0a2b\u0a2c\7V\2\2\u0a2c")
>
> +
> buf.write("\u0a2d\7E\2\2\u0a2d\u0a2e\7J\2\2\u0a2e\u01ee\3\2\2\2\u0a2f")
>
> +
> buf.write("\u0a30\7H\2\2\u0a30\u0a31\7K\2\2\u0a31\u0a32\7T\2\2\u0a32")
>
> +
> buf.write("\u0a33\7U\2\2\u0a33\u0a34\7V\2\2\u0a34\u0a35\7a\2\2\u0a35")
>
> +
> buf.write("\u0a36\7P\2\2\u0a36\u0a37\7Q\2\2\u0a37\u0a38\7P\2\2\u0a38")
>
> +
> buf.write("\u0a39\7a\2\2\u0a39\u0a3a\7O\2\2\u0a3a\u0a3b\7C\2\2\u0a3b"
> )
>
> +
> buf.write("\u0a3c\7V\2\2\u0a3c\u0a3d\7E\2\2\u0a3d\u0a3e\7J\2\2\u0a3e")
>
> + buf.write("\u01f0\3\2\2\2\u0a3f\u0a40\7\62\2\2\u0a40\u0a41\7z\2\2")
>
> +
> buf.write("\u0a41\u0a43\3\2\2\2\u0a42\u0a44\t\2\2\2\u0a43\u0a42\3")
>
> +
> buf.write("\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46"
> )
>
> +
> buf.write("\3\2\2\2\u0a46\u0a4d\3\2\2\2\u0a47\u0a49\t\3\2\2\u0a48")
>
> +
> buf.write("\u0a47\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a48\3\2\2\2")
>
> +
> buf.write("\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4d\3\2\2\2\u0a4c\u0a3f\3")
>
> +
> buf.write("\2\2\2\u0a4c\u0a48\3\2\2\2\u0a4d\u01f2\3\2\2\2\u0a4e\u0a52")
>
> + buf.write("\t\4\2\2\u0a4f\u0a51\t\5\2\2\u0a50\u0a4f\3\2\2\2\u0a51")
>
> +
> buf.write("\u0a54\3\2\2\2\u0a52\u0a50\3\2\2\2\u0a52\u0a53\3\2\2\2")
>
> +
> buf.write("\u0a53\u01f4\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a55\u0a57\7")
>
> +
> buf.write("%\2\2\u0a56\u0a58\5\u01fb\u00fe\2\u0a57\u0a56\3\2\2\2")
>
> +
> buf.write("\u0a57\u0a58\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\7")
>
> +
> buf.write("f\2\2\u0a5a\u0a5b\7g\2\2\u0a5b\u0a5c\7h\2\2\u0a5c\u0a5d")
>
> +
> buf.write("\7k\2\2\u0a5d\u0a5e\7p\2\2\u0a5e\u0a5f\7g\2\2\u0a5f\u0a63")
>
> +
> buf.write("\3\2\2\2\u0a60\u0a62\n\6\2\2\u0a61\u0a60\3\2\2\2\u0a62")
>
> +
> buf.write("\u0a65\3\2\2\2\u0a63\u0a61\3\2\2\2\u0a63\u0a64\3\2\2\2")
>
> +
> buf.write("\u0a64\u0a66\3\2\2\2\u0a65\u0a63\3\2\2\2\u0a66\u0a67\b")
>
> +
> buf.write("\u00fb\2\2\u0a67\u01f6\3\2\2\2\u0a68\u0a6a\7%\2\2\u0a69")
>
> +
> buf.write("\u0a6b\5\u01fb\u00fe\2\u0a6a\u0a69\3\2\2\2\u0a6a\u0a6b")
>
> + buf.write("\3\2\2\2\u0a6b\u0a6c\3\2\2\2\u0a6c\u0a6d\7n\2\2\u0a6d")
>
> +
> buf.write("\u0a6e\7k\2\2\u0a6e\u0a6f\7p\2\2\u0a6f\u0a70\7g\2\2\u0a70")
>
> +
> buf.write("\u0a74\3\2\2\2\u0a71\u0a73\n\6\2\2\u0a72\u0a71\3\2\2\2")
>
> +
> buf.write("\u0a73\u0a76\3\2\2\2\u0a74\u0a72\3\2\2\2\u0a74\u0a75\3")
>
> +
> buf.write("\2\2\2\u0a75\u0a77\3\2\2\2\u0a76\u0a74\3\2\2\2\u0a77\u0a78"
> )
>
> +
> buf.write("\b\u00fc\2\2\u0a78\u01f8\3\2\2\2\u0a79\u0a7b\7%\2\2\u0a7a")
>
> +
> buf.write("\u0a7c\5\u01fb\u00fe\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c")
>
> + buf.write("\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7e\7k\2\2\u0a7e")
>
> +
> buf.write("\u0a7f\7p\2\2\u0a7f\u0a80\7e\2\2\u0a80\u0a81\7n\2\2\u0a81")
>
> +
> buf.write("\u0a82\7w\2\2\u0a82\u0a83\7f\2\2\u0a83\u0a84\7g\2\2\u0a84")
>
> +
> buf.write("\u0a88\3\2\2\2\u0a85\u0a87\n\6\2\2\u0a86\u0a85\3\2\2\2")
>
> +
> buf.write("\u0a87\u0a8a\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a88\u0a89\3")
>
> +
> buf.write("\2\2\2\u0a89\u0a8b\3\2\2\2\u0a8a\u0a88\3\2\2\2\u0a8b\u0a8c"
> )
>
> +
> buf.write("\b\u00fd\2\2\u0a8c\u01fa\3\2\2\2\u0a8d\u0a8f\t\7\2\2\u0a8e")
>
> +
> buf.write("\u0a8d\3\2\2\2\u0a8f\u0a90\3\2\2\2\u0a90\u0a8e\3\2\2\2")
>
> +
> buf.write("\u0a90\u0a91\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a93\b")
>
> +
> buf.write("\u00fe\2\2\u0a93\u01fc\3\2\2\2\u0a94\u0a96\7\17\2\2\u0a95")
>
> +
> buf.write("\u0a97\7\f\2\2\u0a96\u0a95\3\2\2\2\u0a96\u0a97\3\2\2\2")
>
> +
> buf.write("\u0a97\u0a9a\3\2\2\2\u0a98\u0a9a\7\f\2\2\u0a99\u0a94\3")
>
> +
> buf.write("\2\2\2\u0a99\u0a98\3\2\2\2\u0a9a\u0a9b\3\2\2\2\u0a9b\u0a9c"
> )
>
> + buf.write("\b\u00ff\2\2\u0a9c\u01fe\3\2\2\2\u0a9d\u0a9e\7\61\2\2")
>
> + buf.write("\u0a9e\u0a9f\7\61\2\2\u0a9f\u0aa3\3\2\2\2\u0aa0\u0aa2")
>
> +
> buf.write("\n\b\2\2\u0aa1\u0aa0\3\2\2\2\u0aa2\u0aa5\3\2\2\2\u0aa3")
>
> +
> buf.write("\u0aa1\3\2\2\2\u0aa3\u0aa4\3\2\2\2\u0aa4\u0aa6\3\2\2\2")
>
> +
> buf.write("\u0aa5\u0aa3\3\2\2\2\u0aa6\u0aa7\b\u0100\2\2\u0aa7\u0200")
>
> +
> buf.write("\3\2\2\2\u0aa8\u0aa9\7g\2\2\u0aa9\u0aaa\7z\2\2\u0aaa\u0aab"
> )
>
> +
> buf.write("\7v\2\2\u0aab\u0aac\7g\2\2\u0aac\u0aad\7t\2\2\u0aad\u0aae")
>
> + buf.write("\7p\2\2\u0aae\u0ab2\3\2\2\2\u0aaf\u0ab1\n\6\2\2\u0ab0")
>
> +
> buf.write("\u0aaf\3\2\2\2\u0ab1\u0ab4\3\2\2\2\u0ab2\u0ab0\3\2\2\2")
>
> +
> buf.write("\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0ab2\3")
>
> +
> buf.write("\2\2\2\u0ab5\u0ab6\b\u0101\2\2\u0ab6\u0202\3\2\2\2\22")
>
> +
> buf.write("\2\u0a45\u0a4a\u0a4c\u0a52\u0a57\u0a63\u0a6a\u0a74\u0a7b"
> )
>
> + buf.write("\u0a88\u0a90\u0a96\u0a99\u0aa3\u0ab2\3\b\2\2")
>
> + return buf.getvalue()
>
> +
>
> +
>
> +class VfrSyntaxLexer(Lexer):
>
> +
>
> + atn = ATNDeserializer().deserialize(serializedATN())
>
> +
>
> + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
>
> +
>
> + T__0 = 1
>
> + T__1 = 2
>
> + T__2 = 3
>
> + T__3 = 4
>
> + T__4 = 5
>
> + T__5 = 6
>
> + T__6 = 7
>
> + T__7 = 8
>
> + T__8 = 9
>
> + T__9 = 10
>
> + T__10 = 11
>
> + T__11 = 12
>
> + T__12 = 13
>
> + T__13 = 14
>
> + T__14 = 15
>
> + T__15 = 16
>
> + Define = 17
>
> + Include = 18
>
> + FormPkgType = 19
>
> + OpenBrace = 20
>
> + CloseBrace = 21
>
> + OpenParen = 22
>
> + CloseParen = 23
>
> + OpenBracket = 24
>
> + CloseBracket = 25
>
> + Dot = 26
>
> + Negative = 27
>
> + Colon = 28
>
> + Slash = 29
>
> + Semicolon = 30
>
> + Comma = 31
>
> + Equal = 32
>
> + NotEqual = 33
>
> + LessEqual = 34
>
> + Less = 35
>
> + GreaterEqual = 36
>
> + Greater = 37
>
> + BitWiseOr = 38
>
> + BitWiseAnd = 39
>
> + DevicePath = 40
>
> + FormSet = 41
>
> + FormSetId = 42
>
> + EndFormSet = 43
>
> + Title = 44
>
> + FormId = 45
>
> + OneOf = 46
>
> + EndOneOf = 47
>
> + Prompt = 48
>
> + OrderedList = 49
>
> + MaxContainers = 50
>
> + EndList = 51
>
> + EndForm = 52
>
> + Form = 53
>
> + FormMap = 54
>
> + MapTitle = 55
>
> + MapGuid = 56
>
> + Subtitle = 57
>
> + EndSubtitle = 58
>
> + Help = 59
>
> + Text = 60
>
> + Option = 61
>
> + FLAGS = 62
>
> + Date = 63
>
> + EndDate = 64
>
> + Year = 65
>
> + Month = 66
>
> + Day = 67
>
> + Time = 68
>
> + EndTime = 69
>
> + Hour = 70
>
> + Minute = 71
>
> + Second = 72
>
> + GrayOutIf = 73
>
> + Label = 74
>
> + Timeout = 75
>
> + Inventory = 76
>
> + NonNvDataMap = 77
>
> + Struct = 78
>
> + Union = 79
>
> + Boolean = 80
>
> + Uint64 = 81
>
> + Uint32 = 82
>
> + Uint16 = 83
>
> + Uint8 = 84
>
> + EFI_STRING_ID = 85
>
> + EFI_HII_DATE = 86
>
> + EFI_HII_TIME = 87
>
> + EFI_HII_REF = 88
>
> + Uuid = 89
>
> + CheckBox = 90
>
> + EndCheckBox = 91
>
> + Numeric = 92
>
> + EndNumeric = 93
>
> + Minimum = 94
>
> + Maximum = 95
>
> + Step = 96
>
> + Default = 97
>
> + Password = 98
>
> + EndPassword = 99
>
> + String = 100
>
> + EndString = 101
>
> + MinSize = 102
>
> + MaxSize = 103
>
> + Encoding = 104
>
> + SuppressIf = 105
>
> + DisableIf = 106
>
> + Hidden = 107
>
> + Goto = 108
>
> + FormSetGuid = 109
>
> + InconsistentIf = 110
>
> + WarningIf = 111
>
> + NoSubmitIf = 112
>
> + EndIf = 113
>
> + Key = 114
>
> + DefaultFlag = 115
>
> + ManufacturingFlag = 116
>
> + CheckBoxDefaultFlag = 117
>
> + CheckBoxDefaultMfgFlag = 118
>
> + InteractiveFlag = 119
>
> + NVAccessFlag = 120
>
> + ResetRequiredFlag = 121
>
> + ReconnectRequiredFlag = 122
>
> + LateCheckFlag = 123
>
> + ReadOnlyFlag = 124
>
> + OptionOnlyFlag = 125
>
> + RestStyleFlag = 126
>
> + Class = 127
>
> + Subclass = 128
>
> + ClassGuid = 129
>
> + TypeDef = 130
>
> + Restore = 131
>
> + Save = 132
>
> + Defaults = 133
>
> + Banner = 134
>
> + Align = 135
>
> + Left = 136
>
> + Right = 137
>
> + Center = 138
>
> + Line = 139
>
> + Name = 140
>
> + VarId = 141
>
> + Question = 142
>
> + QuestionId = 143
>
> + Image = 144
>
> + Locked = 145
>
> + Rule = 146
>
> + EndRule = 147
>
> + Value = 148
>
> + Read = 149
>
> + Write = 150
>
> + ResetButton = 151
>
> + EndResetButton = 152
>
> + DefaultStore = 153
>
> + Attribute = 154
>
> + Varstore = 155
>
> + Efivarstore = 156
>
> + VarSize = 157
>
> + NameValueVarStore = 158
>
> + Action = 159
>
> + Config = 160
>
> + EndAction = 161
>
> + Refresh = 162
>
> + Interval = 163
>
> + VarstoreDevice = 164
>
> + GuidOp = 165
>
> + EndGuidOp = 166
>
> + DataType = 167
>
> + Data = 168
>
> + Modal = 169
>
> + ClassNonDevice = 170
>
> + ClassDiskDevice = 171
>
> + ClassVideoDevice = 172
>
> + ClassNetworkDevice = 173
>
> + ClassInputDevice = 174
>
> + ClassOnBoardDevice = 175
>
> + ClassOtherDevice = 176
>
> + SubclassSetupApplication = 177
>
> + SubclassGeneralApplication = 178
>
> + SubclassFrontPage = 179
>
> + SubclassSingleUse = 180
>
> + YearSupppressFlag = 181
>
> + MonthSuppressFlag = 182
>
> + DaySuppressFlag = 183
>
> + HourSupppressFlag = 184
>
> + MinuteSuppressFlag = 185
>
> + SecondSuppressFlag = 186
>
> + StorageNormalFlag = 187
>
> + StorageTimeFlag = 188
>
> + StorageWakeUpFlag = 189
>
> + UniQueFlag = 190
>
> + NoEmptyFlag = 191
>
> + Cond = 192
>
> + Find = 193
>
> + Mid = 194
>
> + Tok = 195
>
> + Span = 196
>
> + Dup = 197
>
> + VarEqVal = 198
>
> + Var = 199
>
> + IdEqVal = 200
>
> + IdEqId = 201
>
> + IdEqValList = 202
>
> + QuestionRef = 203
>
> + RuleRef = 204
>
> + StringRef = 205
>
> + PushThis = 206
>
> + Security = 207
>
> + Get = 208
>
> + TrueSymbol = 209
>
> + FalseSymbol = 210
>
> + One = 211
>
> + Ones = 212
>
> + Zero = 213
>
> + Undefined = 214
>
> + Version = 215
>
> + Length = 216
>
> + AND = 217
>
> + OR = 218
>
> + NOT = 219
>
> + Set = 220
>
> + BitWiseNot = 221
>
> + BoolVal = 222
>
> + StringVal = 223
>
> + UnIntVal = 224
>
> + ToUpper = 225
>
> + ToLower = 226
>
> + Match = 227
>
> + Match2 = 228
>
> + Catenate = 229
>
> + QuestionRefVal = 230
>
> + StringRefVal = 231
>
> + Map = 232
>
> + RefreshGuid = 233
>
> + StringToken = 234
>
> + OptionDefault = 235
>
> + OptionDefaultMfg = 236
>
> + NumericSizeOne = 237
>
> + NumericSizeTwo = 238
>
> + NumericSizeFour = 239
>
> + NumericSizeEight = 240
>
> + DisPlayIntDec = 241
>
> + DisPlayUIntDec = 242
>
> + DisPlayUIntHex = 243
>
> + Insensitive = 244
>
> + Sensitive = 245
>
> + LastNonMatch = 246
>
> + FirstNonMatch = 247
>
> + Number = 248
>
> + StringIdentifier = 249
>
> + ComplexDefine = 250
>
> + LineDefinition = 251
>
> + IncludeDefinition = 252
>
> + Whitespace = 253
>
> + Newline = 254
>
> + LineComment = 255
>
> + Extern = 256
>
> +
>
> + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
>
> +
>
> + modeNames = [ "DEFAULT_MODE" ]
>
> +
>
> + literalNames = [ "<INVALID>",
>
> + "'show'", "'push'", "'pop'", "'#pragma'", "'pack'", "'='",
> "'IMAGE_TOKEN'",
>
> + "'HORIZONTAL'", "'MULTI_LINE'", "'<<'", "'>>'", "'+'", "'*'",
>
> + "'%'", "'format'", "'?'", "'#define'", "'#include'", "'formpkgtype'",
>
> + "'{'", "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
>
> + "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'", "'>='",
>
> + "'>'", "'|'", "'&'", "'devicepath'", "'formset'", "'formsetid'",
>
> + "'endformset'", "'title'", "'formid'", "'oneof'", "'endoneof'",
>
> + "'prompt'", "'orderedlist'", "'maxcontainers'", "'endlist'",
>
> + "'endform'", "'form'", "'formmap'", "'maptitle'", "'mapguid'",
>
> + "'subtitle'", "'endsubtitle'", "'help'", "'text'", "'option'",
>
> + "'flags'", "'date'", "'enddate'", "'year'", "'month'", "'day'",
>
> + "'time'", "'endtime'", "'hour'", "'minute'", "'second'", "'grayoutif'",
>
> + "'label'", "'timeout'", "'inventory'", "'_NON_NV_DATA_MAP'",
>
> + "'struct'", "'union'", "'BOOLEAN'", "'UINT64'", "'UINT32'",
>
> + "'UINT16'", "'UINT8'", "'EFI_STRING_ID'", "'EFI_HII_DATE'",
>
> + "'EFI_HII_TIME'", "'EFI_HII_REF'", "'guid'", "'checkbox'",
> "'endcheckbox'",
>
> + "'numeric'", "'endnumeric'", "'minimum'", "'maximum'", "'step'",
>
> + "'default'", "'password'", "'endpassword'", "'string'", "'endstring'",
>
> + "'minsize'", "'maxsize'", "'encoding'", "'suppressif'", "'disableif'",
>
> + "'hidden'", "'goto'", "'formsetguid'", "'inconsistentif'", "'warningif'",
>
> + "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'",
>
> + "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'",
> "'INTERACTIVE'",
>
> + "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'",
> "'LATE_CHECK'",
>
> + "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'", "'class'",
>
> + "'subclass'", "'classguid'", "'typedef'", "'restore'", "'save'",
>
> + "'defaults'", "'banner'", "'align'", "'left'", "'right'", "'center'",
>
> + "'line'", "'name'", "'varid'", "'question'", "'questionid'",
>
> + "'image'", "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
>
> + "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
>
> + "'attribute'", "'varstore'", "'efivarstore'", "'varsize'",
> "'namevaluevarstore'",
>
> + "'action'", "'config'", "'endaction'", "'refresh'", "'interval'",
>
> + "'varstoredevice'", "'guidop'", "'endguidop'", "'datatype'",
>
> + "'data'", "'modal'", "'NON_DEVICE'", "'DISK_DEVICE'",
> "'VIDEO_DEVICE'",
>
> + "'NETWORK_DEVICE'", "'INPUT_DEVICE'", "'ONBOARD_DEVICE'",
> "'OTHER_DEVICE'",
>
> + "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'", "'FRONT_PAGE'",
>
> + "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'",
> "'DAY_SUPPRESS'",
>
> + "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'", "'SECOND_SUPPRESS'",
>
> + "'STORAGE_NORMAL'", "'STORAGE_TIME'", "'STORAGE_WAKEUP'",
> "'UNIQUE'",
>
> + "'NOEMPTY'", "'cond'", "'find'", "'mid'", "'token'", "'span'",
>
> + "'dup'", "'vareqval'", "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
>
> + "'questionref'", "'ruleref'", "'stringref'", "'pushthis'", "'security'",
>
> + "'get'", "'TRUE'", "'FALSE'", "'ONE'", "'ONES'", "'ZERO'",
> "'UNDEFINED'",
>
> + "'VERSION'", "'length'", "'AND'", "'OR'", "'NOT'", "'set'",
>
> + "'~'", "'boolval'", "'stringval'", "'unintval'", "'toupper'",
>
> + "'tolower'", "'match'", "'match2'", "'catenate'", "'questionrefval'",
>
> + "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
>
> + "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'",
> "'NUMERIC_SIZE_1'",
>
> + "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
>
> + "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'", "'DISPLAY_UINT_HEX'",
>
> + "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'",
> "'FIRST_NON_MATCH'" ]
>
> +
>
> + symbolicNames = [ "<INVALID>",
>
> + "Define", "Include", "FormPkgType", "OpenBrace", "CloseBrace",
>
> + "OpenParen", "CloseParen", "OpenBracket", "CloseBracket", "Dot",
>
> + "Negative", "Colon", "Slash", "Semicolon", "Comma", "Equal",
>
> + "NotEqual", "LessEqual", "Less", "GreaterEqual", "Greater",
>
> + "BitWiseOr", "BitWiseAnd", "DevicePath", "FormSet", "FormSetId",
>
> + "EndFormSet", "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
>
> + "OrderedList", "MaxContainers", "EndList", "EndForm", "Form",
>
> + "FormMap", "MapTitle", "MapGuid", "Subtitle", "EndSubtitle",
>
> + "Help", "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
>
> + "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
>
> + "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
>
> + "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
>
> + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
> "EFI_HII_REF",
>
> + "Uuid", "CheckBox", "EndCheckBox", "Numeric", "EndNumeric",
>
> + "Minimum", "Maximum", "Step", "Default", "Password",
> "EndPassword",
>
> + "String", "EndString", "MinSize", "MaxSize", "Encoding", "SuppressIf",
>
> + "DisableIf", "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
>
> + "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
> "ManufacturingFlag",
>
> + "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag", "InteractiveFlag",
>
> + "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
>
> + "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag",
>
> + "Class", "Subclass", "ClassGuid", "TypeDef", "Restore", "Save",
>
> + "Defaults", "Banner", "Align", "Left", "Right", "Center", "Line",
>
> + "Name", "VarId", "Question", "QuestionId", "Image", "Locked",
>
> + "Rule", "EndRule", "Value", "Read", "Write", "ResetButton",
>
> + "EndResetButton", "DefaultStore", "Attribute", "Varstore",
> "Efivarstore",
>
> + "VarSize", "NameValueVarStore", "Action", "Config", "EndAction",
>
> + "Refresh", "Interval", "VarstoreDevice", "GuidOp", "EndGuidOp",
>
> + "DataType", "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
>
> + "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
>
> + "ClassOnBoardDevice", "ClassOtherDevice",
> "SubclassSetupApplication",
>
> + "SubclassGeneralApplication", "SubclassFrontPage",
> "SubclassSingleUse",
>
> + "YearSupppressFlag", "MonthSuppressFlag", "DaySuppressFlag",
>
> + "HourSupppressFlag", "MinuteSuppressFlag", "SecondSuppressFlag",
>
> + "StorageNormalFlag", "StorageTimeFlag", "StorageWakeUpFlag",
>
> + "UniQueFlag", "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span",
>
> + "Dup", "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
>
> + "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
>
> + "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
> "Undefined",
>
> + "Version", "Length", "AND", "OR", "NOT", "Set", "BitWiseNot",
>
> + "BoolVal", "StringVal", "UnIntVal", "ToUpper", "ToLower", "Match",
>
> + "Match2", "Catenate", "QuestionRefVal", "StringRefVal", "Map",
>
> + "RefreshGuid", "StringToken", "OptionDefault", "OptionDefaultMfg",
>
> + "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour",
> "NumericSizeEight",
>
> + "DisPlayIntDec", "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive",
>
> + "Sensitive", "LastNonMatch", "FirstNonMatch", "Number",
> "StringIdentifier",
>
> + "ComplexDefine", "LineDefinition", "IncludeDefinition",
> "Whitespace",
>
> + "Newline", "LineComment", "Extern" ]
>
> +
>
> + ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
>
> + "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
>
> + "T__14", "T__15", "Define", "Include", "FormPkgType",
>
> + "OpenBrace", "CloseBrace", "OpenParen", "CloseParen",
>
> + "OpenBracket", "CloseBracket", "Dot", "Negative", "Colon",
>
> + "Slash", "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
>
> + "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
>
> + "DevicePath", "FormSet", "FormSetId", "EndFormSet", "Title",
>
> + "FormId", "OneOf", "EndOneOf", "Prompt", "OrderedList",
>
> + "MaxContainers", "EndList", "EndForm", "Form", "FormMap",
>
> + "MapTitle", "MapGuid", "Subtitle", "EndSubtitle", "Help",
>
> + "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
>
> + "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
>
> + "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
>
> + "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
>
> + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
>
> + "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox", "Numeric",
>
> + "EndNumeric", "Minimum", "Maximum", "Step", "Default",
>
> + "Password", "EndPassword", "String", "EndString", "MinSize",
>
> + "MaxSize", "Encoding", "SuppressIf", "DisableIf", "Hidden",
>
> + "Goto", "FormSetGuid", "InconsistentIf", "WarningIf",
>
> + "NoSubmitIf", "EndIf", "Key", "DefaultFlag", "ManufacturingFlag",
>
> + "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag",
> "InteractiveFlag",
>
> + "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
>
> + "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag",
> "RestStyleFlag",
>
> + "Class", "Subclass", "ClassGuid", "TypeDef", "Restore",
>
> + "Save", "Defaults", "Banner", "Align", "Left", "Right",
>
> + "Center", "Line", "Name", "VarId", "Question", "QuestionId",
>
> + "Image", "Locked", "Rule", "EndRule", "Value", "Read",
>
> + "Write", "ResetButton", "EndResetButton", "DefaultStore",
>
> + "Attribute", "Varstore", "Efivarstore", "VarSize",
> "NameValueVarStore",
>
> + "Action", "Config", "EndAction", "Refresh", "Interval",
>
> + "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType", "Data",
>
> + "Modal", "ClassNonDevice", "ClassDiskDevice",
> "ClassVideoDevice",
>
> + "ClassNetworkDevice", "ClassInputDevice",
> "ClassOnBoardDevice",
>
> + "ClassOtherDevice", "SubclassSetupApplication",
> "SubclassGeneralApplication",
>
> + "SubclassFrontPage", "SubclassSingleUse", "YearSupppressFlag",
>
> + "MonthSuppressFlag", "DaySuppressFlag", "HourSupppressFlag",
>
> + "MinuteSuppressFlag", "SecondSuppressFlag",
> "StorageNormalFlag",
>
> + "StorageTimeFlag", "StorageWakeUpFlag", "UniQueFlag",
>
> + "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span", "Dup",
>
> + "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
>
> + "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
>
> + "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
>
> + "Undefined", "Version", "Length", "AND", "OR", "NOT",
>
> + "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
>
> + "ToUpper", "ToLower", "Match", "Match2", "Catenate",
> "QuestionRefVal",
>
> + "StringRefVal", "Map", "RefreshGuid", "StringToken",
> "OptionDefault",
>
> + "OptionDefaultMfg", "NumericSizeOne", "NumericSizeTwo",
>
> + "NumericSizeFour", "NumericSizeEight", "DisPlayIntDec",
>
> + "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive", "Sensitive",
>
> + "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier",
>
> + "ComplexDefine", "LineDefinition", "IncludeDefinition",
>
> + "Whitespace", "Newline", "LineComment", "Extern" ]
>
> +
>
> + grammarFileName = "VfrSyntax.g4"
>
> +
>
> + def __init__(self, input=None, output:TextIO = sys.stdout):
>
> + super().__init__(input, output)
>
> + self.checkVersion("4.7.2")
>
> + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA,
> PredictionContextCache())
>
> + self._actions = None
>
> + self._predicates = None
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> new file mode 100644
> index 0000000000..d5d61a26a9
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> @@ -0,0 +1,20475 @@
> +# 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
>
> +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("\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")
>
> + buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
>
> + buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
>
> + buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
>
> + buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
>
> + buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
>
> + buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
>
> + buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
>
> + buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
>
> + buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
>
> + buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
>
> + buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
>
> + buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
>
> + buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
>
> +
> buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
>
> +
> buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
>
> +
> buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
>
> +
> buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
>
> +
> buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
>
> +
> buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
>
> +
> buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
>
> +
> buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
>
> +
> buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
>
> +
> buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
>
> +
> buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
>
> +
> buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
>
> +
> buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
>
> +
> buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
>
> +
> buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
>
> +
> buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
>
> +
> buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
>
> +
> buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
>
> +
> buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
>
> +
> buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
>
> +
> buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
>
> + buf.write("\t\u00ca\4\u00cb\t\u00cb\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\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\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\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\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("\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\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("\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\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\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\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\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()
>
> +
>
> +
>
> +class VfrSyntaxParser ( Parser ):
>
> +
>
> + grammarFileName = "VfrSyntax.g4"
>
> +
>
> + atn = ATNDeserializer().deserialize(serializedATN())
>
> +
>
> + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
>
> +
>
> + sharedContextCache = PredictionContextCache()
>
> +
>
> + literalNames = [ "<INVALID>", "'show'", "'push'", "'pop'", "'#pragma'",
>
> + "'pack'", "'='", "'IMAGE_TOKEN'", "'HORIZONTAL'",
> "'MULTI_LINE'",
>
> + "'<<'", "'>>'", "'+'", "'*'", "'%'", "'format'", "'?'",
>
> + "'#define'", "'#include'", "'formpkgtype'", "'{'",
>
> + "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
>
> + "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'",
>
> + "'>='", "'>'", "'|'", "'&'", "'devicepath'", "'formset'",
>
> + "'formsetid'", "'endformset'", "'title'", "'formid'",
>
> + "'oneof'", "'endoneof'", "'prompt'", "'orderedlist'",
>
> + "'maxcontainers'", "'endlist'", "'endform'", "'form'",
>
> + "'formmap'", "'maptitle'", "'mapguid'", "'subtitle'",
>
> + "'endsubtitle'", "'help'", "'text'", "'option'", "'flags'",
>
> + "'date'", "'enddate'", "'year'", "'month'", "'day'",
>
> + "'time'", "'endtime'", "'hour'", "'minute'", "'second'",
>
> + "'grayoutif'", "'label'", "'timeout'", "'inventory'",
>
> + "'_NON_NV_DATA_MAP'", "'struct'", "'union'", "'BOOLEAN'",
>
> + "'UINT64'", "'UINT32'", "'UINT16'", "'UINT8'", "'EFI_STRING_ID'",
>
> + "'EFI_HII_DATE'", "'EFI_HII_TIME'", "'EFI_HII_REF'",
>
> + "'guid'", "'checkbox'", "'endcheckbox'", "'numeric'",
>
> + "'endnumeric'", "'minimum'", "'maximum'", "'step'",
>
> + "'default'", "'password'", "'endpassword'", "'string'",
>
> + "'endstring'", "'minsize'", "'maxsize'", "'encoding'",
>
> + "'suppressif'", "'disableif'", "'hidden'", "'goto'",
>
> + "'formsetguid'", "'inconsistentif'", "'warningif'",
>
> + "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'",
> "'MANUFACTURING'",
>
> + "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'",
> "'INTERACTIVE'",
>
> + "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'",
>
> + "'LATE_CHECK'", "'READ_ONLY'", "'OPTIONS_ONLY'",
> "'REST_STYLE'",
>
> + "'class'", "'subclass'", "'classguid'", "'typedef'",
>
> + "'restore'", "'save'", "'defaults'", "'banner'", "'align'",
>
> + "'left'", "'right'", "'center'", "'line'", "'name'",
>
> + "'varid'", "'question'", "'questionid'", "'image'",
>
> + "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
>
> + "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
>
> + "'attribute'", "'varstore'", "'efivarstore'", "'varsize'",
>
> + "'namevaluevarstore'", "'action'", "'config'", "'endaction'",
>
> + "'refresh'", "'interval'", "'varstoredevice'", "'guidop'",
>
> + "'endguidop'", "'datatype'", "'data'", "'modal'", "'NON_DEVICE'",
>
> + "'DISK_DEVICE'", "'VIDEO_DEVICE'", "'NETWORK_DEVICE'",
>
> + "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'",
>
> + "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'",
> "'FRONT_PAGE'",
>
> + "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'",
>
> + "'DAY_SUPPRESS'", "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'",
>
> + "'SECOND_SUPPRESS'", "'STORAGE_NORMAL'",
> "'STORAGE_TIME'",
>
> + "'STORAGE_WAKEUP'", "'UNIQUE'", "'NOEMPTY'", "'cond'",
>
> + "'find'", "'mid'", "'token'", "'span'", "'dup'", "'vareqval'",
>
> + "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
>
> + "'questionref'", "'ruleref'", "'stringref'", "'pushthis'",
>
> + "'security'", "'get'", "'TRUE'", "'FALSE'", "'ONE'",
>
> + "'ONES'", "'ZERO'", "'UNDEFINED'", "'VERSION'", "'length'",
>
> + "'AND'", "'OR'", "'NOT'", "'set'", "'~'", "'boolval'",
>
> + "'stringval'", "'unintval'", "'toupper'", "'tolower'",
>
> + "'match'", "'match2'", "'catenate'", "'questionrefval'",
>
> + "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
>
> + "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'",
> "'NUMERIC_SIZE_1'",
>
> + "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
>
> + "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'",
> "'DISPLAY_UINT_HEX'",
>
> + "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'",
>
> + "'FIRST_NON_MATCH'" ]
>
> +
>
> + symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
>
> + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
>
> + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
>
> + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
>
> + "<INVALID>", "Define", "Include", "FormPkgType", "OpenBrace",
>
> + "CloseBrace", "OpenParen", "CloseParen", "OpenBracket",
>
> + "CloseBracket", "Dot", "Negative", "Colon", "Slash",
>
> + "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
>
> + "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
>
> + "DevicePath", "FormSet", "FormSetId", "EndFormSet",
>
> + "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
>
> + "OrderedList", "MaxContainers", "EndList", "EndForm",
>
> + "Form", "FormMap", "MapTitle", "MapGuid", "Subtitle",
>
> + "EndSubtitle", "Help", "Text", "Option", "FLAGS",
>
> + "Date", "EndDate", "Year", "Month", "Day", "Time",
>
> + "EndTime", "Hour", "Minute", "Second", "GrayOutIf",
>
> + "Label", "Timeout", "Inventory", "NonNvDataMap", "Struct",
>
> + "Union", "Boolean", "Uint64", "Uint32", "Uint16",
>
> + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
>
> + "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox",
>
> + "Numeric", "EndNumeric", "Minimum", "Maximum", "Step",
>
> + "Default", "Password", "EndPassword", "String", "EndString",
>
> + "MinSize", "MaxSize", "Encoding", "SuppressIf", "DisableIf",
>
> + "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
>
> + "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
>
> + "ManufacturingFlag", "CheckBoxDefaultFlag",
> "CheckBoxDefaultMfgFlag",
>
> + "InteractiveFlag", "NVAccessFlag", "ResetRequiredFlag",
>
> + "ReconnectRequiredFlag", "LateCheckFlag", "ReadOnlyFlag",
>
> + "OptionOnlyFlag", "RestStyleFlag", "Class", "Subclass",
>
> + "ClassGuid", "TypeDef", "Restore", "Save", "Defaults",
>
> + "Banner", "Align", "Left", "Right", "Center", "Line",
>
> + "Name", "VarId", "Question", "QuestionId", "Image",
>
> + "Locked", "Rule", "EndRule", "Value", "Read", "Write",
>
> + "ResetButton", "EndResetButton", "DefaultStore", "Attribute",
>
> + "Varstore", "Efivarstore", "VarSize", "NameValueVarStore",
>
> + "Action", "Config", "EndAction", "Refresh", "Interval",
>
> + "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType",
>
> + "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
>
> + "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
>
> + "ClassOnBoardDevice", "ClassOtherDevice",
> "SubclassSetupApplication",
>
> + "SubclassGeneralApplication", "SubclassFrontPage",
>
> + "SubclassSingleUse", "YearSupppressFlag",
> "MonthSuppressFlag",
>
> + "DaySuppressFlag", "HourSupppressFlag",
> "MinuteSuppressFlag",
>
> + "SecondSuppressFlag", "StorageNormalFlag", "StorageTimeFlag",
>
> + "StorageWakeUpFlag", "UniQueFlag", "NoEmptyFlag",
>
> + "Cond", "Find", "Mid", "Tok", "Span", "Dup", "VarEqVal",
>
> + "Var", "IdEqVal", "IdEqId", "IdEqValList", "QuestionRef",
>
> + "RuleRef", "StringRef", "PushThis", "Security", "Get",
>
> + "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
>
> + "Undefined", "Version", "Length", "AND", "OR", "NOT",
>
> + "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
>
> + "ToUpper", "ToLower", "Match", "Match2", "Catenate",
>
> + "QuestionRefVal", "StringRefVal", "Map", "RefreshGuid",
>
> + "StringToken", "OptionDefault", "OptionDefaultMfg",
>
> + "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour",
>
> + "NumericSizeEight", "DisPlayIntDec", "DisPlayUIntDec",
>
> + "DisPlayUIntHex", "Insensitive", "Sensitive", "LastNonMatch",
>
> + "FirstNonMatch", "Number", "StringIdentifier",
> "ComplexDefine",
>
> + "LineDefinition", "IncludeDefinition", "Whitespace",
>
> + "Newline", "LineComment", "Extern" ]
>
> +
>
> + RULE_vfrProgram = 0
>
> + RULE_pragmaPackShowDef = 1
>
> + RULE_pragmaPackStackDef = 2
>
> + RULE_pragmaPackNumber = 3
>
> + RULE_vfrPragmaPackDefinition = 4
>
> + RULE_vfrDataStructDefinition = 5
>
> + RULE_vfrDataUnionDefinition = 6
>
> + RULE_vfrDataStructFields = 7
>
> + RULE_dataStructField64 = 8
>
> + RULE_dataStructField32 = 9
>
> + RULE_dataStructField16 = 10
>
> + RULE_dataStructField8 = 11
>
> + RULE_dataStructFieldBool = 12
>
> + RULE_dataStructFieldString = 13
>
> + RULE_dataStructFieldDate = 14
>
> + RULE_dataStructFieldTime = 15
>
> + RULE_dataStructFieldRef = 16
>
> + RULE_dataStructFieldUser = 17
>
> + RULE_dataStructBitField64 = 18
>
> + RULE_dataStructBitField32 = 19
>
> + RULE_dataStructBitField16 = 20
>
> + RULE_dataStructBitField8 = 21
>
> + RULE_vfrFormSetDefinition = 22
>
> + RULE_classguidDefinition = 23
>
> + RULE_classDefinition = 24
>
> + RULE_validClassNames = 25
>
> + RULE_subclassDefinition = 26
>
> + RULE_vfrFormSetList = 27
>
> + RULE_vfrFormSet = 28
>
> + RULE_vfrStatementDefaultStore = 29
>
> + RULE_vfrStatementVarStoreLinear = 30
>
> + RULE_vfrStatementVarStoreEfi = 31
>
> + RULE_vfrVarStoreEfiAttr = 32
>
> + RULE_vfrStatementVarStoreNameValue = 33
>
> + RULE_vfrStatementDisableIfFormSet = 34
>
> + RULE_vfrStatementSuppressIfFormSet = 35
>
> + RULE_guidSubDefinition = 36
>
> + RULE_guidDefinition = 37
>
> + RULE_getStringId = 38
>
> + RULE_vfrQuestionHeader = 39
>
> + RULE_vfrQuestionBaseInfo = 40
>
> + RULE_vfrStatementHeader = 41
>
> + RULE_questionheaderFlagsField = 42
>
> + RULE_vfrStorageVarId = 43
>
> + RULE_vfrConstantValueField = 44
>
> + RULE_vfrImageTag = 45
>
> + RULE_vfrLockedTag = 46
>
> + RULE_vfrStatementStatTag = 47
>
> + RULE_vfrStatementStatTagList = 48
>
> + RULE_vfrFormDefinition = 49
>
> + RULE_vfrForm = 50
>
> + RULE_vfrFormMapDefinition = 51
>
> + RULE_vfrStatementImage = 52
>
> + RULE_vfrStatementLocked = 53
>
> + RULE_vfrStatementRules = 54
>
> + RULE_vfrStatementStat = 55
>
> + RULE_vfrStatementSubTitle = 56
>
> + RULE_vfrStatementSubTitleComponent = 57
>
> + RULE_vfrSubtitleFlags = 58
>
> + RULE_subtitleFlagsField = 59
>
> + RULE_vfrStatementStaticText = 60
>
> + RULE_staticTextFlagsField = 61
>
> + RULE_vfrStatementCrossReference = 62
>
> + RULE_vfrStatementGoto = 63
>
> + RULE_vfrGotoFlags = 64
>
> + RULE_gotoFlagsField = 65
>
> + RULE_vfrStatementResetButton = 66
>
> + RULE_vfrStatementQuestions = 67
>
> + RULE_vfrStatementQuestionTag = 68
>
> + RULE_vfrStatementInconsistentIf = 69
>
> + RULE_vfrStatementNoSubmitIf = 70
>
> + RULE_vfrStatementDisableIfQuest = 71
>
> + RULE_vfrStatementRefresh = 72
>
> + RULE_vfrStatementVarstoreDevice = 73
>
> + RULE_vfrStatementRefreshEvent = 74
>
> + RULE_vfrStatementWarningIf = 75
>
> + RULE_vfrStatementQuestionTagList = 76
>
> + RULE_vfrStatementQuestionOptionTag = 77
>
> + RULE_flagsField = 78
>
> + RULE_vfrStatementSuppressIfQuest = 79
>
> + RULE_vfrStatementGrayOutIfQuest = 80
>
> + RULE_vfrStatementDefault = 81
>
> + RULE_vfrStatementValue = 82
>
> + RULE_vfrStatementOptions = 83
>
> + RULE_vfrStatementOneOfOption = 84
>
> + RULE_vfrOneOfOptionFlags = 85
>
> + RULE_oneofoptionFlagsField = 86
>
> + RULE_vfrStatementRead = 87
>
> + RULE_vfrStatementWrite = 88
>
> + RULE_vfrStatementQuestionOptionList = 89
>
> + RULE_vfrStatementQuestionOption = 90
>
> + RULE_vfrStatementBooleanType = 91
>
> + RULE_vfrStatementCheckBox = 92
>
> + RULE_vfrCheckBoxFlags = 93
>
> + RULE_checkboxFlagsField = 94
>
> + RULE_vfrStatementAction = 95
>
> + RULE_vfrActionFlags = 96
>
> + RULE_actionFlagsField = 97
>
> + RULE_vfrStatementNumericType = 98
>
> + RULE_vfrStatementNumeric = 99
>
> + RULE_vfrSetMinMaxStep = 100
>
> + RULE_vfrNumericFlags = 101
>
> + RULE_numericFlagsField = 102
>
> + RULE_vfrStatementOneOf = 103
>
> + RULE_vfrOneofFlagsField = 104
>
> + RULE_vfrStatementStringType = 105
>
> + RULE_vfrStatementString = 106
>
> + RULE_vfrStringFlagsField = 107
>
> + RULE_stringFlagsField = 108
>
> + RULE_vfrStatementPassword = 109
>
> + RULE_vfrPasswordFlagsField = 110
>
> + RULE_passwordFlagsField = 111
>
> + RULE_vfrStatementOrderedList = 112
>
> + RULE_vfrOrderedListFlags = 113
>
> + RULE_orderedlistFlagsField = 114
>
> + RULE_vfrStatementDate = 115
>
> + RULE_minMaxDateStepDefault = 116
>
> + RULE_vfrDateFlags = 117
>
> + RULE_dateFlagsField = 118
>
> + RULE_vfrStatementTime = 119
>
> + RULE_minMaxTimeStepDefault = 120
>
> + RULE_vfrTimeFlags = 121
>
> + RULE_timeFlagsField = 122
>
> + RULE_vfrStatementConditional = 123
>
> + RULE_vfrStatementConditionalNew = 124
>
> + RULE_vfrStatementSuppressIfStat = 125
>
> + RULE_vfrStatementGrayOutIfStat = 126
>
> + RULE_vfrStatementStatList = 127
>
> + RULE_vfrStatementStatListOld = 128
>
> + RULE_vfrStatementDisableIfStat = 129
>
> + RULE_vfrStatementgrayoutIfSuppressIf = 130
>
> + RULE_vfrStatementsuppressIfGrayOutIf = 131
>
> + RULE_vfrStatementSuppressIfStatNew = 132
>
> + RULE_vfrStatementGrayOutIfStatNew = 133
>
> + RULE_vfrStatementInconsistentIfStat = 134
>
> + RULE_vfrStatementInvalid = 135
>
> + RULE_vfrStatementInvalidHidden = 136
>
> + RULE_vfrStatementInvalidInventory = 137
>
> + RULE_vfrStatementInvalidSaveRestoreDefaults = 138
>
> + RULE_vfrStatementLabel = 139
>
> + RULE_vfrStatementBanner = 140
>
> + RULE_vfrStatementExtension = 141
>
> + RULE_vfrExtensionData = 142
>
> + RULE_vfrStatementModal = 143
>
> + RULE_vfrModalTag = 144
>
> + RULE_vfrStatementExpression = 145
>
> + RULE_vfrStatementExpressionSub = 146
>
> + RULE_andTerm = 147
>
> + RULE_bitwiseorTerm = 148
>
> + RULE_bitwiseandTerm = 149
>
> + RULE_equalTerm = 150
>
> + RULE_equalTermSupplementary = 151
>
> + RULE_compareTerm = 152
>
> + RULE_compareTermSupplementary = 153
>
> + RULE_shiftTerm = 154
>
> + RULE_shiftTermSupplementary = 155
>
> + RULE_addMinusTerm = 156
>
> + RULE_addMinusTermSupplementary = 157
>
> + RULE_multdivmodTerm = 158
>
> + RULE_multdivmodTermSupplementary = 159
>
> + RULE_castTerm = 160
>
> + RULE_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",
>
> + "vfrDataUnionDefinition", "vfrDataStructFields",
> "dataStructField64",
>
> + "dataStructField32", "dataStructField16", "dataStructField8",
>
> + "dataStructFieldBool", "dataStructFieldString",
> "dataStructFieldDate",
>
> + "dataStructFieldTime", "dataStructFieldRef",
> "dataStructFieldUser",
>
> + "dataStructBitField64", "dataStructBitField32",
> "dataStructBitField16",
>
> + "dataStructBitField8", "vfrFormSetDefinition",
> "classguidDefinition",
>
> + "classDefinition", "validClassNames", "subclassDefinition",
>
> + "vfrFormSetList", "vfrFormSet", "vfrStatementDefaultStore",
>
> + "vfrStatementVarStoreLinear", "vfrStatementVarStoreEfi",
>
> + "vfrVarStoreEfiAttr", "vfrStatementVarStoreNameValue",
>
> + "vfrStatementDisableIfFormSet",
> "vfrStatementSuppressIfFormSet",
>
> + "guidSubDefinition", "guidDefinition", "getStringId",
>
> + "vfrQuestionHeader", "vfrQuestionBaseInfo",
> "vfrStatementHeader",
>
> + "questionheaderFlagsField", "vfrStorageVarId",
> "vfrConstantValueField",
>
> + "vfrImageTag", "vfrLockedTag", "vfrStatementStatTag",
>
> + "vfrStatementStatTagList", "vfrFormDefinition", "vfrForm",
>
> + "vfrFormMapDefinition", "vfrStatementImage",
> "vfrStatementLocked",
>
> + "vfrStatementRules", "vfrStatementStat", "vfrStatementSubTitle",
>
> + "vfrStatementSubTitleComponent", "vfrSubtitleFlags",
>
> + "subtitleFlagsField", "vfrStatementStaticText",
> "staticTextFlagsField",
>
> + "vfrStatementCrossReference", "vfrStatementGoto",
> "vfrGotoFlags",
>
> + "gotoFlagsField", "vfrStatementResetButton",
> "vfrStatementQuestions",
>
> + "vfrStatementQuestionTag", "vfrStatementInconsistentIf",
>
> + "vfrStatementNoSubmitIf", "vfrStatementDisableIfQuest",
>
> + "vfrStatementRefresh", "vfrStatementVarstoreDevice",
>
> + "vfrStatementRefreshEvent", "vfrStatementWarningIf",
>
> + "vfrStatementQuestionTagList",
> "vfrStatementQuestionOptionTag",
>
> + "flagsField", "vfrStatementSuppressIfQuest",
> "vfrStatementGrayOutIfQuest",
>
> + "vfrStatementDefault", "vfrStatementValue",
> "vfrStatementOptions",
>
> + "vfrStatementOneOfOption", "vfrOneOfOptionFlags",
> "oneofoptionFlagsField",
>
> + "vfrStatementRead", "vfrStatementWrite",
> "vfrStatementQuestionOptionList",
>
> + "vfrStatementQuestionOption", "vfrStatementBooleanType",
>
> + "vfrStatementCheckBox", "vfrCheckBoxFlags",
> "checkboxFlagsField",
>
> + "vfrStatementAction", "vfrActionFlags", "actionFlagsField",
>
> + "vfrStatementNumericType", "vfrStatementNumeric",
> "vfrSetMinMaxStep",
>
> + "vfrNumericFlags", "numericFlagsField", "vfrStatementOneOf",
>
> + "vfrOneofFlagsField", "vfrStatementStringType",
> "vfrStatementString",
>
> + "vfrStringFlagsField", "stringFlagsField", "vfrStatementPassword",
>
> + "vfrPasswordFlagsField", "passwordFlagsField",
> "vfrStatementOrderedList",
>
> + "vfrOrderedListFlags", "orderedlistFlagsField", "vfrStatementDate",
>
> + "minMaxDateStepDefault", "vfrDateFlags", "dateFlagsField",
>
> + "vfrStatementTime", "minMaxTimeStepDefault", "vfrTimeFlags",
>
> + "timeFlagsField", "vfrStatementConditional",
> "vfrStatementConditionalNew",
>
> + "vfrStatementSuppressIfStat", "vfrStatementGrayOutIfStat",
>
> + "vfrStatementStatList", "vfrStatementStatListOld",
> "vfrStatementDisableIfStat",
>
> + "vfrStatementgrayoutIfSuppressIf",
> "vfrStatementsuppressIfGrayOutIf",
>
> + "vfrStatementSuppressIfStatNew",
> "vfrStatementGrayOutIfStatNew",
>
> + "vfrStatementInconsistentIfStat", "vfrStatementInvalid",
>
> + "vfrStatementInvalidHidden", "vfrStatementInvalidInventory",
>
> + "vfrStatementInvalidSaveRestoreDefaults", "vfrStatementLabel",
>
> + "vfrStatementBanner", "vfrStatementExtension",
> "vfrExtensionData",
>
> + "vfrStatementModal", "vfrModalTag", "vfrStatementExpression",
>
> + "vfrStatementExpressionSub", "andTerm", "bitwiseorTerm",
>
> + "bitwiseandTerm", "equalTerm", "equalTermSupplementary",
>
> + "compareTerm", "compareTermSupplementary", "shiftTerm",
>
> + "shiftTermSupplementary", "addMinusTerm",
> "addMinusTermSupplementary",
>
> + "multdivmodTerm", "multdivmodTermSupplementary",
> "castTerm",
>
> + "castTermSub", "atomTerm", "vfrExpressionCatenate",
> "vfrExpressionMatch",
>
> + "vfrExpressionMatch2", "vfrExpressionParen",
> "vfrExpressionBuildInFunction",
>
> + "dupExp", "vareqvalExp", "ideqvalExp", "ideqidExp",
> "ideqvallistExp",
>
> + "vfrQuestionDataFieldName", "arrayName", "questionref1Exp",
>
> + "rulerefExp", "stringref1Exp", "pushthisExp", "securityExp",
>
> + "numericVarStoreType", "getExp", "vfrExpressionConstant",
>
> + "vfrExpressionUnaryOp", "lengthExp", "bitwisenotExp",
>
> + "question23refExp", "stringref2Exp", "toboolExp", "tostringExp",
>
> + "unintExp", "toupperExp", "tolwerExp", "setExp",
> "vfrExpressionTernaryOp",
>
> + "conditionalExp", "findExp", "findFormat", "midExp",
>
> + "tokenExp", "spanExp", "spanFlags", "vfrExpressionMap" ]
>
> +
>
> + EOF = Token.EOF
>
> + T__0=1
>
> + T__1=2
>
> + T__2=3
>
> + T__3=4
>
> + T__4=5
>
> + T__5=6
>
> + T__6=7
>
> + T__7=8
>
> + T__8=9
>
> + T__9=10
>
> + T__10=11
>
> + T__11=12
>
> + T__12=13
>
> + T__13=14
>
> + T__14=15
>
> + T__15=16
>
> + Define=17
>
> + Include=18
>
> + FormPkgType=19
>
> + OpenBrace=20
>
> + CloseBrace=21
>
> + OpenParen=22
>
> + CloseParen=23
>
> + OpenBracket=24
>
> + CloseBracket=25
>
> + Dot=26
>
> + Negative=27
>
> + Colon=28
>
> + Slash=29
>
> + Semicolon=30
>
> + Comma=31
>
> + Equal=32
>
> + NotEqual=33
>
> + LessEqual=34
>
> + Less=35
>
> + GreaterEqual=36
>
> + Greater=37
>
> + BitWiseOr=38
>
> + BitWiseAnd=39
>
> + DevicePath=40
>
> + FormSet=41
>
> + FormSetId=42
>
> + EndFormSet=43
>
> + Title=44
>
> + FormId=45
>
> + OneOf=46
>
> + EndOneOf=47
>
> + Prompt=48
>
> + OrderedList=49
>
> + MaxContainers=50
>
> + EndList=51
>
> + EndForm=52
>
> + Form=53
>
> + FormMap=54
>
> + MapTitle=55
>
> + MapGuid=56
>
> + Subtitle=57
>
> + EndSubtitle=58
>
> + Help=59
>
> + Text=60
>
> + Option=61
>
> + FLAGS=62
>
> + Date=63
>
> + EndDate=64
>
> + Year=65
>
> + Month=66
>
> + Day=67
>
> + Time=68
>
> + EndTime=69
>
> + Hour=70
>
> + Minute=71
>
> + Second=72
>
> + GrayOutIf=73
>
> + Label=74
>
> + Timeout=75
>
> + Inventory=76
>
> + NonNvDataMap=77
>
> + Struct=78
>
> + Union=79
>
> + Boolean=80
>
> + Uint64=81
>
> + Uint32=82
>
> + Uint16=83
>
> + Uint8=84
>
> + EFI_STRING_ID=85
>
> + EFI_HII_DATE=86
>
> + EFI_HII_TIME=87
>
> + EFI_HII_REF=88
>
> + Uuid=89
>
> + CheckBox=90
>
> + EndCheckBox=91
>
> + Numeric=92
>
> + EndNumeric=93
>
> + Minimum=94
>
> + Maximum=95
>
> + Step=96
>
> + Default=97
>
> + Password=98
>
> + EndPassword=99
>
> + String=100
>
> + EndString=101
>
> + MinSize=102
>
> + MaxSize=103
>
> + Encoding=104
>
> + SuppressIf=105
>
> + DisableIf=106
>
> + Hidden=107
>
> + Goto=108
>
> + FormSetGuid=109
>
> + InconsistentIf=110
>
> + WarningIf=111
>
> + NoSubmitIf=112
>
> + EndIf=113
>
> + Key=114
>
> + DefaultFlag=115
>
> + ManufacturingFlag=116
>
> + CheckBoxDefaultFlag=117
>
> + CheckBoxDefaultMfgFlag=118
>
> + InteractiveFlag=119
>
> + NVAccessFlag=120
>
> + ResetRequiredFlag=121
>
> + ReconnectRequiredFlag=122
>
> + LateCheckFlag=123
>
> + ReadOnlyFlag=124
>
> + OptionOnlyFlag=125
>
> + RestStyleFlag=126
>
> + Class=127
>
> + Subclass=128
>
> + ClassGuid=129
>
> + TypeDef=130
>
> + Restore=131
>
> + Save=132
>
> + Defaults=133
>
> + Banner=134
>
> + Align=135
>
> + Left=136
>
> + Right=137
>
> + Center=138
>
> + Line=139
>
> + Name=140
>
> + VarId=141
>
> + Question=142
>
> + QuestionId=143
>
> + Image=144
>
> + Locked=145
>
> + Rule=146
>
> + EndRule=147
>
> + Value=148
>
> + Read=149
>
> + Write=150
>
> + ResetButton=151
>
> + EndResetButton=152
>
> + DefaultStore=153
>
> + Attribute=154
>
> + Varstore=155
>
> + Efivarstore=156
>
> + VarSize=157
>
> + NameValueVarStore=158
>
> + Action=159
>
> + Config=160
>
> + EndAction=161
>
> + Refresh=162
>
> + Interval=163
>
> + VarstoreDevice=164
>
> + GuidOp=165
>
> + EndGuidOp=166
>
> + DataType=167
>
> + Data=168
>
> + Modal=169
>
> + ClassNonDevice=170
>
> + ClassDiskDevice=171
>
> + ClassVideoDevice=172
>
> + ClassNetworkDevice=173
>
> + ClassInputDevice=174
>
> + ClassOnBoardDevice=175
>
> + ClassOtherDevice=176
>
> + SubclassSetupApplication=177
>
> + SubclassGeneralApplication=178
>
> + SubclassFrontPage=179
>
> + SubclassSingleUse=180
>
> + YearSupppressFlag=181
>
> + MonthSuppressFlag=182
>
> + DaySuppressFlag=183
>
> + HourSupppressFlag=184
>
> + MinuteSuppressFlag=185
>
> + SecondSuppressFlag=186
>
> + StorageNormalFlag=187
>
> + StorageTimeFlag=188
>
> + StorageWakeUpFlag=189
>
> + UniQueFlag=190
>
> + NoEmptyFlag=191
>
> + Cond=192
>
> + Find=193
>
> + Mid=194
>
> + Tok=195
>
> + Span=196
>
> + Dup=197
>
> + VarEqVal=198
>
> + Var=199
>
> + IdEqVal=200
>
> + IdEqId=201
>
> + IdEqValList=202
>
> + QuestionRef=203
>
> + RuleRef=204
>
> + StringRef=205
>
> + PushThis=206
>
> + Security=207
>
> + Get=208
>
> + TrueSymbol=209
>
> + FalseSymbol=210
>
> + One=211
>
> + Ones=212
>
> + Zero=213
>
> + Undefined=214
>
> + Version=215
>
> + Length=216
>
> + AND=217
>
> + OR=218
>
> + NOT=219
>
> + Set=220
>
> + BitWiseNot=221
>
> + BoolVal=222
>
> + StringVal=223
>
> + UnIntVal=224
>
> + ToUpper=225
>
> + ToLower=226
>
> + Match=227
>
> + Match2=228
>
> + Catenate=229
>
> + QuestionRefVal=230
>
> + StringRefVal=231
>
> + Map=232
>
> + RefreshGuid=233
>
> + StringToken=234
>
> + OptionDefault=235
>
> + OptionDefaultMfg=236
>
> + NumericSizeOne=237
>
> + NumericSizeTwo=238
>
> + NumericSizeFour=239
>
> + NumericSizeEight=240
>
> + DisPlayIntDec=241
>
> + DisPlayUIntDec=242
>
> + DisPlayUIntHex=243
>
> + Insensitive=244
>
> + Sensitive=245
>
> + LastNonMatch=246
>
> + FirstNonMatch=247
>
> + Number=248
>
> + StringIdentifier=249
>
> + ComplexDefine=250
>
> + LineDefinition=251
>
> + IncludeDefinition=252
>
> + Whitespace=253
>
> + Newline=254
>
> + LineComment=255
>
> + Extern=256
>
> +
>
> + def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
>
> + super().__init__(input, output)
>
> + self.checkVersion("4.7.2")
>
> + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA,
> self.sharedContextCache)
>
> + self._predicates = None
>
> +
>
> +
>
> +
>
> +
>
> + class VfrProgramContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def vfrPragmaPackDefinition(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrPragmaPackDefinitionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrPragmaPackDefinitionContext,i)
>
> +
>
> +
>
> + def vfrDataStructDefinition(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrDataStructDefinitionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructDefinitionContext,i)
>
> +
>
> +
>
> + def vfrDataUnionDefinition(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrDataUnionDefinitionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrDataUnionDefinitionContext,i)
>
> +
>
> +
>
> + def vfrFormSetDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetDefinitionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrProgram
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrProgram" ):
>
> + return visitor.visitVfrProgram(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrProgram(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrProgramContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 0, self.RULE_vfrProgram)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 409
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 406
>
> + self.vfrPragmaPackDefinition()
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + self.state = 407
>
> + self.vfrDataStructDefinition()
>
> + pass
>
> +
>
> + elif la_ == 3:
>
> + self.state = 408
>
> + self.vfrDataUnionDefinition()
>
> + pass
>
> +
>
> +
>
> + self.state = 413
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + 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)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class PragmaPackShowDefContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_pragmaPackShowDef
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitPragmaPackShowDef" ):
>
> + return visitor.visitPragmaPackShowDef(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def pragmaPackShowDef(self):
>
> +
>
> + localctx = VfrSyntaxParser.PragmaPackShowDefContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 2, self.RULE_pragmaPackShowDef)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 417
>
> + self.match(VfrSyntaxParser.T__0)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class PragmaPackStackDefContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_pragmaPackStackDef
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitPragmaPackStackDef" ):
>
> + return visitor.visitPragmaPackStackDef(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def pragmaPackStackDef(self):
>
> +
>
> + localctx = VfrSyntaxParser.PragmaPackStackDefContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 4, self.RULE_pragmaPackStackDef)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 422
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 420
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 421
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 426
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 424
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 425
>
> + self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class PragmaPackNumberContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_pragmaPackNumber
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitPragmaPackNumber" ):
>
> + return visitor.visitPragmaPackNumber(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def pragmaPackNumber(self):
>
> +
>
> + localctx = VfrSyntaxParser.PragmaPackNumberContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 6, self.RULE_pragmaPackNumber)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 429
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Number:
>
> + self.state = 428
>
> + self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrPragmaPackDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def pragmaPackShowDef(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.PragmaPackShowDefContext,0)
>
> +
>
> +
>
> + def pragmaPackStackDef(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.PragmaPackStackDefContext,0)
>
> +
>
> +
>
> + def pragmaPackNumber(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.PragmaPackNumberContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrPragmaPackDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrPragmaPackDefinition" ):
>
> + return visitor.visitVfrPragmaPackDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrPragmaPackDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrPragmaPackDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 8, self.RULE_vfrPragmaPackDefinition)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 431
>
> + self.match(VfrSyntaxParser.T__3)
>
> + self.state = 432
>
> + self.match(VfrSyntaxParser.T__4)
>
> + self.state = 433
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 437
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 434
>
> + self.pragmaPackShowDef()
>
> +
>
> + elif la_ == 2:
>
> + self.state = 435
>
> + self.pragmaPackStackDef()
>
> +
>
> + elif la_ == 3:
>
> + self.state = 436
>
> + self.pragmaPackNumber()
>
> +
>
> +
>
> + self.state = 439
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrDataStructDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.N1 = None # Token
>
> + self.N2 = None # Token
>
> +
>
> + def Struct(self):
>
> + return self.getToken(VfrSyntaxParser.Struct, 0)
>
> +
>
> + def OpenBrace(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBrace, 0)
>
> +
>
> + def vfrDataStructFields(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
>
> +
>
> +
>
> + def CloseBrace(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBrace, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def TypeDef(self):
>
> + return self.getToken(VfrSyntaxParser.TypeDef, 0)
>
> +
>
> + def NonNvDataMap(self):
>
> + return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrDataStructDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrDataStructDefinition" ):
>
> + return visitor.visitVfrDataStructDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrDataStructDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrDataStructDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 10, self.RULE_vfrDataStructDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 442
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.TypeDef:
>
> + self.state = 441
>
> + self.match(VfrSyntaxParser.TypeDef)
>
> +
>
> +
>
> + self.state = 444
>
> + self.match(VfrSyntaxParser.Struct)
>
> + self.state = 446
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.NonNvDataMap:
>
> + self.state = 445
>
> + self.match(VfrSyntaxParser.NonNvDataMap)
>
> +
>
> +
>
> + self.state = 449
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 448
>
> + localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 451
>
> + self.match(VfrSyntaxParser.OpenBrace)
>
> + self.state = 452
>
> + self.vfrDataStructFields(False)
>
> + self.state = 453
>
> + self.match(VfrSyntaxParser.CloseBrace)
>
> + self.state = 455
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 454
>
> + localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 457
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrDataUnionDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.N1 = None # Token
>
> + self.N2 = None # Token
>
> +
>
> + def Union(self):
>
> + return self.getToken(VfrSyntaxParser.Union, 0)
>
> +
>
> + def OpenBrace(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBrace, 0)
>
> +
>
> + def vfrDataStructFields(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
>
> +
>
> +
>
> + def CloseBrace(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBrace, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def TypeDef(self):
>
> + return self.getToken(VfrSyntaxParser.TypeDef, 0)
>
> +
>
> + def NonNvDataMap(self):
>
> + return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrDataUnionDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrDataUnionDefinition" ):
>
> + return visitor.visitVfrDataUnionDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrDataUnionDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrDataUnionDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 12, self.RULE_vfrDataUnionDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 460
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.TypeDef:
>
> + self.state = 459
>
> + self.match(VfrSyntaxParser.TypeDef)
>
> +
>
> +
>
> + self.state = 462
>
> + self.match(VfrSyntaxParser.Union)
>
> + self.state = 464
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.NonNvDataMap:
>
> + self.state = 463
>
> + self.match(VfrSyntaxParser.NonNvDataMap)
>
> +
>
> +
>
> + self.state = 467
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 466
>
> + localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 469
>
> + self.match(VfrSyntaxParser.OpenBrace)
>
> + self.state = 470
>
> + self.vfrDataStructFields(True)
>
> + self.state = 471
>
> + self.match(VfrSyntaxParser.CloseBrace)
>
> + self.state = 473
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 472
>
> + localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 475
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrDataStructFieldsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def dataStructField64(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructField64Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructField64Context,i)
>
> +
>
> +
>
> + def dataStructField32(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructField32Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructField32Context,i)
>
> +
>
> +
>
> + def dataStructField16(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructField16Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructField16Context,i)
>
> +
>
> +
>
> + def dataStructField8(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructField8Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructField8Context,i)
>
> +
>
> +
>
> + def dataStructFieldBool(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldBoolContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldBoolContext,i)
>
> +
>
> +
>
> + def dataStructFieldString(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldStringContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldStringContext,i)
>
> +
>
> +
>
> + def dataStructFieldDate(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldDateContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldDateContext,i)
>
> +
>
> +
>
> + def dataStructFieldTime(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldTimeContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldTimeContext,i)
>
> +
>
> +
>
> + def dataStructFieldRef(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldRefContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldRefContext,i)
>
> +
>
> +
>
> + def dataStructFieldUser(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldUserContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldUserContext,i)
>
> +
>
> +
>
> + def dataStructBitField64(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField64Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField64Context,i)
>
> +
>
> +
>
> + def dataStructBitField32(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField32Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField32Context,i)
>
> +
>
> +
>
> + def dataStructBitField16(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField16Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField16Context,i)
>
> +
>
> +
>
> + def dataStructBitField8(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField8Context)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField8Context,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrDataStructFields
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrDataStructFields" ):
>
> + return visitor.visitVfrDataStructFields(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrDataStructFields(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.VfrDataStructFieldsContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 14, self.RULE_vfrDataStructFields)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 491
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 477
>
> + self.dataStructField64(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + self.state = 478
>
> + self.dataStructField32(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 3:
>
> + self.state = 479
>
> + self.dataStructField16(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 4:
>
> + self.state = 480
>
> + self.dataStructField8(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 5:
>
> + self.state = 481
>
> + self.dataStructFieldBool(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 6:
>
> + self.state = 482
>
> + self.dataStructFieldString(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 7:
>
> + self.state = 483
>
> + self.dataStructFieldDate(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 8:
>
> + self.state = 484
>
> + self.dataStructFieldTime(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 9:
>
> + self.state = 485
>
> + self.dataStructFieldRef(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 10:
>
> + self.state = 486
>
> + self.dataStructFieldUser(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 11:
>
> + self.state = 487
>
> + self.dataStructBitField64(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 12:
>
> + self.state = 488
>
> + self.dataStructBitField32(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 13:
>
> + self.state = 489
>
> + self.dataStructBitField16(FieldInUnion)
>
> + pass
>
> +
>
> + elif la_ == 14:
>
> + self.state = 490
>
> + self.dataStructBitField8(FieldInUnion)
>
> + pass
>
> +
>
> +
>
> + self.state = 495
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructField64Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Uint64(self):
>
> + return self.getToken(VfrSyntaxParser.Uint64, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructField64
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructField64" ):
>
> + return visitor.visitDataStructField64(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructField64(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructField64Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 16, self.RULE_dataStructField64)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 496
>
> + self.match(VfrSyntaxParser.Uint64)
>
> + self.state = 497
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 501
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 498
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 499
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 500
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 503
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructField32Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Uint32(self):
>
> + return self.getToken(VfrSyntaxParser.Uint32, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructField32
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructField32" ):
>
> + return visitor.visitDataStructField32(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructField32(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructField32Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 18, self.RULE_dataStructField32)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 505
>
> + self.match(VfrSyntaxParser.Uint32)
>
> + self.state = 506
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 510
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 507
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 508
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 509
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 512
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructField16Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Uint16(self):
>
> + return self.getToken(VfrSyntaxParser.Uint16, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructField16
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructField16" ):
>
> + return visitor.visitDataStructField16(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructField16(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructField16Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 20, self.RULE_dataStructField16)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 514
>
> + self.match(VfrSyntaxParser.Uint16)
>
> + self.state = 515
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 519
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 516
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 517
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 518
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 521
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructField8Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Uint8(self):
>
> + return self.getToken(VfrSyntaxParser.Uint8, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructField8
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructField8" ):
>
> + return visitor.visitDataStructField8(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructField8(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructField8Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 22, self.RULE_dataStructField8)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 523
>
> + self.match(VfrSyntaxParser.Uint8)
>
> + self.state = 524
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 528
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 525
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 526
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 527
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 530
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructFieldBoolContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Boolean(self):
>
> + return self.getToken(VfrSyntaxParser.Boolean, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructFieldBool
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructFieldBool" ):
>
> + return visitor.visitDataStructFieldBool(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructFieldBool(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructFieldBoolContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 24, self.RULE_dataStructFieldBool)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 532
>
> + self.match(VfrSyntaxParser.Boolean)
>
> + self.state = 533
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 537
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 534
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 535
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 536
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 539
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructFieldStringContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def EFI_STRING_ID(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructFieldString
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructFieldString" ):
>
> + return visitor.visitDataStructFieldString(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructFieldString(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructFieldStringContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 26, self.RULE_dataStructFieldString)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 541
>
> + self.match(VfrSyntaxParser.EFI_STRING_ID)
>
> + self.state = 542
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 546
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 543
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 544
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 545
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 548
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructFieldDateContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def EFI_HII_DATE(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructFieldDate
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructFieldDate" ):
>
> + return visitor.visitDataStructFieldDate(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructFieldDate(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructFieldDateContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 28, self.RULE_dataStructFieldDate)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 550
>
> + self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> + self.state = 551
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 555
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 552
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 553
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 554
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 557
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructFieldTimeContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def EFI_HII_TIME(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructFieldTime
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructFieldTime" ):
>
> + return visitor.visitDataStructFieldTime(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructFieldTime(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructFieldTimeContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 30, self.RULE_dataStructFieldTime)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 559
>
> + self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> + self.state = 560
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 564
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 561
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 562
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 563
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 566
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructFieldRefContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def EFI_HII_REF(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructFieldRef
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructFieldRef" ):
>
> + return visitor.visitDataStructFieldRef(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructFieldRef(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructFieldRefContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 32, self.RULE_dataStructFieldRef)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 568
>
> + self.match(VfrSyntaxParser.EFI_HII_REF)
>
> + self.state = 569
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 573
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 570
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 571
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 572
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 575
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructFieldUserContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.T = None # Token
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructFieldUser
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructFieldUser" ):
>
> + return visitor.visitDataStructFieldUser(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructFieldUser(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructFieldUserContext(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 34, self.RULE_dataStructFieldUser)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 577
>
> + localctx.T = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 578
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 582
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 579
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 580
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 581
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 584
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructBitField64Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.D = None # Token
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Colon(self):
>
> + return self.getToken(VfrSyntaxParser.Colon, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Uint64(self):
>
> + return self.getToken(VfrSyntaxParser.Uint64, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructBitField64
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructBitField64" ):
>
> + return visitor.visitDataStructBitField64(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructBitField64(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructBitField64Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 36, self.RULE_dataStructBitField64)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 586
>
> + localctx.D = self.match(VfrSyntaxParser.Uint64)
>
> + self.state = 588
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 587
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 590
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 591
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 592
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructBitField32Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.D = None # Token
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Colon(self):
>
> + return self.getToken(VfrSyntaxParser.Colon, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Uint32(self):
>
> + return self.getToken(VfrSyntaxParser.Uint32, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructBitField32
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructBitField32" ):
>
> + return visitor.visitDataStructBitField32(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructBitField32(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructBitField32Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 38, self.RULE_dataStructBitField32)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 594
>
> + localctx.D = self.match(VfrSyntaxParser.Uint32)
>
> + self.state = 596
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 595
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 598
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 599
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 600
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructBitField16Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.D = None # Token
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Colon(self):
>
> + return self.getToken(VfrSyntaxParser.Colon, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Uint16(self):
>
> + return self.getToken(VfrSyntaxParser.Uint16, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructBitField16
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructBitField16" ):
>
> + return visitor.visitDataStructBitField16(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructBitField16(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructBitField16Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 40, self.RULE_dataStructBitField16)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 602
>
> + localctx.D = self.match(VfrSyntaxParser.Uint16)
>
> + self.state = 604
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 603
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 606
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 607
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 608
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DataStructBitField8Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, FieldInUnion=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.FieldInUnion = None
>
> + self.D = None # Token
>
> + self.N = None # Token
>
> + self.FieldInUnion = FieldInUnion
>
> +
>
> + def Colon(self):
>
> + return self.getToken(VfrSyntaxParser.Colon, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Uint8(self):
>
> + return self.getToken(VfrSyntaxParser.Uint8, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dataStructBitField8
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDataStructBitField8" ):
>
> + return visitor.visitDataStructBitField8(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dataStructBitField8(self, FieldInUnion):
>
> +
>
> + localctx = VfrSyntaxParser.DataStructBitField8Context(self, self._ctx,
> self.state, FieldInUnion)
>
> + self.enterRule(localctx, 42, self.RULE_dataStructBitField8)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 610
>
> + localctx.D = self.match(VfrSyntaxParser.Uint8)
>
> + self.state = 612
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.StringIdentifier:
>
> + self.state = 611
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> +
>
> +
>
> + self.state = 614
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 615
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 616
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrFormSetDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_FORM_SET_OP)
>
> +
>
> + def FormSet(self):
>
> + return self.getToken(VfrSyntaxParser.FormSet, 0)
>
> +
>
> + def Uuid(self):
>
> + return self.getToken(VfrSyntaxParser.Uuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Title(self):
>
> + return self.getToken(VfrSyntaxParser.Title, 0)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Help(self):
>
> + return self.getToken(VfrSyntaxParser.Help, 0)
>
> +
>
> + def vfrFormSetList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
>
> +
>
> +
>
> + def EndFormSet(self):
>
> + return self.getToken(VfrSyntaxParser.EndFormSet, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def ClassGuid(self):
>
> + return self.getToken(VfrSyntaxParser.ClassGuid, 0)
>
> +
>
> + def classguidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ClassguidDefinitionContext,0)
>
> +
>
> +
>
> + def Class(self):
>
> + return self.getToken(VfrSyntaxParser.Class, 0)
>
> +
>
> + def classDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ClassDefinitionContext,0)
>
> +
>
> +
>
> + def Subclass(self):
>
> + return self.getToken(VfrSyntaxParser.Subclass, 0)
>
> +
>
> + def subclassDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.SubclassDefinitionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrFormSetDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrFormSetDefinition" ):
>
> + return visitor.visitVfrFormSetDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrFormSetDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrFormSetDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 44, self.RULE_vfrFormSetDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 618
>
> + self.match(VfrSyntaxParser.FormSet)
>
> + self.state = 619
>
> + self.match(VfrSyntaxParser.Uuid)
>
> + self.state = 620
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 621
>
> + self.guidDefinition()
>
> + self.state = 622
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 623
>
> + self.match(VfrSyntaxParser.Title)
>
> + self.state = 624
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 625
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 626
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 627
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 628
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 629
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 630
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 631
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 632
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 633
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 634
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 635
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 636
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 642
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.ClassGuid:
>
> + self.state = 637
>
> + self.match(VfrSyntaxParser.ClassGuid)
>
> + self.state = 638
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 639
>
> + self.classguidDefinition(localctx.Node)
>
> + self.state = 640
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 649
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Class:
>
> + self.state = 644
>
> + self.match(VfrSyntaxParser.Class)
>
> + self.state = 645
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 646
>
> + self.classDefinition()
>
> + self.state = 647
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 656
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Subclass:
>
> + self.state = 651
>
> + self.match(VfrSyntaxParser.Subclass)
>
> + self.state = 652
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 653
>
> + self.subclassDefinition()
>
> + self.state = 654
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 658
>
> + self.vfrFormSetList(localctx.Node)
>
> + self.state = 659
>
> + self.match(VfrSyntaxParser.EndFormSet)
>
> + self.state = 660
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ClassguidDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.GuidList = []
>
> + self.Node = Node
>
> +
>
> + def guidDefinition(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_classguidDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitClassguidDefinition" ):
>
> + return visitor.visitClassguidDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def classguidDefinition(self, Node):
>
> +
>
> + localctx = VfrSyntaxParser.ClassguidDefinitionContext(self, self._ctx,
> self.state, Node)
>
> + self.enterRule(localctx, 46, self.RULE_classguidDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 662
>
> + self.guidDefinition()
>
> + self.state = 665
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 663
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 664
>
> + self.guidDefinition()
>
> +
>
> +
>
> + self.state = 669
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 667
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 668
>
> + self.guidDefinition()
>
> +
>
> +
>
> + self.state = 673
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 671
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 672
>
> + self.guidDefinition()
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ClassDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
> +
>
> + def validClassNames(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.ValidClassNamesContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ValidClassNamesContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_classDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitClassDefinition" ):
>
> + return visitor.visitClassDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def classDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.ClassDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 48, self.RULE_classDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 675
>
> + self.validClassNames()
>
> + self.state = 680
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 676
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 677
>
> + self.validClassNames()
>
> + self.state = 682
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ValidClassNamesContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ClassName = 0
>
> +
>
> + def ClassNonDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassNonDevice, 0)
>
> +
>
> + def ClassDiskDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassDiskDevice, 0)
>
> +
>
> + def ClassVideoDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassVideoDevice, 0)
>
> +
>
> + def ClassNetworkDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassNetworkDevice, 0)
>
> +
>
> + def ClassInputDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassInputDevice, 0)
>
> +
>
> + def ClassOnBoardDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassOnBoardDevice, 0)
>
> +
>
> + def ClassOtherDevice(self):
>
> + return self.getToken(VfrSyntaxParser.ClassOtherDevice, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_validClassNames
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitValidClassNames" ):
>
> + return visitor.visitValidClassNames(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def validClassNames(self):
>
> +
>
> + localctx = VfrSyntaxParser.ValidClassNamesContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 50, self.RULE_validClassNames)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class SubclassDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
> +
>
> + def SubclassSetupApplication(self):
>
> + return self.getToken(VfrSyntaxParser.SubclassSetupApplication, 0)
>
> +
>
> + def SubclassGeneralApplication(self):
>
> + return self.getToken(VfrSyntaxParser.SubclassGeneralApplication, 0)
>
> +
>
> + def SubclassFrontPage(self):
>
> + return self.getToken(VfrSyntaxParser.SubclassFrontPage, 0)
>
> +
>
> + def SubclassSingleUse(self):
>
> + return self.getToken(VfrSyntaxParser.SubclassSingleUse, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_subclassDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitSubclassDefinition" ):
>
> + return visitor.visitSubclassDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def subclassDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.SubclassDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 52, self.RULE_subclassDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrFormSetListContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.Node = Node
>
> +
>
> + def vfrFormSet(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrFormSetContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrFormSetList
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrFormSetList" ):
>
> + return visitor.visitVfrFormSetList(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrFormSetList(self, Node):
>
> +
>
> + localctx = VfrSyntaxParser.VfrFormSetListContext(self, self._ctx, self.state,
> Node)
>
> + self.enterRule(localctx, 54, self.RULE_vfrFormSetList)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 687
>
> + self.vfrFormSet()
>
> + self.state = 692
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrFormSetContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrFormDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormDefinitionContext,0)
>
> +
>
> +
>
> + def vfrFormMapDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormMapDefinitionContext,0)
>
> +
>
> +
>
> + def vfrStatementImage(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
>
> +
>
> +
>
> + def vfrStatementVarStoreLinear(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreLinearContext
> ,0)
>
> +
>
> +
>
> + def vfrStatementVarStoreEfi(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreEfiContext,0)
>
> +
>
> +
>
> + def vfrStatementVarStoreNameValue(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreNameValueCo
> ntext,0)
>
> +
>
> +
>
> + def vfrStatementDefaultStore(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultStoreContext,0)
>
> +
>
> +
>
> + def vfrStatementDisableIfFormSet(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfFormSetCont
> ext,0)
>
> +
>
> +
>
> + def vfrStatementSuppressIfFormSet(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfFormSetCon
> text,0)
>
> +
>
> +
>
> + def vfrStatementExtension(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrFormSet
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrFormSet" ):
>
> + return visitor.visitVfrFormSet(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrFormSet(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrFormSetContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 56, self.RULE_vfrFormSet)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 703
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Form]:
>
> + self.state = 693
>
> + self.vfrFormDefinition()
>
> + pass
>
> + elif token in [VfrSyntaxParser.FormMap]:
>
> + self.state = 694
>
> + self.vfrFormMapDefinition()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Image]:
>
> + self.state = 695
>
> + self.vfrStatementImage()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Varstore]:
>
> + self.state = 696
>
> + self.vfrStatementVarStoreLinear()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Efivarstore]:
>
> + self.state = 697
>
> + self.vfrStatementVarStoreEfi()
>
> + pass
>
> + elif token in [VfrSyntaxParser.NameValueVarStore]:
>
> + self.state = 698
>
> + self.vfrStatementVarStoreNameValue()
>
> + pass
>
> + elif token in [VfrSyntaxParser.DefaultStore]:
>
> + self.state = 699
>
> + self.vfrStatementDefaultStore()
>
> + pass
>
> + elif token in [VfrSyntaxParser.DisableIf]:
>
> + self.state = 700
>
> + self.vfrStatementDisableIfFormSet()
>
> + pass
>
> + elif token in [VfrSyntaxParser.SuppressIf]:
>
> + self.state = 701
>
> + self.vfrStatementSuppressIfFormSet()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GuidOp]:
>
> + self.state = 702
>
> + self.vfrStatementExtension()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementDefaultStoreContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)
>
> + self.N = None # Token
>
> + self.S = None # Token
>
> + self.A = None # Token
>
> +
>
> + def DefaultStore(self):
>
> + return self.getToken(VfrSyntaxParser.DefaultStore, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Attribute(self):
>
> + return self.getToken(VfrSyntaxParser.Attribute, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementDefaultStore
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementDefaultStore" ):
>
> + return visitor.visitVfrStatementDefaultStore(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementDefaultStore(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementDefaultStoreContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 58, self.RULE_vfrStatementDefaultStore)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 705
>
> + self.match(VfrSyntaxParser.DefaultStore)
>
> + self.state = 706
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 707
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 708
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 709
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 710
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 711
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 712
>
> + localctx.S = self.match(VfrSyntaxParser.Number)
>
> + self.state = 713
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 718
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 714
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 715
>
> + self.match(VfrSyntaxParser.Attribute)
>
> + self.state = 716
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 717
>
> + localctx.A = self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + self.state = 720
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementVarStoreLinearContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_OP)
>
> + self.TN = None # Token
>
> + self.ID = None # Token
>
> + self.SN = None # Token
>
> +
>
> + def Varstore(self):
>
> + return self.getToken(VfrSyntaxParser.Varstore, 0)
>
> +
>
> + def Name(self):
>
> + return self.getToken(VfrSyntaxParser.Name, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Uuid(self):
>
> + return self.getToken(VfrSyntaxParser.Uuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def Uint8(self):
>
> + return self.getToken(VfrSyntaxParser.Uint8, 0)
>
> +
>
> + def Uint16(self):
>
> + return self.getToken(VfrSyntaxParser.Uint16, 0)
>
> +
>
> + def Uint32(self):
>
> + return self.getToken(VfrSyntaxParser.Uint32, 0)
>
> +
>
> + def Uint64(self):
>
> + return self.getToken(VfrSyntaxParser.Uint64, 0)
>
> +
>
> + def EFI_HII_DATE(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
>
> +
>
> + def EFI_HII_TIME(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
>
> +
>
> + def EFI_HII_REF(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
>
> +
>
> + def VarId(self):
>
> + return self.getToken(VfrSyntaxParser.VarId, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementVarStoreLinear
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementVarStoreLinear" ):
>
> + return visitor.visitVfrStatementVarStoreLinear(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementVarStoreLinear(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementVarStoreLinearContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 60, self.RULE_vfrStatementVarStoreLinear)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 722
>
> + self.match(VfrSyntaxParser.Varstore)
>
> + self.state = 739
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.StringIdentifier]:
>
> + self.state = 723
>
> + localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 724
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint8]:
>
> + self.state = 725
>
> + self.match(VfrSyntaxParser.Uint8)
>
> + self.state = 726
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint16]:
>
> + self.state = 727
>
> + self.match(VfrSyntaxParser.Uint16)
>
> + self.state = 728
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint32]:
>
> + self.state = 729
>
> + self.match(VfrSyntaxParser.Uint32)
>
> + self.state = 730
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint64]:
>
> + self.state = 731
>
> + self.match(VfrSyntaxParser.Uint64)
>
> + self.state = 732
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_DATE]:
>
> + self.state = 733
>
> + self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> + self.state = 734
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_TIME]:
>
> + self.state = 735
>
> + self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> + self.state = 736
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_REF]:
>
> + self.state = 737
>
> + self.match(VfrSyntaxParser.EFI_HII_REF)
>
> + self.state = 738
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 745
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.VarId:
>
> + self.state = 741
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 742
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 743
>
> + localctx.ID = self.match(VfrSyntaxParser.Number)
>
> + self.state = 744
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 747
>
> + self.match(VfrSyntaxParser.Name)
>
> + self.state = 748
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 749
>
> + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 750
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 751
>
> + self.match(VfrSyntaxParser.Uuid)
>
> + self.state = 752
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 753
>
> + self.guidDefinition()
>
> + self.state = 754
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementVarStoreEfiContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)
>
> + self.TN = None # Token
>
> + self.ID = None # Token
>
> + self.SN = None # Token
>
> + self.VN = None # Token
>
> + self.N = None # Token
>
> +
>
> + def Efivarstore(self):
>
> + return self.getToken(VfrSyntaxParser.Efivarstore, 0)
>
> +
>
> + def Attribute(self):
>
> + return self.getToken(VfrSyntaxParser.Attribute, 0)
>
> +
>
> + def vfrVarStoreEfiAttr(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrVarStoreEfiAttrContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrVarStoreEfiAttrContext,i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Uuid(self):
>
> + return self.getToken(VfrSyntaxParser.Uuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Uint8(self):
>
> + return self.getToken(VfrSyntaxParser.Uint8, 0)
>
> +
>
> + def Uint16(self):
>
> + return self.getToken(VfrSyntaxParser.Uint16, 0)
>
> +
>
> + def Uint32(self):
>
> + return self.getToken(VfrSyntaxParser.Uint32, 0)
>
> +
>
> + def Uint64(self):
>
> + return self.getToken(VfrSyntaxParser.Uint64, 0)
>
> +
>
> + def EFI_HII_DATE(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
>
> +
>
> + def EFI_HII_TIME(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
>
> +
>
> + def EFI_HII_REF(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
>
> +
>
> + def Name(self):
>
> + return self.getToken(VfrSyntaxParser.Name, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def VarSize(self):
>
> + return self.getToken(VfrSyntaxParser.VarSize, 0)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def VarId(self):
>
> + return self.getToken(VfrSyntaxParser.VarId, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementVarStoreEfi
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementVarStoreEfi" ):
>
> + return visitor.visitVfrStatementVarStoreEfi(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementVarStoreEfi(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementVarStoreEfiContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 62, self.RULE_vfrStatementVarStoreEfi)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 756
>
> + self.match(VfrSyntaxParser.Efivarstore)
>
> + self.state = 773
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.StringIdentifier]:
>
> + self.state = 757
>
> + localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 758
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint8]:
>
> + self.state = 759
>
> + self.match(VfrSyntaxParser.Uint8)
>
> + self.state = 760
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint16]:
>
> + self.state = 761
>
> + self.match(VfrSyntaxParser.Uint16)
>
> + self.state = 762
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint32]:
>
> + self.state = 763
>
> + self.match(VfrSyntaxParser.Uint32)
>
> + self.state = 764
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint64]:
>
> + self.state = 765
>
> + self.match(VfrSyntaxParser.Uint64)
>
> + self.state = 766
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_DATE]:
>
> + self.state = 767
>
> + self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> + self.state = 768
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_TIME]:
>
> + self.state = 769
>
> + self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> + self.state = 770
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_REF]:
>
> + self.state = 771
>
> + self.match(VfrSyntaxParser.EFI_HII_REF)
>
> + self.state = 772
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 779
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.VarId:
>
> + self.state = 775
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 776
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 777
>
> + localctx.ID = self.match(VfrSyntaxParser.Number)
>
> + self.state = 778
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 781
>
> + self.match(VfrSyntaxParser.Attribute)
>
> + self.state = 782
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 783
>
> + self.vfrVarStoreEfiAttr()
>
> + self.state = 788
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 784
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 785
>
> + self.vfrVarStoreEfiAttr()
>
> + self.state = 790
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 791
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 807
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 792
>
> + self.match(VfrSyntaxParser.Name)
>
> + self.state = 793
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 794
>
> + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 795
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + self.state = 796
>
> + self.match(VfrSyntaxParser.Name)
>
> + self.state = 797
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 798
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 799
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 800
>
> + localctx.VN = self.match(VfrSyntaxParser.Number)
>
> + self.state = 801
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 802
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 803
>
> + self.match(VfrSyntaxParser.VarSize)
>
> + self.state = 804
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 805
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + self.state = 806
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> +
>
> +
>
> + self.state = 809
>
> + self.match(VfrSyntaxParser.Uuid)
>
> + self.state = 810
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 811
>
> + self.guidDefinition()
>
> + self.state = 812
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrVarStoreEfiAttrContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Attr = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrVarStoreEfiAttr
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrVarStoreEfiAttr" ):
>
> + return visitor.visitVfrVarStoreEfiAttr(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrVarStoreEfiAttr(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrVarStoreEfiAttrContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 64, self.RULE_vfrVarStoreEfiAttr)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 814
>
> + self.match(VfrSyntaxParser.Number)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementVarStoreNameValueContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)
>
> + self.SN = None # Token
>
> + self.ID = None # Token
>
> +
>
> + def NameValueVarStore(self):
>
> + return self.getToken(VfrSyntaxParser.NameValueVarStore, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Uuid(self):
>
> + return self.getToken(VfrSyntaxParser.Uuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def VarId(self):
>
> + return self.getToken(VfrSyntaxParser.VarId, 0)
>
> +
>
> + def Name(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Name)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Name, i)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementVarStoreNameValue
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementVarStoreNameValue" ):
>
> + return visitor.visitVfrStatementVarStoreNameValue(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementVarStoreNameValue(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementVarStoreNameValueContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 66, self.RULE_vfrStatementVarStoreNameValue)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 816
>
> + self.match(VfrSyntaxParser.NameValueVarStore)
>
> + self.state = 817
>
> + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 818
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 823
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.VarId:
>
> + self.state = 819
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 820
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 821
>
> + localctx.ID = self.match(VfrSyntaxParser.Number)
>
> + self.state = 822
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 832
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while True:
>
> + self.state = 825
>
> + self.match(VfrSyntaxParser.Name)
>
> + self.state = 826
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 827
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 828
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 829
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 830
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + 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 = 836
>
> + self.match(VfrSyntaxParser.Uuid)
>
> + self.state = 837
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 838
>
> + self.guidDefinition()
>
> + self.state = 839
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementDisableIfFormSetContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
>
> +
>
> + def DisableIf(self):
>
> + return self.getToken(VfrSyntaxParser.DisableIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def vfrFormSetList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementDisableIfFormSet
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementDisableIfFormSet" ):
>
> + return visitor.visitVfrStatementDisableIfFormSet(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementDisableIfFormSet(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementDisableIfFormSetContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 68, self.RULE_vfrStatementDisableIfFormSet)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 841
>
> + self.match(VfrSyntaxParser.DisableIf)
>
> + self.state = 842
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 843
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 844
>
> + self.vfrFormSetList(localctx.Node)
>
> + self.state = 845
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 846
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementSuppressIfFormSetContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
> +
>
> + def SuppressIf(self):
>
> + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def vfrFormSetList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementSuppressIfFormSet
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementSuppressIfFormSet" ):
>
> + return visitor.visitVfrStatementSuppressIfFormSet(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementSuppressIfFormSet(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementSuppressIfFormSetContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 70, self.RULE_vfrStatementSuppressIfFormSet)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 848
>
> + self.match(VfrSyntaxParser.SuppressIf)
>
> + self.state = 849
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 850
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 851
>
> + self.vfrFormSetList(localctx.Node)
>
> + self.state = 852
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 853
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class GuidSubDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Guid=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Guid = None
>
> + self.Guid = Guid
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_guidSubDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitGuidSubDefinition" ):
>
> + return visitor.visitGuidSubDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def guidSubDefinition(self, Guid):
>
> +
>
> + localctx = VfrSyntaxParser.GuidSubDefinitionContext(self, self._ctx,
> self.state, Guid)
>
> + self.enterRule(localctx, 72, self.RULE_guidSubDefinition)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 855
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 856
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 857
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 858
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 859
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 860
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 861
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 862
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 863
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 864
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 865
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 866
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 867
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 868
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 869
>
> + self.match(VfrSyntaxParser.Number)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class GuidDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode()
>
> + self.Guid = EFI_GUID()
>
> +
>
> + def OpenBrace(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenBrace)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenBrace, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def CloseBrace(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseBrace)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseBrace, i)
>
> +
>
> + def guidSubDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidSubDefinitionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_guidDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitGuidDefinition" ):
>
> + return visitor.visitGuidDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def guidDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.GuidDefinitionContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 74, self.RULE_guidDefinition)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 871
>
> + self.match(VfrSyntaxParser.OpenBrace)
>
> + self.state = 872
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 873
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 874
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 875
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 876
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 877
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 883
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.OpenBrace]:
>
> + self.state = 878
>
> + self.match(VfrSyntaxParser.OpenBrace)
>
> + self.state = 879
>
> + self.guidSubDefinition(localctx.Guid)
>
> + self.state = 880
>
> + self.match(VfrSyntaxParser.CloseBrace)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Number]:
>
> + self.state = 882
>
> + self.guidSubDefinition(localctx.Guid)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 885
>
> + self.match(VfrSyntaxParser.CloseBrace)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class GetStringIdContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.StringId = ''
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_getStringId
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitGetStringId" ):
>
> + return visitor.visitGetStringId(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def getStringId(self):
>
> +
>
> + localctx = VfrSyntaxParser.GetStringIdContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 76, self.RULE_getStringId)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 887
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 888
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 889
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 890
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrQuestionHeaderContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None, QType=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.QType = None
>
> + self.Node = Node
>
> + self.QType = QType
>
> +
>
> + def vfrQuestionBaseInfo(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
>
> +
>
> +
>
> + def vfrStatementHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrQuestionHeader
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrQuestionHeader" ):
>
> + return visitor.visitVfrQuestionHeader(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrQuestionHeader(self, Node, 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 = 892
>
> + self.vfrQuestionBaseInfo(Node, QType)
>
> + self.state = 893
>
> + self.vfrStatementHeader(Node)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrQuestionBaseInfoContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None, QType=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + 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.Node = Node
>
> + self.QType = QType
>
> +
>
> + def Name(self):
>
> + return self.getToken(VfrSyntaxParser.Name, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def VarId(self):
>
> + return self.getToken(VfrSyntaxParser.VarId, 0)
>
> +
>
> + def vfrStorageVarId(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
>
> +
>
> +
>
> + def QuestionId(self):
>
> + return self.getToken(VfrSyntaxParser.QuestionId, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrQuestionBaseInfo
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrQuestionBaseInfo" ):
>
> + return visitor.visitVfrQuestionBaseInfo(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrQuestionBaseInfo(self, Node, 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 = 899
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Name:
>
> + self.state = 895
>
> + self.match(VfrSyntaxParser.Name)
>
> + self.state = 896
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 897
>
> + localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 898
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 906
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.VarId:
>
> + self.state = 901
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 902
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 903
>
> + self.vfrStorageVarId(localctx.BaseInfo, localctx.CheckFlag)
>
> + self.state = 904
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 912
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.QuestionId:
>
> + self.state = 908
>
> + self.match(VfrSyntaxParser.QuestionId)
>
> + self.state = 909
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 910
>
> + localctx.ID = self.match(VfrSyntaxParser.Number)
>
> + self.state = 911
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementHeaderContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.Node = Node
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def Help(self):
>
> + return self.getToken(VfrSyntaxParser.Help, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementHeader
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementHeader" ):
>
> + return visitor.visitVfrStatementHeader(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementHeader(self, Node):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementHeaderContext(self, self._ctx,
> self.state, Node)
>
> + self.enterRule(localctx, 82, self.RULE_vfrStatementHeader)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 914
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 915
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 916
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 917
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 918
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 919
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 920
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 921
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 922
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 923
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 924
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 925
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 926
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class QuestionheaderFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.QHFlag = 0
>
> + self.O = None # Token
>
> + self.N = None # Token
>
> + self.L = None # Token
>
> +
>
> + def ReadOnlyFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ReadOnlyFlag, 0)
>
> +
>
> + def InteractiveFlag(self):
>
> + return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
>
> +
>
> + def ResetRequiredFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
>
> +
>
> + def RestStyleFlag(self):
>
> + return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
>
> +
>
> + def ReconnectRequiredFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
>
> +
>
> + def OptionOnlyFlag(self):
>
> + return self.getToken(VfrSyntaxParser.OptionOnlyFlag, 0)
>
> +
>
> + def NVAccessFlag(self):
>
> + return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
>
> +
>
> + def LateCheckFlag(self):
>
> + return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_questionheaderFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitQuestionheaderFlagsField" ):
>
> + return visitor.visitQuestionheaderFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def questionheaderFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.QuestionheaderFlagsFieldContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 84, self.RULE_questionheaderFlagsField)
>
> + try:
>
> + self.state = 936
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.ReadOnlyFlag]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 928
>
> + self.match(VfrSyntaxParser.ReadOnlyFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.InteractiveFlag]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 929
>
> + self.match(VfrSyntaxParser.InteractiveFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ResetRequiredFlag]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 930
>
> + self.match(VfrSyntaxParser.ResetRequiredFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.RestStyleFlag]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 931
>
> + self.match(VfrSyntaxParser.RestStyleFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 932
>
> + self.match(VfrSyntaxParser.ReconnectRequiredFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.OptionOnlyFlag]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 933
>
> + localctx.O = self.match(VfrSyntaxParser.OptionOnlyFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NVAccessFlag]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 934
>
> + localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.LateCheckFlag]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 935
>
> + localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStorageVarIdContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, BaseInfo=None, CheckFlag=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.BaseInfo = None
>
> + self.CheckFlag = None
>
> + self.VarIdStr = ''
>
> + self.BaseInfo = BaseInfo
>
> + self.CheckFlag = CheckFlag
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStorageVarId
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.BaseInfo = ctx.BaseInfo
>
> + self.CheckFlag = ctx.CheckFlag
>
> + self.VarIdStr = ctx.VarIdStr
>
> +
>
> +
>
> +
>
> + class VfrStorageVarIdRule1Context(VfrStorageVarIdContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.VfrStorageVarIdContext
>
> + super().__init__(parser)
>
> + self.SN1 = None # Token
>
> + self.I = None # Token
>
> + self.copyFrom(ctx)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStorageVarIdRule1" ):
>
> + return visitor.visitVfrStorageVarIdRule1(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class VfrStorageVarIdRule2Context(VfrStorageVarIdContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.VfrStorageVarIdContext
>
> + super().__init__(parser)
>
> + self.SN2 = None # Token
>
> + self.copyFrom(ctx)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> + def Dot(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Dot)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Dot, i)
>
> + def arrayName(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStorageVarIdRule2" ):
>
> + return visitor.visitVfrStorageVarIdRule2(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def vfrStorageVarId(self, BaseInfo, CheckFlag):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStorageVarIdContext(self, self._ctx,
> self.state, BaseInfo, CheckFlag)
>
> + self.enterRule(localctx, 86, self.RULE_vfrStorageVarId)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.state = 950
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
>
> + if la_ == 1:
>
> + localctx = VfrSyntaxParser.VfrStorageVarIdRule1Context(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 938
>
> + localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 939
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 940
>
> + localctx.I = self.match(VfrSyntaxParser.Number)
>
> + self.state = 941
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + localctx = VfrSyntaxParser.VfrStorageVarIdRule2Context(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 942
>
> + localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 947
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.Dot:
>
> + self.state = 943
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 944
>
> + self.arrayName()
>
> + self.state = 949
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + pass
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrConstantValueFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ValueList = []
>
> + self.ListType = False
>
> + self.ValueType = None
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Negative(self):
>
> + return self.getToken(VfrSyntaxParser.Negative, 0)
>
> +
>
> + def TrueSymbol(self):
>
> + return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
>
> +
>
> + def FalseSymbol(self):
>
> + return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
>
> +
>
> + def One(self):
>
> + return self.getToken(VfrSyntaxParser.One, 0)
>
> +
>
> + def Ones(self):
>
> + return self.getToken(VfrSyntaxParser.Ones, 0)
>
> +
>
> + def Zero(self):
>
> + return self.getToken(VfrSyntaxParser.Zero, 0)
>
> +
>
> + def Colon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Colon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Colon, i)
>
> +
>
> + def Slash(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Slash)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Slash, i)
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def OpenBrace(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBrace, 0)
>
> +
>
> + def CloseBrace(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBrace, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrConstantValueField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrConstantValueField" ):
>
> + return visitor.visitVfrConstantValueField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrConstantValueField(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrConstantValueFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 88, self.RULE_vfrConstantValueField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.state = 996
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
>
> + if la_ == 1:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 953
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Negative:
>
> + self.state = 952
>
> + self.match(VfrSyntaxParser.Negative)
>
> +
>
> +
>
> + self.state = 955
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 956
>
> + self.match(VfrSyntaxParser.TrueSymbol)
>
> + pass
>
> +
>
> + elif la_ == 3:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 957
>
> + self.match(VfrSyntaxParser.FalseSymbol)
>
> + pass
>
> +
>
> + elif la_ == 4:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 958
>
> + self.match(VfrSyntaxParser.One)
>
> + pass
>
> +
>
> + elif la_ == 5:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 959
>
> + self.match(VfrSyntaxParser.Ones)
>
> + pass
>
> +
>
> + elif la_ == 6:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 960
>
> + self.match(VfrSyntaxParser.Zero)
>
> + pass
>
> +
>
> + elif la_ == 7:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 961
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 962
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 963
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 964
>
> + self.match(VfrSyntaxParser.Colon)
>
> + self.state = 965
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> +
>
> + elif la_ == 8:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 966
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 967
>
> + self.match(VfrSyntaxParser.Slash)
>
> + self.state = 968
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 969
>
> + self.match(VfrSyntaxParser.Slash)
>
> + self.state = 970
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> +
>
> + elif la_ == 9:
>
> + self.enterOuterAlt(localctx, 9)
>
> + self.state = 971
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 972
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 973
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 974
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 975
>
> + self.guidDefinition()
>
> + self.state = 976
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 977
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 978
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 979
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 980
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + pass
>
> +
>
> + elif la_ == 10:
>
> + self.enterOuterAlt(localctx, 10)
>
> + self.state = 982
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 983
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 984
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 985
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + pass
>
> +
>
> + elif la_ == 11:
>
> + self.enterOuterAlt(localctx, 11)
>
> + self.state = 986
>
> + self.match(VfrSyntaxParser.OpenBrace)
>
> + self.state = 987
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 992
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.Comma:
>
> + self.state = 988
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 989
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 994
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 995
>
> + self.match(VfrSyntaxParser.CloseBrace)
>
> + pass
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrImageTagContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_IMAGE_OP)
>
> +
>
> + def Image(self):
>
> + return self.getToken(VfrSyntaxParser.Image, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrImageTag
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrImageTag" ):
>
> + return visitor.visitVfrImageTag(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrImageTag(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrImageTagContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 90, self.RULE_vfrImageTag)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 998
>
> + self.match(VfrSyntaxParser.Image)
>
> + self.state = 999
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1000
>
> + self.match(VfrSyntaxParser.T__6)
>
> + self.state = 1001
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1002
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1003
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrLockedTagContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_LOCKED_OP)
>
> +
>
> + def Locked(self):
>
> + return self.getToken(VfrSyntaxParser.Locked, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrLockedTag
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrLockedTag" ):
>
> + return visitor.visitVfrLockedTag(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrLockedTag(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrLockedTagContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 92, self.RULE_vfrLockedTag)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1005
>
> + self.match(VfrSyntaxParser.Locked)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStatTagContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrImageTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
>
> +
>
> +
>
> + def vfrLockedTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStatTag
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStatTag" ):
>
> + return visitor.visitVfrStatementStatTag(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStatTag(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStatTagContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 94, self.RULE_vfrStatementStatTag)
>
> + try:
>
> + self.state = 1009
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Image]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1007
>
> + self.vfrImageTag()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Locked]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1008
>
> + self.vfrLockedTag()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStatTagListContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.Node = Node
>
> +
>
> + def vfrStatementStatTag(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatTagContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStatTagList
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStatTagList" ):
>
> + return visitor.visitVfrStatementStatTagList(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStatTagList(self, Node):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStatTagListContext(self, self._ctx,
> self.state, Node)
>
> + self.enterRule(localctx, 96, self.RULE_vfrStatementStatTagList)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1011
>
> + self.vfrStatementStatTag()
>
> + self.state = 1016
>
> + self._errHandler.sync(self)
>
> + _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
>
> + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
>
> + if _alt==1:
>
> + self.state = 1012
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1013
>
> + self.vfrStatementStatTag()
>
> + self.state = 1018
>
> + self._errHandler.sync(self)
>
> + _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrFormDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_FORM_OP)
>
> +
>
> + def Form(self):
>
> + return self.getToken(VfrSyntaxParser.Form, 0)
>
> +
>
> + def FormId(self):
>
> + return self.getToken(VfrSyntaxParser.FormId, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def Title(self):
>
> + return self.getToken(VfrSyntaxParser.Title, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def EndForm(self):
>
> + return self.getToken(VfrSyntaxParser.EndForm, 0)
>
> +
>
> + def vfrForm(self, i:int=None):
>
> + if i is None:
>
> + return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
>
> + else:
>
> + return self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrFormDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrFormDefinition" ):
>
> + return visitor.visitVfrFormDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrFormDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrFormDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 98, self.RULE_vfrFormDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1019
>
> + self.match(VfrSyntaxParser.Form)
>
> + self.state = 1020
>
> + self.match(VfrSyntaxParser.FormId)
>
> + self.state = 1021
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1022
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1023
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1024
>
> + self.match(VfrSyntaxParser.Title)
>
> + self.state = 1025
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1026
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1027
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1028
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1029
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1030
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + 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 = 1031
>
> + self.vfrForm()
>
> + self.state = 1036
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1037
>
> + self.match(VfrSyntaxParser.EndForm)
>
> + self.state = 1038
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrFormContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementImage(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
>
> +
>
> +
>
> + def vfrStatementLocked(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLockedContext,0)
>
> +
>
> +
>
> + def vfrStatementRules(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRulesContext,0)
>
> +
>
> +
>
> + def vfrStatementDefault(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
>
> +
>
> +
>
> + def vfrStatementStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
>
> +
>
> +
>
> + def vfrStatementQuestions(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
>
> +
>
> +
>
> + def vfrStatementConditional(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
>
> +
>
> +
>
> + def vfrStatementLabel(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
>
> +
>
> +
>
> + def vfrStatementBanner(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBannerContext,0)
>
> +
>
> +
>
> + def vfrStatementInvalid(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
>
> +
>
> +
>
> + def vfrStatementExtension(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
>
> +
>
> +
>
> + def vfrStatementModal(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementModalContext,0)
>
> +
>
> +
>
> + def vfrStatementRefreshEvent(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0
> )
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrForm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrForm" ):
>
> + return visitor.visitVfrForm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrForm(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrFormContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 100, self.RULE_vfrForm)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1055
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Image]:
>
> + self.state = 1040
>
> + self.vfrStatementImage()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Locked]:
>
> + self.state = 1041
>
> + self.vfrStatementLocked()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Rule]:
>
> + self.state = 1042
>
> + self.vfrStatementRules()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Default]:
>
> + self.state = 1043
>
> + self.vfrStatementDefault()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text,
> VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
>
> + 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 = 1045
>
> + self.vfrStatementQuestions()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf,
> VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
>
> + self.state = 1046
>
> + self.vfrStatementConditional()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Label]:
>
> + self.state = 1047
>
> + self.vfrStatementLabel()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Banner]:
>
> + self.state = 1048
>
> + self.vfrStatementBanner()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> + self.state = 1049
>
> + self.vfrStatementInvalid()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GuidOp]:
>
> + self.state = 1050
>
> + self.vfrStatementExtension()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Modal]:
>
> + self.state = 1051
>
> + self.vfrStatementModal()
>
> + pass
>
> + elif token in [VfrSyntaxParser.RefreshGuid]:
>
> + self.state = 1052
>
> + self.vfrStatementRefreshEvent()
>
> + self.state = 1053
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrFormMapDefinitionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_FORM_MAP_OP)
>
> + self.S1 = None # Token
>
> +
>
> + def FormMap(self):
>
> + return self.getToken(VfrSyntaxParser.FormMap, 0)
>
> +
>
> + def FormId(self):
>
> + return self.getToken(VfrSyntaxParser.FormId, 0)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def EndForm(self):
>
> + return self.getToken(VfrSyntaxParser.EndForm, 0)
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def MapTitle(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.MapTitle)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.MapTitle, i)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def MapGuid(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.MapGuid)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.MapGuid, i)
>
> +
>
> + def guidDefinition(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
>
> +
>
> +
>
> + def vfrForm(self, i:int=None):
>
> + if i is None:
>
> + return self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
>
> + else:
>
> + return self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrFormMapDefinition
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrFormMapDefinition" ):
>
> + return visitor.visitVfrFormMapDefinition(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrFormMapDefinition(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrFormMapDefinitionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 102, self.RULE_vfrFormMapDefinition)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1057
>
> + self.match(VfrSyntaxParser.FormMap)
>
> + self.state = 1058
>
> + self.match(VfrSyntaxParser.FormId)
>
> + self.state = 1059
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1060
>
> + localctx.S1 = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1061
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1076
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.MapTitle:
>
> + self.state = 1062
>
> + self.match(VfrSyntaxParser.MapTitle)
>
> + self.state = 1063
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1064
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1065
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1066
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1067
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1068
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 1069
>
> + self.match(VfrSyntaxParser.MapGuid)
>
> + self.state = 1070
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1071
>
> + self.guidDefinition()
>
> + self.state = 1072
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 1078
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + 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 = 1079
>
> + self.vfrForm()
>
> + self.state = 1084
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1085
>
> + self.match(VfrSyntaxParser.EndForm)
>
> + self.state = 1086
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementImageContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrImageTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementImage
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementImage" ):
>
> + return visitor.visitVfrStatementImage(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementImage(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementImageContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 104, self.RULE_vfrStatementImage)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1088
>
> + self.vfrImageTag()
>
> + self.state = 1089
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementLockedContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrLockedTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementLocked
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementLocked" ):
>
> + return visitor.visitVfrStatementLocked(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementLocked(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementLockedContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 106, self.RULE_vfrStatementLocked)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1091
>
> + self.vfrLockedTag()
>
> + self.state = 1092
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementRulesContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_RULE_OP)
>
> +
>
> + def Rule(self):
>
> + return self.getToken(VfrSyntaxParser.Rule, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def EndRule(self):
>
> + return self.getToken(VfrSyntaxParser.EndRule, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementRules
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementRules" ):
>
> + return visitor.visitVfrStatementRules(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementRules(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementRulesContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 108, self.RULE_vfrStatementRules)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1094
>
> + self.match(VfrSyntaxParser.Rule)
>
> + self.state = 1095
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1096
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1097
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1098
>
> + self.match(VfrSyntaxParser.EndRule)
>
> + self.state = 1099
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStatContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementSubTitle(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleContext,0)
>
> +
>
> +
>
> + def vfrStatementStaticText(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStaticTextContext,0)
>
> +
>
> +
>
> + def vfrStatementCrossReference(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCrossReferenceContex
> t,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStat
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStat" ):
>
> + return visitor.visitVfrStatementStat(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStat(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStatContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 110, self.RULE_vfrStatementStat)
>
> + try:
>
> + self.state = 1104
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Subtitle]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1101
>
> + self.vfrStatementSubTitle()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Text]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1102
>
> + self.vfrStatementStaticText()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1103
>
> + self.vfrStatementCrossReference()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementSubTitleContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_SUBTITLE_OP)
>
> +
>
> + def Subtitle(self):
>
> + return self.getToken(VfrSyntaxParser.Subtitle, 0)
>
> +
>
> + def Text(self):
>
> + return self.getToken(VfrSyntaxParser.Text, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def EndSubtitle(self):
>
> + return self.getToken(VfrSyntaxParser.EndSubtitle, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def vfrSubtitleFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrSubtitleFlagsContext,0)
>
> +
>
> +
>
> + def vfrStatementStatTagList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
>
> +
>
> +
>
> + def vfrStatementSubTitleComponent(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementSubTitleComponentC
> ontext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleComponentCo
> ntext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementSubTitle
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementSubTitle" ):
>
> + return visitor.visitVfrStatementSubTitle(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementSubTitle(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementSubTitleContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 112, self.RULE_vfrStatementSubTitle)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1106
>
> + self.match(VfrSyntaxParser.Subtitle)
>
> + self.state = 1107
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 1108
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1109
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1110
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1111
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1112
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1117
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1113
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1114
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1115
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1116
>
> + self.vfrSubtitleFlags()
>
> +
>
> +
>
> + self.state = 1139
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1121
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 1119
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1120
>
> + self.vfrStatementStatTagList(localctx.Node)
>
> +
>
> +
>
> + self.state = 1123
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + self.state = 1126
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1124
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1125
>
> + self.vfrStatementStatTagList(localctx.Node)
>
> +
>
> +
>
> + self.state = 1135
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 1128
>
> + self.match(VfrSyntaxParser.Comma)
>
> + 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 = 1129
>
> + self.vfrStatementSubTitleComponent()
>
> + self.state = 1134
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> +
>
> +
>
> + self.state = 1137
>
> + self.match(VfrSyntaxParser.EndSubtitle)
>
> + self.state = 1138
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + pass
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementSubTitleComponentContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
>
> +
>
> +
>
> + def vfrStatementQuestions(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementSubTitleComponent
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementSubTitleComponent" ):
>
> + return visitor.visitVfrStatementSubTitleComponent(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementSubTitleComponent(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementSubTitleComponentContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 114, self.RULE_vfrStatementSubTitleComponent)
>
> + try:
>
> + self.state = 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 = 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 = 1142
>
> + self.vfrStatementQuestions()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrSubtitleFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.SubFlags = 0
>
> +
>
> + def subtitleFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.SubtitleFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.SubtitleFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrSubtitleFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrSubtitleFlags" ):
>
> + return visitor.visitVfrSubtitleFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrSubtitleFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrSubtitleFlagsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 116, self.RULE_vfrSubtitleFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1145
>
> + self.subtitleFlagsField()
>
> + self.state = 1150
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1146
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1147
>
> + self.subtitleFlagsField()
>
> + self.state = 1152
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class SubtitleFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Flag = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_subtitleFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitSubtitleFlagsField" ):
>
> + return visitor.visitSubtitleFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def subtitleFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.SubtitleFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 118, self.RULE_subtitleFlagsField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1153
>
> + _la = self._input.LA(1)
>
> + if not(_la==VfrSyntaxParser.T__7 or _la==VfrSyntaxParser.Number):
>
> + self._errHandler.recoverInline(self)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStaticTextContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_TEXT_OP)
>
> + self.S1 = None # Token
>
> + self.S2 = None # Token
>
> + self.S3 = None # Token
>
> + self.F = None # Token
>
> + self.S4 = None # Token
>
> +
>
> + def Text(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Text)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Text, i)
>
> +
>
> + def Help(self):
>
> + return self.getToken(VfrSyntaxParser.Help, 0)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def staticTextFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.StaticTextFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.StaticTextFlagsFieldContext,i)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def vfrStatementStatTagList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
>
> +
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStaticText
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStaticText" ):
>
> + return visitor.visitVfrStatementStaticText(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStaticText(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStaticTextContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 120, self.RULE_vfrStatementStaticText)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1155
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 1156
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 1157
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1158
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1159
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1160
>
> + localctx.S1 = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1161
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1162
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1163
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 1164
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1165
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1166
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1167
>
> + localctx.S2 = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1168
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1176
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1169
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1170
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 1171
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1172
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1173
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1174
>
> + localctx.S3 = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1175
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> +
>
> +
>
> + self.state = 1194
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1178
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1179
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1180
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1181
>
> + self.staticTextFlagsField()
>
> + self.state = 1186
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1182
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1183
>
> + self.staticTextFlagsField()
>
> + self.state = 1188
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1189
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1190
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1191
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1192
>
> + localctx.S4 = self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + self.state = 1198
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 1196
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1197
>
> + self.vfrStatementStatTagList(localctx.Node)
>
> +
>
> +
>
> + self.state = 1200
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class StaticTextFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Flag = 0
>
> + self.N = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_staticTextFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitStaticTextFlagsField" ):
>
> + return visitor.visitStaticTextFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def staticTextFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.StaticTextFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 122, self.RULE_staticTextFlagsField)
>
> + try:
>
> + self.state = 1204
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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 = 1203
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementCrossReferenceContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementGoto(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGotoContext,0)
>
> +
>
> +
>
> + def vfrStatementResetButton(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementResetButtonContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementCrossReference
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementCrossReference" ):
>
> + return visitor.visitVfrStatementCrossReference(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementCrossReference(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementCrossReferenceContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 124, self.RULE_vfrStatementCrossReference)
>
> + try:
>
> + self.state = 1208
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Goto]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1206
>
> + self.vfrStatementGoto()
>
> + pass
>
> + elif token in [VfrSyntaxParser.ResetButton]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1207
>
> + self.vfrStatementResetButton()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementGotoContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = 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)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def vfrGotoFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrGotoFlagsContext,0)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def DevicePath(self):
>
> + return self.getToken(VfrSyntaxParser.DevicePath, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def FormSetGuid(self):
>
> + return self.getToken(VfrSyntaxParser.FormSetGuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def FormId(self):
>
> + return self.getToken(VfrSyntaxParser.FormId, 0)
>
> +
>
> + def Question(self):
>
> + return self.getToken(VfrSyntaxParser.Question, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementGoto
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementGoto" ):
>
> + return visitor.visitVfrStatementGoto(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementGoto(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementGotoContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 126, self.RULE_vfrStatementGoto)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1210
>
> + self.match(VfrSyntaxParser.Goto)
>
> + self.state = 1258
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.DevicePath]:
>
> + self.state = 1211
>
> + self.match(VfrSyntaxParser.DevicePath)
>
> + self.state = 1212
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1213
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1214
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1215
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1216
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1217
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1218
>
> + self.match(VfrSyntaxParser.FormSetGuid)
>
> + self.state = 1219
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1220
>
> + self.guidDefinition()
>
> + self.state = 1221
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1222
>
> + self.match(VfrSyntaxParser.FormId)
>
> + self.state = 1223
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1224
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1225
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1226
>
> + self.match(VfrSyntaxParser.Question)
>
> + self.state = 1227
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1228
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1229
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.FormSetGuid]:
>
> + self.state = 1231
>
> + self.match(VfrSyntaxParser.FormSetGuid)
>
> + self.state = 1232
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1233
>
> + self.guidDefinition()
>
> + self.state = 1234
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1235
>
> + self.match(VfrSyntaxParser.FormId)
>
> + self.state = 1236
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1237
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1238
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1239
>
> + self.match(VfrSyntaxParser.Question)
>
> + self.state = 1240
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1241
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1242
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.FormId]:
>
> + self.state = 1244
>
> + self.match(VfrSyntaxParser.FormId)
>
> + self.state = 1245
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1246
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1247
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1248
>
> + self.match(VfrSyntaxParser.Question)
>
> + self.state = 1249
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1254
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.StringIdentifier]:
>
> + self.state = 1250
>
> + localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1251
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Number]:
>
> + self.state = 1252
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1253
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.Number]:
>
> + 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 = 1260
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1265
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1261
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1262
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1263
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1264
>
> + self.vfrGotoFlags()
>
> +
>
> +
>
> + self.state = 1271
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1267
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1268
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1269
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1270
>
> + self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + self.state = 1275
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 1273
>
> + localctx.E = self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1274
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> +
>
> +
>
> + self.state = 1277
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrGotoFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.GotoFlags = 0
>
> +
>
> + def gotoFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.GotoFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GotoFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrGotoFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrGotoFlags" ):
>
> + return visitor.visitVfrGotoFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrGotoFlags(self):
>
> +
>
> + 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 = 1279
>
> + self.gotoFlagsField()
>
> + self.state = 1284
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1280
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1281
>
> + self.gotoFlagsField()
>
> + self.state = 1286
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class GotoFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Flag = 0
>
> + self.N = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_gotoFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitGotoFlagsField" ):
>
> + return visitor.visitGotoFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def gotoFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.GotoFlagsFieldContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 130, self.RULE_gotoFlagsField)
>
> + try:
>
> + self.state = 1289
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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 = 1288
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementResetButtonContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_RESET_BUTTON_OP)
>
> + self.N = None # Token
>
> +
>
> + def ResetButton(self):
>
> + return self.getToken(VfrSyntaxParser.ResetButton, 0)
>
> +
>
> + def DefaultStore(self):
>
> + return self.getToken(VfrSyntaxParser.DefaultStore, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
>
> +
>
> +
>
> + def EndResetButton(self):
>
> + return self.getToken(VfrSyntaxParser.EndResetButton, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def vfrStatementStatTagList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementResetButton
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementResetButton" ):
>
> + return visitor.visitVfrStatementResetButton(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementResetButton(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementResetButtonContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 132, self.RULE_vfrStatementResetButton)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1291
>
> + self.match(VfrSyntaxParser.ResetButton)
>
> + self.state = 1292
>
> + self.match(VfrSyntaxParser.DefaultStore)
>
> + self.state = 1293
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1294
>
> + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1295
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1296
>
> + self.vfrStatementHeader(localctx.Node)
>
> + self.state = 1297
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1301
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Image or _la==VfrSyntaxParser.Locked:
>
> + self.state = 1298
>
> + self.vfrStatementStatTagList(localctx.Node)
>
> + self.state = 1299
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1303
>
> + self.match(VfrSyntaxParser.EndResetButton)
>
> + self.state = 1304
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementQuestionsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementBooleanType(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBooleanTypeContext,0
> )
>
> +
>
> +
>
> + def vfrStatementDate(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDateContext,0)
>
> +
>
> +
>
> + def vfrStatementNumericType(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericTypeContext,0
> )
>
> +
>
> +
>
> + def vfrStatementStringType(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringTypeContext,0)
>
> +
>
> +
>
> + def vfrStatementOrderedList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOrderedListContext,0)
>
> +
>
> +
>
> + def vfrStatementTime(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementTimeContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementQuestions
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementQuestions" ):
>
> + return visitor.visitVfrStatementQuestions(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementQuestions(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementQuestionsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 134, self.RULE_vfrStatementQuestions)
>
> + try:
>
> + self.state = 1312
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.CheckBox, VfrSyntaxParser.Action]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1306
>
> + self.vfrStatementBooleanType()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Date]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1307
>
> + self.vfrStatementDate()
>
> + pass
>
> + elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.Numeric]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1308
>
> + self.vfrStatementNumericType()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Password, VfrSyntaxParser.String]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1309
>
> + self.vfrStatementStringType()
>
> + pass
>
> + elif token in [VfrSyntaxParser.OrderedList]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 1310
>
> + self.vfrStatementOrderedList()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Time]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 1311
>
> + self.vfrStatementTime()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementQuestionTagContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementStatTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,0)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def vfrStatementInconsistentIf(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,
> 0)
>
> +
>
> +
>
> + def vfrStatementNoSubmitIf(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNoSubmitIfContext,0)
>
> +
>
> +
>
> + def vfrStatementDisableIfQuest(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfQuestContext
> ,0)
>
> +
>
> +
>
> + def vfrStatementRefresh(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshContext,0)
>
> +
>
> +
>
> + def vfrStatementVarstoreDevice(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarstoreDeviceContext
> ,0)
>
> +
>
> +
>
> + def vfrStatementExtension(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
>
> +
>
> +
>
> + def vfrStatementRefreshEvent(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0
> )
>
> +
>
> +
>
> + def vfrStatementWarningIf(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWarningIfContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementQuestionTag
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementQuestionTag" ):
>
> + return visitor.visitVfrStatementQuestionTag(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementQuestionTag(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementQuestionTagContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 136, self.RULE_vfrStatementQuestionTag)
>
> + try:
>
> + self.state = 1325
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Image, VfrSyntaxParser.Locked]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1314
>
> + self.vfrStatementStatTag()
>
> + self.state = 1315
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.InconsistentIf]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1317
>
> + self.vfrStatementInconsistentIf()
>
> + pass
>
> + elif token in [VfrSyntaxParser.NoSubmitIf]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1318
>
> + self.vfrStatementNoSubmitIf()
>
> + pass
>
> + elif token in [VfrSyntaxParser.DisableIf]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1319
>
> + self.vfrStatementDisableIfQuest()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Refresh]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 1320
>
> + self.vfrStatementRefresh()
>
> + pass
>
> + elif token in [VfrSyntaxParser.VarstoreDevice]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 1321
>
> + self.vfrStatementVarstoreDevice()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GuidOp]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 1322
>
> + self.vfrStatementExtension()
>
> + pass
>
> + elif token in [VfrSyntaxParser.RefreshGuid]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 1323
>
> + self.vfrStatementRefreshEvent()
>
> + pass
>
> + elif token in [VfrSyntaxParser.WarningIf]:
>
> + self.enterOuterAlt(localctx, 9)
>
> + self.state = 1324
>
> + self.vfrStatementWarningIf()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementInconsistentIfContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
>
> +
>
> + def InconsistentIf(self):
>
> + return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementInconsistentIf
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementInconsistentIf" ):
>
> + return visitor.visitVfrStatementInconsistentIf(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementInconsistentIf(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementInconsistentIfContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 138, self.RULE_vfrStatementInconsistentIf)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1327
>
> + self.match(VfrSyntaxParser.InconsistentIf)
>
> + self.state = 1328
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 1329
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1330
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1331
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1332
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1333
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1334
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1347
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1335
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1336
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1337
>
> + self.flagsField()
>
> + self.state = 1342
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1338
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1339
>
> + self.flagsField()
>
> + self.state = 1344
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1345
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + 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,92,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1351
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementNoSubmitIfContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)
>
> +
>
> + def NoSubmitIf(self):
>
> + return self.getToken(VfrSyntaxParser.NoSubmitIf, 0)
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementNoSubmitIf
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementNoSubmitIf" ):
>
> + return visitor.visitVfrStatementNoSubmitIf(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementNoSubmitIf(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementNoSubmitIfContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 140, self.RULE_vfrStatementNoSubmitIf)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1354
>
> + self.match(VfrSyntaxParser.NoSubmitIf)
>
> + self.state = 1355
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 1356
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1357
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1358
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1359
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1360
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1361
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1374
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1362
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1363
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1364
>
> + self.flagsField()
>
> + self.state = 1369
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1365
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1366
>
> + self.flagsField()
>
> + self.state = 1371
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1372
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + 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,95,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1378
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementDisableIfQuestContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
>
> +
>
> + def DisableIf(self):
>
> + return self.getToken(VfrSyntaxParser.DisableIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementDisableIfQuest
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementDisableIfQuest" ):
>
> + return visitor.visitVfrStatementDisableIfQuest(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementDisableIfQuest(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementDisableIfQuestContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 142, self.RULE_vfrStatementDisableIfQuest)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1381
>
> + self.match(VfrSyntaxParser.DisableIf)
>
> + self.state = 1382
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1383
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 1384
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1385
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 1387
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1386
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementRefreshContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_REFRESH_OP)
>
> +
>
> + def Refresh(self):
>
> + return self.getToken(VfrSyntaxParser.Refresh, 0)
>
> +
>
> + def Interval(self):
>
> + return self.getToken(VfrSyntaxParser.Interval, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementRefresh
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementRefresh" ):
>
> + return visitor.visitVfrStatementRefresh(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementRefresh(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementRefreshContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 144, self.RULE_vfrStatementRefresh)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1389
>
> + self.match(VfrSyntaxParser.Refresh)
>
> + self.state = 1390
>
> + self.match(VfrSyntaxParser.Interval)
>
> + self.state = 1391
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1392
>
> + self.match(VfrSyntaxParser.Number)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementVarstoreDeviceContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)
>
> +
>
> + def VarstoreDevice(self):
>
> + return self.getToken(VfrSyntaxParser.VarstoreDevice, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementVarstoreDevice
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementVarstoreDevice" ):
>
> + return visitor.visitVfrStatementVarstoreDevice(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementVarstoreDevice(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementVarstoreDeviceContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 146, self.RULE_vfrStatementVarstoreDevice)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1394
>
> + self.match(VfrSyntaxParser.VarstoreDevice)
>
> + self.state = 1395
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1396
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1397
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1398
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1399
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1400
>
> + self.match(VfrSyntaxParser.Comma)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementRefreshEventContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_REFRESH_ID_OP)
>
> +
>
> + def RefreshGuid(self):
>
> + return self.getToken(VfrSyntaxParser.RefreshGuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementRefreshEvent
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementRefreshEvent" ):
>
> + return visitor.visitVfrStatementRefreshEvent(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementRefreshEvent(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementRefreshEventContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 148, self.RULE_vfrStatementRefreshEvent)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1402
>
> + self.match(VfrSyntaxParser.RefreshGuid)
>
> + self.state = 1403
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1404
>
> + self.guidDefinition()
>
> + self.state = 1405
>
> + self.match(VfrSyntaxParser.Comma)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementWarningIfContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_WARNING_IF_OP)
>
> +
>
> + def WarningIf(self):
>
> + return self.getToken(VfrSyntaxParser.WarningIf, 0)
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def Timeout(self):
>
> + return self.getToken(VfrSyntaxParser.Timeout, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementWarningIf
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementWarningIf" ):
>
> + return visitor.visitVfrStatementWarningIf(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementWarningIf(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementWarningIfContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 150, self.RULE_vfrStatementWarningIf)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1407
>
> + self.match(VfrSyntaxParser.WarningIf)
>
> + self.state = 1408
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 1409
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1410
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1411
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1412
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1413
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1414
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1419
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Timeout:
>
> + self.state = 1415
>
> + self.match(VfrSyntaxParser.Timeout)
>
> + self.state = 1416
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1417
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1418
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + 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,98,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1423
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementQuestionTagListContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.Node = Node
>
> +
>
> + def vfrStatementQuestionTag(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionTagContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementQuestionTagList
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementQuestionTagList" ):
>
> + return visitor.visitVfrStatementQuestionTagList(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementQuestionTagList(self, Node):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementQuestionTagListContext(self,
> self._ctx, self.state, Node)
>
> + self.enterRule(localctx, 152, self.RULE_vfrStatementQuestionTagList)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 1426
>
> + self.vfrStatementQuestionTag()
>
> + self.state = 1431
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementQuestionOptionTagContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementSuppressIfQuest(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfQuestConte
> xt,0)
>
> +
>
> +
>
> + def vfrStatementGrayOutIfQuest(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfQuestContex
> t,0)
>
> +
>
> +
>
> + def vfrStatementValue(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
>
> +
>
> +
>
> + def vfrStatementDefault(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
>
> +
>
> +
>
> + def vfrStatementOptions(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOptionsContext,0)
>
> +
>
> +
>
> + def vfrStatementRead(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementReadContext,0)
>
> +
>
> +
>
> + def vfrStatementWrite(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWriteContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementQuestionOptionTag
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementQuestionOptionTag" ):
>
> + return visitor.visitVfrStatementQuestionOptionTag(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementQuestionOptionTag(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementQuestionOptionTagContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 154, self.RULE_vfrStatementQuestionOptionTag)
>
> + try:
>
> + self.state = 1439
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.SuppressIf]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1432
>
> + self.vfrStatementSuppressIfQuest()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GrayOutIf]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1433
>
> + self.vfrStatementGrayOutIfQuest()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Value]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1434
>
> + self.vfrStatementValue()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Default]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1435
>
> + self.vfrStatementDefault()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Option]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 1436
>
> + self.vfrStatementOptions()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Read]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 1437
>
> + self.vfrStatementRead()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Write]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 1438
>
> + self.vfrStatementWrite()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class FlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.N = None # Token
>
> + self.L = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def InteractiveFlag(self):
>
> + return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
>
> +
>
> + def ManufacturingFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
>
> +
>
> + def DefaultFlag(self):
>
> + return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
>
> +
>
> + def ResetRequiredFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
>
> +
>
> + def ReconnectRequiredFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
>
> +
>
> + def NVAccessFlag(self):
>
> + return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
>
> +
>
> + def LateCheckFlag(self):
>
> + return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_flagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitFlagsField" ):
>
> + return visitor.visitFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def flagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.FlagsFieldContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 156, self.RULE_flagsField)
>
> + try:
>
> + self.state = 1449
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1441
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.InteractiveFlag]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1442
>
> + self.match(VfrSyntaxParser.InteractiveFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ManufacturingFlag]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1443
>
> + self.match(VfrSyntaxParser.ManufacturingFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.DefaultFlag]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1444
>
> + self.match(VfrSyntaxParser.DefaultFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ResetRequiredFlag]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 1445
>
> + self.match(VfrSyntaxParser.ResetRequiredFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 1446
>
> + self.match(VfrSyntaxParser.ReconnectRequiredFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NVAccessFlag]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 1447
>
> + localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.LateCheckFlag]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 1448
>
> + localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementSuppressIfQuestContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
> +
>
> + def SuppressIf(self):
>
> + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementSuppressIfQuest
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementSuppressIfQuest" ):
>
> + return visitor.visitVfrStatementSuppressIfQuest(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementSuppressIfQuest(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementSuppressIfQuestContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 158, self.RULE_vfrStatementSuppressIfQuest)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1451
>
> + self.match(VfrSyntaxParser.SuppressIf)
>
> + self.state = 1452
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1453
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 1466
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1454
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1455
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1456
>
> + self.flagsField()
>
> + self.state = 1461
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1457
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1458
>
> + self.flagsField()
>
> + self.state = 1463
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1464
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1468
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1469
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 1471
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1470
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementGrayOutIfQuestContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
> +
>
> + def GrayOutIf(self):
>
> + return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementGrayOutIfQuest
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementGrayOutIfQuest" ):
>
> + return visitor.visitVfrStatementGrayOutIfQuest(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementGrayOutIfQuest(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementGrayOutIfQuestContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 160, self.RULE_vfrStatementGrayOutIfQuest)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1473
>
> + self.match(VfrSyntaxParser.GrayOutIf)
>
> + self.state = 1474
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1475
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 1488
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1476
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1477
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1478
>
> + self.flagsField()
>
> + self.state = 1483
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1479
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1480
>
> + self.flagsField()
>
> + self.state = 1485
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1486
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1490
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1491
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 1493
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1492
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementDefaultContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = 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 Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrConstantValueField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
>
> +
>
> +
>
> + def vfrStatementValue(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
>
> +
>
> +
>
> + def DefaultStore(self):
>
> + return self.getToken(VfrSyntaxParser.DefaultStore, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementDefault
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementDefault" ):
>
> + return visitor.visitVfrStatementDefault(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementDefault(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementDefaultContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 162, self.RULE_vfrStatementDefault)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1495
>
> + localctx.D = self.match(VfrSyntaxParser.Default)
>
> +
>
> + self.state = 1503
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Value]:
>
> + self.state = 1496
>
> + localctx.V = self.vfrStatementValue()
>
> + self.state = 1497
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + elif token in [VfrSyntaxParser.T__5]:
>
> + self.state = 1499
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1500
>
> + self.vfrConstantValueField()
>
> + self.state = 1501
>
> + self.match(VfrSyntaxParser.Comma)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 1509
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.DefaultStore:
>
> + self.state = 1505
>
> + self.match(VfrSyntaxParser.DefaultStore)
>
> + self.state = 1506
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1507
>
> + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1508
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementValueContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_VALUE_OP)
>
> +
>
> + def Value(self):
>
> + return self.getToken(VfrSyntaxParser.Value, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementValue
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementValue" ):
>
> + return visitor.visitVfrStatementValue(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementValue(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementValueContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 164, self.RULE_vfrStatementValue)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1511
>
> + self.match(VfrSyntaxParser.Value)
>
> + self.state = 1512
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1513
>
> + self.vfrStatementExpression(localctx.Node)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementOptionsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementOneOfOption(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfOptionContext,
> 0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementOptions
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementOptions" ):
>
> + return visitor.visitVfrStatementOptions(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementOptions(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementOptionsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 166, self.RULE_vfrStatementOptions)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1515
>
> + self.vfrStatementOneOfOption()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementOneOfOptionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = 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)
>
> +
>
> + def Text(self):
>
> + return self.getToken(VfrSyntaxParser.Text, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Value(self):
>
> + return self.getToken(VfrSyntaxParser.Value, 0)
>
> +
>
> + def vfrConstantValueField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
>
> +
>
> +
>
> + def vfrOneOfOptionFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrOneOfOptionFlagsContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def vfrImageTag(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrImageTagContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementOneOfOption
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementOneOfOption" ):
>
> + return visitor.visitVfrStatementOneOfOption(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementOneOfOption(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementOneOfOptionContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 168, self.RULE_vfrStatementOneOfOption)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1517
>
> + self.match(VfrSyntaxParser.Option)
>
> + self.state = 1518
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 1519
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1520
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1521
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1522
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1523
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1524
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1525
>
> + self.match(VfrSyntaxParser.Value)
>
> + self.state = 1526
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1527
>
> + self.vfrConstantValueField()
>
> + self.state = 1528
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1529
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1530
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1531
>
> + self.vfrOneOfOptionFlags()
>
> + self.state = 1536
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 1532
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1533
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1534
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1535
>
> + localctx.KN = self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + self.state = 1542
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.Comma:
>
> + self.state = 1538
>
> + localctx.T = self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1539
>
> + self.vfrImageTag()
>
> + self.state = 1544
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 1545
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrOneOfOptionFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> + self.LFlags = 0
>
> +
>
> + def oneofoptionFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.OneofoptionFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.OneofoptionFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrOneOfOptionFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrOneOfOptionFlags" ):
>
> + return visitor.visitVfrOneOfOptionFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrOneOfOptionFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrOneOfOptionFlagsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 170, self.RULE_vfrOneOfOptionFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1547
>
> + self.oneofoptionFlagsField()
>
> + self.state = 1552
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1548
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1549
>
> + self.oneofoptionFlagsField()
>
> + self.state = 1554
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class OneofoptionFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlag = 0
>
> + self.LFlag = 0
>
> + self.A = None # Token
>
> + self.L = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def OptionDefault(self):
>
> + return self.getToken(VfrSyntaxParser.OptionDefault, 0)
>
> +
>
> + def OptionDefaultMfg(self):
>
> + return self.getToken(VfrSyntaxParser.OptionDefaultMfg, 0)
>
> +
>
> + def InteractiveFlag(self):
>
> + return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
>
> +
>
> + def ResetRequiredFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
>
> +
>
> + def RestStyleFlag(self):
>
> + return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
>
> +
>
> + def ReconnectRequiredFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
>
> +
>
> + def ManufacturingFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
>
> +
>
> + def DefaultFlag(self):
>
> + return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
>
> +
>
> + def NVAccessFlag(self):
>
> + return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
>
> +
>
> + def LateCheckFlag(self):
>
> + return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_oneofoptionFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitOneofoptionFlagsField" ):
>
> + return visitor.visitOneofoptionFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def oneofoptionFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.OneofoptionFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 172, self.RULE_oneofoptionFlagsField)
>
> + try:
>
> + self.state = 1566
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1555
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.OptionDefault]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1556
>
> + self.match(VfrSyntaxParser.OptionDefault)
>
> + pass
>
> + elif token in [VfrSyntaxParser.OptionDefaultMfg]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1557
>
> + self.match(VfrSyntaxParser.OptionDefaultMfg)
>
> + pass
>
> + elif token in [VfrSyntaxParser.InteractiveFlag]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1558
>
> + self.match(VfrSyntaxParser.InteractiveFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ResetRequiredFlag]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 1559
>
> + self.match(VfrSyntaxParser.ResetRequiredFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.RestStyleFlag]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 1560
>
> + self.match(VfrSyntaxParser.RestStyleFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 1561
>
> + self.match(VfrSyntaxParser.ReconnectRequiredFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ManufacturingFlag]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 1562
>
> + self.match(VfrSyntaxParser.ManufacturingFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.DefaultFlag]:
>
> + self.enterOuterAlt(localctx, 9)
>
> + self.state = 1563
>
> + self.match(VfrSyntaxParser.DefaultFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NVAccessFlag]:
>
> + self.enterOuterAlt(localctx, 10)
>
> + self.state = 1564
>
> + localctx.A = self.match(VfrSyntaxParser.NVAccessFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.LateCheckFlag]:
>
> + self.enterOuterAlt(localctx, 11)
>
> + self.state = 1565
>
> + localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementReadContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_READ_OP)
>
> +
>
> + def Read(self):
>
> + return self.getToken(VfrSyntaxParser.Read, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementRead
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementRead" ):
>
> + return visitor.visitVfrStatementRead(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementRead(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementReadContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 174, self.RULE_vfrStatementRead)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1568
>
> + self.match(VfrSyntaxParser.Read)
>
> + self.state = 1569
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1570
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementWriteContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_WRITE_OP)
>
> +
>
> + def Write(self):
>
> + return self.getToken(VfrSyntaxParser.Write, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementWrite
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementWrite" ):
>
> + return visitor.visitVfrStatementWrite(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementWrite(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementWriteContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 176, self.RULE_vfrStatementWrite)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1572
>
> + self.match(VfrSyntaxParser.Write)
>
> + self.state = 1573
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 1574
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementQuestionOptionListContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.Node = Node
>
> +
>
> + def vfrStatementQuestionOption(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionOptionConte
> xt)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionContex
> t,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementQuestionOptionList
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementQuestionOptionList" ):
>
> + return visitor.visitVfrStatementQuestionOptionList(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementQuestionOptionList(self, Node):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementQuestionOptionListContext(self,
> self._ctx, self.state, Node)
>
> + self.enterRule(localctx, 178, self.RULE_vfrStatementQuestionOptionList)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 1576
>
> + self.vfrStatementQuestionOption()
>
> + self.state = 1581
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementQuestionOptionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementQuestionTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,0)
>
> +
>
> +
>
> + def vfrStatementQuestionOptionTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionTagCo
> ntext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementQuestionOption
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementQuestionOption" ):
>
> + return visitor.visitVfrStatementQuestionOption(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementQuestionOption(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementQuestionOptionContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 180, self.RULE_vfrStatementQuestionOption)
>
> + try:
>
> + self.state = 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 = 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 = 1583
>
> + self.vfrStatementQuestionOptionTag()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementBooleanTypeContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementCheckBox(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCheckBoxContext,0)
>
> +
>
> +
>
> + def vfrStatementAction(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementActionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementBooleanType
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementBooleanType" ):
>
> + return visitor.visitVfrStatementBooleanType(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementBooleanType(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementBooleanTypeContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 182, self.RULE_vfrStatementBooleanType)
>
> + try:
>
> + self.state = 1588
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.CheckBox]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1586
>
> + self.vfrStatementCheckBox()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Action]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1587
>
> + self.vfrStatementAction()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementCheckBoxContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = 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
>
> +
>
> + def vfrQuestionBaseInfo(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
>
> +
>
> +
>
> + def vfrStatementHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndCheckBox(self):
>
> + return self.getToken(VfrSyntaxParser.EndCheckBox, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def CheckBox(self):
>
> + return self.getToken(VfrSyntaxParser.CheckBox, 0)
>
> +
>
> + def vfrCheckBoxFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrCheckBoxFlagsContext,0)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementCheckBox
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementCheckBox" ):
>
> + return visitor.visitVfrStatementCheckBox(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementCheckBox(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementCheckBoxContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 184, self.RULE_vfrStatementCheckBox)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 1599
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1594
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1595
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1596
>
> + self.vfrCheckBoxFlags()
>
> + self.state = 1597
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1605
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Key:
>
> + self.state = 1601
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1602
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1603
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1604
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1607
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1608
>
> + self.match(VfrSyntaxParser.EndCheckBox)
>
> + self.state = 1609
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrCheckBoxFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.LFlags = 0
>
> + self.HFlags = 0
>
> +
>
> + def checkboxFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.CheckboxFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CheckboxFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrCheckBoxFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrCheckBoxFlags" ):
>
> + return visitor.visitVfrCheckBoxFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrCheckBoxFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrCheckBoxFlagsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 186, self.RULE_vfrCheckBoxFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1611
>
> + self.checkboxFlagsField()
>
> + self.state = 1616
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1612
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1613
>
> + self.checkboxFlagsField()
>
> + self.state = 1618
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class CheckboxFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.LFlag = 0
>
> + self.HFlag = 0
>
> + self.D = None # Token
>
> + self.M = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def DefaultFlag(self):
>
> + return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
>
> +
>
> + def ManufacturingFlag(self):
>
> + return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
>
> +
>
> + def CheckBoxDefaultFlag(self):
>
> + return self.getToken(VfrSyntaxParser.CheckBoxDefaultFlag, 0)
>
> +
>
> + def CheckBoxDefaultMfgFlag(self):
>
> + return self.getToken(VfrSyntaxParser.CheckBoxDefaultMfgFlag, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_checkboxFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCheckboxFlagsField" ):
>
> + return visitor.visitCheckboxFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def checkboxFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.CheckboxFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 188, self.RULE_checkboxFlagsField)
>
> + try:
>
> + self.state = 1625
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1619
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.DefaultFlag]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1620
>
> + localctx.D = self.match(VfrSyntaxParser.DefaultFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ManufacturingFlag]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1621
>
> + localctx.M = self.match(VfrSyntaxParser.ManufacturingFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.CheckBoxDefaultFlag]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1622
>
> + self.match(VfrSyntaxParser.CheckBoxDefaultFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.CheckBoxDefaultMfgFlag]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + 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 = 1624
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementActionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_ACTION_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> +
>
> + def Action(self):
>
> + return self.getToken(VfrSyntaxParser.Action, 0)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Config(self):
>
> + return self.getToken(VfrSyntaxParser.Config, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def vfrStatementQuestionTagList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagListContex
> t,0)
>
> +
>
> +
>
> + def EndAction(self):
>
> + return self.getToken(VfrSyntaxParser.EndAction, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def vfrActionFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrActionFlagsContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementAction
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementAction" ):
>
> + return visitor.visitVfrStatementAction(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementAction(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementActionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 190, self.RULE_vfrStatementAction)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1627
>
> + self.match(VfrSyntaxParser.Action)
>
> + self.state = 1628
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1629
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1635
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1630
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1631
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1632
>
> + self.vfrActionFlags()
>
> + self.state = 1633
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1637
>
> + self.match(VfrSyntaxParser.Config)
>
> + self.state = 1638
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1639
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1640
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1641
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1642
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1643
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1644
>
> + self.vfrStatementQuestionTagList(localctx.Node)
>
> + self.state = 1645
>
> + self.match(VfrSyntaxParser.EndAction)
>
> + self.state = 1646
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrActionFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> +
>
> + def actionFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.ActionFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ActionFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrActionFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrActionFlags" ):
>
> + return visitor.visitVfrActionFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrActionFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrActionFlagsContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 192, self.RULE_vfrActionFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1648
>
> + self.actionFlagsField()
>
> + self.state = 1653
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1649
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1650
>
> + self.actionFlagsField()
>
> + self.state = 1655
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ActionFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlag = 0
>
> + self.N = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_actionFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitActionFlagsField" ):
>
> + return visitor.visitActionFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def actionFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.ActionFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 194, self.RULE_actionFlagsField)
>
> + try:
>
> + self.state = 1658
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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 = 1657
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementNumericTypeContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementNumeric(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericContext,0)
>
> +
>
> +
>
> + def vfrStatementOneOf(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementNumericType
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementNumericType" ):
>
> + return visitor.visitVfrStatementNumericType(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementNumericType(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementNumericTypeContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 196, self.RULE_vfrStatementNumericType)
>
> + try:
>
> + self.state = 1662
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Numeric]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1660
>
> + self.vfrStatementNumeric()
>
> + pass
>
> + elif token in [VfrSyntaxParser.OneOf]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1661
>
> + self.vfrStatementOneOf()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementNumericContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_NUMERIC_OP)
>
> + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> + self.F = None # Token
>
> +
>
> + def Numeric(self):
>
> + return self.getToken(VfrSyntaxParser.Numeric, 0)
>
> +
>
> + def vfrQuestionBaseInfo(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
>
> +
>
> +
>
> + def vfrStatementHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrSetMinMaxStep(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
>
> +
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndNumeric(self):
>
> + return self.getToken(VfrSyntaxParser.EndNumeric, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def vfrNumericFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrNumericFlagsContext,0)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementNumeric
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementNumeric" ):
>
> + return visitor.visitVfrStatementNumeric(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementNumeric(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementNumericContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 198, self.RULE_vfrStatementNumeric)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 1673
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1668
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1669
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1670
>
> + self.vfrNumericFlags()
>
> + self.state = 1671
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1679
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Key:
>
> + self.state = 1675
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1676
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1677
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1678
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1681
>
> + self.vfrSetMinMaxStep(localctx.Node)
>
> + self.state = 1682
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1683
>
> + self.match(VfrSyntaxParser.EndNumeric)
>
> + self.state = 1684
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrSetMinMaxStepContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, Node=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> + self.N1 = None # Token
>
> + self.I = None # Token
>
> + self.N2 = None # Token
>
> + self.A = None # Token
>
> + self.S = None # Token
>
> + self.Node = Node
>
> +
>
> + def Minimum(self):
>
> + return self.getToken(VfrSyntaxParser.Minimum, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Maximum(self):
>
> + return self.getToken(VfrSyntaxParser.Maximum, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Step(self):
>
> + return self.getToken(VfrSyntaxParser.Step, 0)
>
> +
>
> + def Negative(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Negative)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Negative, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrSetMinMaxStep
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrSetMinMaxStep" ):
>
> + return visitor.visitVfrSetMinMaxStep(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrSetMinMaxStep(self, Node):
>
> +
>
> + 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 = 1686
>
> + self.match(VfrSyntaxParser.Minimum)
>
> + self.state = 1687
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1689
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Negative:
>
> + self.state = 1688
>
> + localctx.N1 = self.match(VfrSyntaxParser.Negative)
>
> +
>
> +
>
> + self.state = 1691
>
> + localctx.I = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1692
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1693
>
> + self.match(VfrSyntaxParser.Maximum)
>
> + self.state = 1694
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1696
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Negative:
>
> + self.state = 1695
>
> + localctx.N2 = self.match(VfrSyntaxParser.Negative)
>
> +
>
> +
>
> + self.state = 1698
>
> + localctx.A = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1699
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1704
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Step:
>
> + self.state = 1700
>
> + self.match(VfrSyntaxParser.Step)
>
> + self.state = 1701
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1702
>
> + localctx.S = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1703
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrNumericFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> + self.LFlags = 0
>
> + self.IsDisplaySpecified = False
>
> + self.UpdateVarType = False
>
> +
>
> + def numericFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrNumericFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrNumericFlags" ):
>
> + return visitor.visitVfrNumericFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrNumericFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrNumericFlagsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 202, self.RULE_vfrNumericFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1706
>
> + self.numericFlagsField()
>
> + self.state = 1711
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1707
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1708
>
> + self.numericFlagsField()
>
> + self.state = 1713
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class NumericFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlag = 0
>
> + self.IsSetType = False
>
> + self.IsDisplaySpecified = False
>
> + self.N = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def NumericSizeOne(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
>
> +
>
> + def NumericSizeTwo(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
>
> +
>
> + def NumericSizeFour(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
>
> +
>
> + def NumericSizeEight(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
>
> +
>
> + def DisPlayIntDec(self):
>
> + return self.getToken(VfrSyntaxParser.DisPlayIntDec, 0)
>
> +
>
> + def DisPlayUIntDec(self):
>
> + return self.getToken(VfrSyntaxParser.DisPlayUIntDec, 0)
>
> +
>
> + def DisPlayUIntHex(self):
>
> + return self.getToken(VfrSyntaxParser.DisPlayUIntHex, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_numericFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitNumericFlagsField" ):
>
> + return visitor.visitNumericFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def numericFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.NumericFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 204, self.RULE_numericFlagsField)
>
> + try:
>
> + self.state = 1723
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1714
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NumericSizeOne]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1715
>
> + self.match(VfrSyntaxParser.NumericSizeOne)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NumericSizeTwo]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 1716
>
> + self.match(VfrSyntaxParser.NumericSizeTwo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NumericSizeFour]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 1717
>
> + self.match(VfrSyntaxParser.NumericSizeFour)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NumericSizeEight]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 1718
>
> + self.match(VfrSyntaxParser.NumericSizeEight)
>
> + pass
>
> + elif token in [VfrSyntaxParser.DisPlayIntDec]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 1719
>
> + self.match(VfrSyntaxParser.DisPlayIntDec)
>
> + pass
>
> + elif token in [VfrSyntaxParser.DisPlayUIntDec]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 1720
>
> + self.match(VfrSyntaxParser.DisPlayUIntDec)
>
> + pass
>
> + elif token in [VfrSyntaxParser.DisPlayUIntHex]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + 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 = 1722
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementOneOfContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_ONE_OF_OP)
>
> + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> + self.F = None # Token
>
> +
>
> + def OneOf(self):
>
> + return self.getToken(VfrSyntaxParser.OneOf, 0)
>
> +
>
> + def vfrQuestionBaseInfo(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
>
> +
>
> +
>
> + def vfrStatementHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndOneOf(self):
>
> + return self.getToken(VfrSyntaxParser.EndOneOf, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def vfrOneofFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrOneofFlagsFieldContext,0)
>
> +
>
> +
>
> + def vfrSetMinMaxStep(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
>
> +
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementOneOf
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementOneOf" ):
>
> + return visitor.visitVfrStatementOneOf(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementOneOf(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementOneOfContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 206, self.RULE_vfrStatementOneOf)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 1734
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1729
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1730
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1731
>
> + self.vfrOneofFlagsField()
>
> + self.state = 1732
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1737
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Minimum:
>
> + self.state = 1736
>
> + self.vfrSetMinMaxStep(localctx.Node)
>
> +
>
> +
>
> + self.state = 1739
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1740
>
> + self.match(VfrSyntaxParser.EndOneOf)
>
> + self.state = 1741
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrOneofFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> + self.LFlags = 0
>
> + self.UpdateVarType = False
>
> +
>
> + def numericFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrOneofFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrOneofFlagsField" ):
>
> + return visitor.visitVfrOneofFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrOneofFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrOneofFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 208, self.RULE_vfrOneofFlagsField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1743
>
> + self.numericFlagsField()
>
> + self.state = 1748
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1744
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1745
>
> + self.numericFlagsField()
>
> + self.state = 1750
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStringTypeContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementString(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringContext,0)
>
> +
>
> +
>
> + def vfrStatementPassword(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementPasswordContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStringType
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStringType" ):
>
> + return visitor.visitVfrStatementStringType(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStringType(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStringTypeContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 210, self.RULE_vfrStatementStringType)
>
> + try:
>
> + self.state = 1753
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.String]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1751
>
> + self.vfrStatementString()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Password]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1752
>
> + self.vfrStatementPassword()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStringContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_STRING_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> + self.F = None # Token
>
> + self.Min = None # Token
>
> + self.Max = None # Token
>
> +
>
> + def String(self):
>
> + return self.getToken(VfrSyntaxParser.String, 0)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndString(self):
>
> + return self.getToken(VfrSyntaxParser.EndString, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def MinSize(self):
>
> + return self.getToken(VfrSyntaxParser.MinSize, 0)
>
> +
>
> + def MaxSize(self):
>
> + return self.getToken(VfrSyntaxParser.MaxSize, 0)
>
> +
>
> + def vfrStringFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStringFlagsFieldContext,0)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementString
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementString" ):
>
> + return visitor.visitVfrStatementString(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementString(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStringContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 212, self.RULE_vfrStatementString)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1755
>
> + self.match(VfrSyntaxParser.String)
>
> + self.state = 1756
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1757
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1763
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1758
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1759
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1760
>
> + self.vfrStringFlagsField()
>
> + self.state = 1761
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1769
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Key:
>
> + self.state = 1765
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1766
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1767
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1768
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1771
>
> + localctx.Min = self.match(VfrSyntaxParser.MinSize)
>
> + self.state = 1772
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1773
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1774
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1775
>
> + localctx.Max = self.match(VfrSyntaxParser.MaxSize)
>
> + self.state = 1776
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1777
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1778
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1779
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1780
>
> + self.match(VfrSyntaxParser.EndString)
>
> + self.state = 1781
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStringFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> + self.LFlags = 0
>
> +
>
> + def stringFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.StringFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.StringFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStringFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStringFlagsField" ):
>
> + return visitor.visitVfrStringFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStringFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStringFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 214, self.RULE_vfrStringFlagsField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1783
>
> + self.stringFlagsField()
>
> + self.state = 1788
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1784
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1785
>
> + self.stringFlagsField()
>
> + self.state = 1790
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class StringFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlag = 0
>
> + self.LFlag = 0
>
> + self.N = None # Token
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_stringFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitStringFlagsField" ):
>
> + return visitor.visitStringFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def stringFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.StringFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 216, self.RULE_stringFlagsField)
>
> + try:
>
> + self.state = 1794
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1791
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.T__8]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + 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 = 1793
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementPasswordContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_PASSWORD_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> + self.F = None # Token
>
> + self.Min = None # Token
>
> + self.Max = None # Token
>
> +
>
> + def Password(self):
>
> + return self.getToken(VfrSyntaxParser.Password, 0)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndPassword(self):
>
> + return self.getToken(VfrSyntaxParser.EndPassword, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def MinSize(self):
>
> + return self.getToken(VfrSyntaxParser.MinSize, 0)
>
> +
>
> + def MaxSize(self):
>
> + return self.getToken(VfrSyntaxParser.MaxSize, 0)
>
> +
>
> + def vfrPasswordFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrPasswordFlagsFieldContext,0)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def Encoding(self):
>
> + return self.getToken(VfrSyntaxParser.Encoding, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementPassword
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementPassword" ):
>
> + return visitor.visitVfrStatementPassword(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementPassword(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementPasswordContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 218, self.RULE_vfrStatementPassword)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1796
>
> + self.match(VfrSyntaxParser.Password)
>
> + self.state = 1797
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1798
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1804
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1799
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1800
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1801
>
> + self.vfrPasswordFlagsField()
>
> + self.state = 1802
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1810
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Key:
>
> + self.state = 1806
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 1807
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1808
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1809
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1812
>
> + localctx.Min = self.match(VfrSyntaxParser.MinSize)
>
> + self.state = 1813
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1814
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1815
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1816
>
> + localctx.Max = self.match(VfrSyntaxParser.MaxSize)
>
> + self.state = 1817
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1818
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1819
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1824
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Encoding:
>
> + self.state = 1820
>
> + self.match(VfrSyntaxParser.Encoding)
>
> + self.state = 1821
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1822
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1823
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1826
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1827
>
> + self.match(VfrSyntaxParser.EndPassword)
>
> + self.state = 1828
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrPasswordFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> +
>
> + def passwordFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.PasswordFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.PasswordFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrPasswordFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrPasswordFlagsField" ):
>
> + return visitor.visitVfrPasswordFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrPasswordFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrPasswordFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 220, self.RULE_vfrPasswordFlagsField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1830
>
> + self.passwordFlagsField()
>
> + self.state = 1835
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1831
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1832
>
> + self.passwordFlagsField()
>
> + self.state = 1837
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class PasswordFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlag = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_passwordFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitPasswordFlagsField" ):
>
> + return visitor.visitPasswordFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def passwordFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.PasswordFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 222, self.RULE_passwordFlagsField)
>
> + try:
>
> + self.state = 1840
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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 = 1839
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementOrderedListContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_ORDERED_LIST_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
>
> + self.M = None # Token
>
> + self.F = None # Token
>
> +
>
> + def OrderedList(self):
>
> + return self.getToken(VfrSyntaxParser.OrderedList, 0)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def EndList(self):
>
> + return self.getToken(VfrSyntaxParser.EndList, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def vfrOrderedListFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrOrderedListFlagsContext,0)
>
> +
>
> +
>
> + def MaxContainers(self):
>
> + return self.getToken(VfrSyntaxParser.MaxContainers, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementOrderedList
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementOrderedList" ):
>
> + return visitor.visitVfrStatementOrderedList(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementOrderedList(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementOrderedListContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 224, self.RULE_vfrStatementOrderedList)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1842
>
> + self.match(VfrSyntaxParser.OrderedList)
>
> + self.state = 1843
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1844
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1849
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.MaxContainers:
>
> + self.state = 1845
>
> + localctx.M = self.match(VfrSyntaxParser.MaxContainers)
>
> + self.state = 1846
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1847
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1848
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1856
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1851
>
> + localctx.F = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1852
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1853
>
> + self.vfrOrderedListFlags()
>
> + self.state = 1854
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1858
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + self.state = 1859
>
> + self.match(VfrSyntaxParser.EndList)
>
> + self.state = 1860
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrOrderedListFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlags = 0
>
> + self.LFlags = 0
>
> +
>
> + def orderedlistFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.OrderedlistFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.OrderedlistFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrOrderedListFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrOrderedListFlags" ):
>
> + return visitor.visitVfrOrderedListFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrOrderedListFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrOrderedListFlagsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 226, self.RULE_vfrOrderedListFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1862
>
> + self.orderedlistFlagsField()
>
> + self.state = 1867
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1863
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1864
>
> + self.orderedlistFlagsField()
>
> + self.state = 1869
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class OrderedlistFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.HFlag = 0
>
> + self.LFlag = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def UniQueFlag(self):
>
> + return self.getToken(VfrSyntaxParser.UniQueFlag, 0)
>
> +
>
> + def NoEmptyFlag(self):
>
> + return self.getToken(VfrSyntaxParser.NoEmptyFlag, 0)
>
> +
>
> + def questionheaderFlagsField(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> )
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_orderedlistFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitOrderedlistFlagsField" ):
>
> + return visitor.visitOrderedlistFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def orderedlistFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.OrderedlistFlagsFieldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 228, self.RULE_orderedlistFlagsField)
>
> + try:
>
> + self.state = 1874
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Number]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1870
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.UniQueFlag]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 1871
>
> + self.match(VfrSyntaxParser.UniQueFlag)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NoEmptyFlag]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + 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 = 1873
>
> + self.questionheaderFlagsField()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementDateContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_DATE_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_DATE
>
> + self.Val = EFI_HII_DATE()
>
> + self.F1 = None # Token
>
> + self.F2 = None # Token
>
> +
>
> + def Date(self):
>
> + return self.getToken(VfrSyntaxParser.Date, 0)
>
> +
>
> + def EndDate(self):
>
> + return self.getToken(VfrSyntaxParser.EndDate, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def Year(self):
>
> + return self.getToken(VfrSyntaxParser.Year, 0)
>
> +
>
> + def VarId(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.VarId)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.VarId, i)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def Dot(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Dot)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Dot, i)
>
> +
>
> + def Prompt(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Prompt)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Prompt, i)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Help(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Help)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Help, i)
>
> +
>
> + def minMaxDateStepDefault(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.MinMaxDateStepDefaultContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MinMaxDateStepDefaultContext,i)
>
> +
>
> +
>
> + def Month(self):
>
> + return self.getToken(VfrSyntaxParser.Month, 0)
>
> +
>
> + def Day(self):
>
> + return self.getToken(VfrSyntaxParser.Day, 0)
>
> +
>
> + def vfrDateFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrDateFlagsContext,0)
>
> +
>
> +
>
> + def vfrStatementInconsistentIf(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext
> )
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i
> )
>
> +
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementDate
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementDate" ):
>
> + return visitor.visitVfrStatementDate(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementDate(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementDateContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 230, self.RULE_vfrStatementDate)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1876
>
> + self.match(VfrSyntaxParser.Date)
>
> + 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 = 1877
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 1878
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1884
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 1879
>
> + localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1880
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1881
>
> + self.vfrDateFlags()
>
> + self.state = 1882
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1886
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Year]:
>
> + self.state = 1888
>
> + self.match(VfrSyntaxParser.Year)
>
> + self.state = 1889
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 1890
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1891
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1892
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 1893
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1894
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1895
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 1896
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1897
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1898
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1899
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1900
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1901
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1902
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 1903
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1904
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1905
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1906
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1907
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1908
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1909
>
> + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 0)
>
> + self.state = 1910
>
> + self.match(VfrSyntaxParser.Month)
>
> + self.state = 1911
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 1912
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1913
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1914
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 1915
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1916
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1917
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 1918
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1919
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1920
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1921
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1922
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1923
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1924
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 1925
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1926
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1927
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1928
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1929
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1930
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1931
>
> + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 1)
>
> + self.state = 1932
>
> + self.match(VfrSyntaxParser.Day)
>
> + self.state = 1933
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 1934
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1935
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1936
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 1937
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 1938
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1939
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 1940
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1941
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1942
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1943
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1944
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 1945
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1946
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 1947
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1948
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 1949
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 1950
>
> + 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 = 1954
>
> + localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 1955
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1956
>
> + self.vfrDateFlags()
>
> + self.state = 1957
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1964
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.InconsistentIf:
>
> + self.state = 1961
>
> + self.vfrStatementInconsistentIf()
>
> + self.state = 1966
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 1969
>
> + self.match(VfrSyntaxParser.EndDate)
>
> + self.state = 1970
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class MinMaxDateStepDefaultContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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
>
> +
>
> + def Minimum(self):
>
> + return self.getToken(VfrSyntaxParser.Minimum, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Maximum(self):
>
> + return self.getToken(VfrSyntaxParser.Maximum, 0)
>
> +
>
> + def Step(self):
>
> + return self.getToken(VfrSyntaxParser.Step, 0)
>
> +
>
> + def Default(self):
>
> + return self.getToken(VfrSyntaxParser.Default, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_minMaxDateStepDefault
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMinMaxDateStepDefault" ):
>
> + return visitor.visitMinMaxDateStepDefault(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def minMaxDateStepDefault(self, Node, 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 = 1972
>
> + self.match(VfrSyntaxParser.Minimum)
>
> + self.state = 1973
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1974
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1975
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1976
>
> + self.match(VfrSyntaxParser.Maximum)
>
> + self.state = 1977
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1978
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1979
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 1984
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Step:
>
> + self.state = 1980
>
> + self.match(VfrSyntaxParser.Step)
>
> + self.state = 1981
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1982
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 1983
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 1990
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Default:
>
> + self.state = 1986
>
> + self.match(VfrSyntaxParser.Default)
>
> + self.state = 1987
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 1988
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + self.state = 1989
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrDateFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.LFlags = 0
>
> +
>
> + def dateFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.DateFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.DateFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrDateFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrDateFlags" ):
>
> + return visitor.visitVfrDateFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrDateFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrDateFlagsContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 234, self.RULE_vfrDateFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 1992
>
> + self.dateFlagsField()
>
> + self.state = 1997
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 1993
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 1994
>
> + self.dateFlagsField()
>
> + self.state = 1999
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DateFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.LFlag = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def YearSupppressFlag(self):
>
> + return self.getToken(VfrSyntaxParser.YearSupppressFlag, 0)
>
> +
>
> + def MonthSuppressFlag(self):
>
> + return self.getToken(VfrSyntaxParser.MonthSuppressFlag, 0)
>
> +
>
> + def DaySuppressFlag(self):
>
> + return self.getToken(VfrSyntaxParser.DaySuppressFlag, 0)
>
> +
>
> + def StorageNormalFlag(self):
>
> + return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
>
> +
>
> + def StorageTimeFlag(self):
>
> + return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
>
> +
>
> + def StorageWakeUpFlag(self):
>
> + return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dateFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDateFlagsField" ):
>
> + return visitor.visitDateFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dateFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.DateFlagsFieldContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 236, self.RULE_dateFlagsField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementTimeContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_TIME_OP)
>
> + self.QType = EFI_QUESION_TYPE.QUESTION_TIME
>
> + self.Val = EFI_HII_TIME()
>
> + self.F1 = None # Token
>
> + self.F2 = None # Token
>
> +
>
> + def Time(self):
>
> + return self.getToken(VfrSyntaxParser.Time, 0)
>
> +
>
> + def EndTime(self):
>
> + return self.getToken(VfrSyntaxParser.EndTime, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def vfrQuestionHeader(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementQuestionOptionList(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> ntext,0)
>
> +
>
> +
>
> + def Hour(self):
>
> + return self.getToken(VfrSyntaxParser.Hour, 0)
>
> +
>
> + def VarId(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.VarId)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.VarId, i)
>
> +
>
> + def StringIdentifier(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringIdentifier)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
>
> +
>
> + def Dot(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Dot)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Dot, i)
>
> +
>
> + def Prompt(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Prompt)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Prompt, i)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Help(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Help)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Help, i)
>
> +
>
> + def minMaxTimeStepDefault(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.MinMaxTimeStepDefaultContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MinMaxTimeStepDefaultContext,i)
>
> +
>
> +
>
> + def Minute(self):
>
> + return self.getToken(VfrSyntaxParser.Minute, 0)
>
> +
>
> + def Second(self):
>
> + return self.getToken(VfrSyntaxParser.Second, 0)
>
> +
>
> + def vfrTimeFlags(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrTimeFlagsContext,0)
>
> +
>
> +
>
> + def vfrStatementInconsistentIf(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext
> )
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i
> )
>
> +
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementTime
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementTime" ):
>
> + return visitor.visitVfrStatementTime(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementTime(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementTimeContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 238, self.RULE_vfrStatementTime)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2002
>
> + self.match(VfrSyntaxParser.Time)
>
> + 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 = 2003
>
> + self.vfrQuestionHeader(localctx.Node, localctx.QType)
>
> + self.state = 2004
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2010
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 2005
>
> + localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2006
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2007
>
> + self.vfrTimeFlags()
>
> + self.state = 2008
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2012
>
> + self.vfrStatementQuestionOptionList(localctx.Node)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Hour]:
>
> + self.state = 2014
>
> + self.match(VfrSyntaxParser.Hour)
>
> + self.state = 2015
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 2016
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2017
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2018
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 2019
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2020
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2021
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 2022
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2023
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2024
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2025
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2026
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2027
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2028
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 2029
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2030
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2031
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2032
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2033
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2034
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2035
>
> + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 0)
>
> + self.state = 2036
>
> + self.match(VfrSyntaxParser.Minute)
>
> + self.state = 2037
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 2038
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2039
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2040
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 2041
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2042
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2043
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 2044
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2045
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2046
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2047
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2048
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2049
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2050
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 2051
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2052
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2053
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2054
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2055
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2056
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2057
>
> + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 1)
>
> + self.state = 2058
>
> + self.match(VfrSyntaxParser.Second)
>
> + self.state = 2059
>
> + self.match(VfrSyntaxParser.VarId)
>
> + self.state = 2060
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2061
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2062
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 2063
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2064
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2065
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 2066
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2067
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2068
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2069
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2070
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2071
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2072
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 2073
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2074
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2075
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2076
>
> + 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 = 2080
>
> + localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2081
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2082
>
> + self.vfrTimeFlags()
>
> + self.state = 2083
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2090
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.InconsistentIf:
>
> + self.state = 2087
>
> + self.vfrStatementInconsistentIf()
>
> + self.state = 2092
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 2095
>
> + self.match(VfrSyntaxParser.EndTime)
>
> + self.state = 2096
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class MinMaxTimeStepDefaultContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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
>
> +
>
> + def Minimum(self):
>
> + return self.getToken(VfrSyntaxParser.Minimum, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Maximum(self):
>
> + return self.getToken(VfrSyntaxParser.Maximum, 0)
>
> +
>
> + def Step(self):
>
> + return self.getToken(VfrSyntaxParser.Step, 0)
>
> +
>
> + def Default(self):
>
> + return self.getToken(VfrSyntaxParser.Default, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_minMaxTimeStepDefault
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMinMaxTimeStepDefault" ):
>
> + return visitor.visitMinMaxTimeStepDefault(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def minMaxTimeStepDefault(self, Node, 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 = 2098
>
> + self.match(VfrSyntaxParser.Minimum)
>
> + self.state = 2099
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2100
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2101
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2102
>
> + self.match(VfrSyntaxParser.Maximum)
>
> + self.state = 2103
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2104
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2105
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2110
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Step:
>
> + self.state = 2106
>
> + self.match(VfrSyntaxParser.Step)
>
> + self.state = 2107
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2108
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2109
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2116
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Default:
>
> + self.state = 2112
>
> + self.match(VfrSyntaxParser.Default)
>
> + self.state = 2113
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2114
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2115
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrTimeFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.LFlags = 0
>
> +
>
> + def timeFlagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.TimeFlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.TimeFlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrTimeFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrTimeFlags" ):
>
> + return visitor.visitVfrTimeFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrTimeFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrTimeFlagsContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 242, self.RULE_vfrTimeFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2118
>
> + self.timeFlagsField()
>
> + self.state = 2123
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2119
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2120
>
> + self.timeFlagsField()
>
> + self.state = 2125
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class TimeFlagsFieldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.LFlag = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def HourSupppressFlag(self):
>
> + return self.getToken(VfrSyntaxParser.HourSupppressFlag, 0)
>
> +
>
> + def MinuteSuppressFlag(self):
>
> + return self.getToken(VfrSyntaxParser.MinuteSuppressFlag, 0)
>
> +
>
> + def SecondSuppressFlag(self):
>
> + return self.getToken(VfrSyntaxParser.SecondSuppressFlag, 0)
>
> +
>
> + def StorageNormalFlag(self):
>
> + return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
>
> +
>
> + def StorageTimeFlag(self):
>
> + return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
>
> +
>
> + def StorageWakeUpFlag(self):
>
> + return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_timeFlagsField
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitTimeFlagsField" ):
>
> + return visitor.visitTimeFlagsField(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def timeFlagsField(self):
>
> +
>
> + localctx = VfrSyntaxParser.TimeFlagsFieldContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 244, self.RULE_timeFlagsField)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementConditionalContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementDisableIfStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
>
> +
>
> +
>
> + def vfrStatementSuppressIfStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatContext,
> 0)
>
> +
>
> +
>
> + def vfrStatementGrayOutIfStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatContext,
> 0)
>
> +
>
> +
>
> + def vfrStatementInconsistentIfStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatCont
> ext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementConditional
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementConditional" ):
>
> + return visitor.visitVfrStatementConditional(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementConditional(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementConditionalContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 246, self.RULE_vfrStatementConditional)
>
> + try:
>
> + self.state = 2132
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.DisableIf]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2128
>
> + self.vfrStatementDisableIfStat()
>
> + pass
>
> + elif token in [VfrSyntaxParser.SuppressIf]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2129
>
> + self.vfrStatementSuppressIfStat()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GrayOutIf]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2130
>
> + self.vfrStatementGrayOutIfStat()
>
> + pass
>
> + elif token in [VfrSyntaxParser.InconsistentIf]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2131
>
> + self.vfrStatementInconsistentIfStat()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementConditionalNewContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementDisableIfStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
>
> +
>
> +
>
> + def vfrStatementSuppressIfStatNew(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewCon
> text,0)
>
> +
>
> +
>
> + def vfrStatementGrayOutIfStatNew(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewCont
> ext,0)
>
> +
>
> +
>
> + def vfrStatementInconsistentIfStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatCont
> ext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementConditionalNew
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementConditionalNew" ):
>
> + return visitor.visitVfrStatementConditionalNew(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementConditionalNew(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementConditionalNewContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 248, self.RULE_vfrStatementConditionalNew)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2134
>
> + self.vfrStatementDisableIfStat()
>
> + self.state = 2135
>
> + self.vfrStatementSuppressIfStatNew()
>
> + self.state = 2136
>
> + self.vfrStatementGrayOutIfStatNew()
>
> + self.state = 2137
>
> + self.vfrStatementInconsistentIfStat()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementSuppressIfStatContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementSuppressIfStatNew(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewCon
> text,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementSuppressIfStat
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementSuppressIfStat" ):
>
> + return visitor.visitVfrStatementSuppressIfStat(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementSuppressIfStat(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementSuppressIfStatContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 250, self.RULE_vfrStatementSuppressIfStat)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2139
>
> + self.vfrStatementSuppressIfStatNew()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementGrayOutIfStatContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementGrayOutIfStatNew(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewCont
> ext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStat
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementGrayOutIfStat" ):
>
> + return visitor.visitVfrStatementGrayOutIfStat(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementGrayOutIfStat(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 252, self.RULE_vfrStatementGrayOutIfStat)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2141
>
> + self.vfrStatementGrayOutIfStatNew()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStatListContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrStatementStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
>
> +
>
> +
>
> + def vfrStatementQuestions(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
>
> +
>
> +
>
> + def vfrStatementConditional(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
>
> +
>
> +
>
> + def vfrStatementLabel(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
>
> +
>
> +
>
> + def vfrStatementExtension(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
>
> +
>
> +
>
> + def vfrStatementInvalid(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStatList
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStatList" ):
>
> + return visitor.visitVfrStatementStatList(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStatList(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStatListContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 254, self.RULE_vfrStatementStatList)
>
> + try:
>
> + self.state = 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 = 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 = 2144
>
> + self.vfrStatementQuestions()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf,
> VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2145
>
> + self.vfrStatementConditional()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Label]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2146
>
> + self.vfrStatementLabel()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GuidOp]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 2147
>
> + self.vfrStatementExtension()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 2148
>
> + self.vfrStatementInvalid()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementStatListOldContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def vfrStatementStat(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
>
> +
>
> +
>
> + def vfrStatementQuestions(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
>
> +
>
> +
>
> + def vfrStatementLabel(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
>
> +
>
> +
>
> + def vfrStatementInvalid(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementStatListOld
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementStatListOld" ):
>
> + return visitor.visitVfrStatementStatListOld(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementStatListOld(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementStatListOldContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 256, self.RULE_vfrStatementStatListOld)
>
> + try:
>
> + self.state = 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 = 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 = 2152
>
> + self.vfrStatementQuestions()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Label]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2153
>
> + self.vfrStatementLabel()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2154
>
> + self.vfrStatementInvalid()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementDisableIfStatContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
>
> +
>
> + def DisableIf(self):
>
> + return self.getToken(VfrSyntaxParser.DisableIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def vfrStatementStatList(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementDisableIfStat
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementDisableIfStat" ):
>
> + return visitor.visitVfrStatementDisableIfStat(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementDisableIfStat(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementDisableIfStatContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 258, self.RULE_vfrStatementDisableIfStat)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2157
>
> + self.match(VfrSyntaxParser.DisableIf)
>
> + self.state = 2158
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2159
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + 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 = 2160
>
> + self.vfrStatementStatList()
>
> + self.state = 2165
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2166
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 2167
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementgrayoutIfSuppressIfContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def SuppressIf(self):
>
> + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementgrayoutIfSuppressIf
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementgrayoutIfSuppressIf" ):
>
> + return visitor.visitVfrStatementgrayoutIfSuppressIf(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementgrayoutIfSuppressIf(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementgrayoutIfSuppressIfContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 260, self.RULE_vfrStatementgrayoutIfSuppressIf)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2169
>
> + self.match(VfrSyntaxParser.SuppressIf)
>
> + self.state = 2182
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 2170
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2171
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2172
>
> + self.flagsField()
>
> + self.state = 2177
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2173
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2174
>
> + self.flagsField()
>
> + self.state = 2179
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2180
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2184
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2185
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementsuppressIfGrayOutIfContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def GrayOutIf(self):
>
> + return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementsuppressIfGrayOutIf
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementsuppressIfGrayOutIf" ):
>
> + return visitor.visitVfrStatementsuppressIfGrayOutIf(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementsuppressIfGrayOutIf(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementsuppressIfGrayOutIfContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 262, self.RULE_vfrStatementsuppressIfGrayOutIf)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2187
>
> + self.match(VfrSyntaxParser.GrayOutIf)
>
> + self.state = 2200
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 2188
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2189
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2190
>
> + self.flagsField()
>
> + self.state = 2195
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2191
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2192
>
> + self.flagsField()
>
> + self.state = 2197
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2198
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2202
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2203
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementSuppressIfStatNewContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
>
> +
>
> + def SuppressIf(self):
>
> + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def vfrStatementStatList(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementSuppressIfStatNew
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementSuppressIfStatNew" ):
>
> + return visitor.visitVfrStatementSuppressIfStatNew(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementSuppressIfStatNew(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementSuppressIfStatNewContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 264, self.RULE_vfrStatementSuppressIfStatNew)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2205
>
> + self.match(VfrSyntaxParser.SuppressIf)
>
> + self.state = 2218
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 2206
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2207
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2208
>
> + self.flagsField()
>
> + self.state = 2213
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2209
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2210
>
> + self.flagsField()
>
> + self.state = 2215
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2216
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2220
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2221
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + 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 = 2222
>
> + self.vfrStatementStatList()
>
> + self.state = 2227
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2228
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 2229
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementGrayOutIfStatNewContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)
>
> +
>
> + def GrayOutIf(self):
>
> + return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def vfrStatementStatList(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStatNew
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementGrayOutIfStatNew" ):
>
> + return visitor.visitVfrStatementGrayOutIfStatNew(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementGrayOutIfStatNew(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 266, self.RULE_vfrStatementGrayOutIfStatNew)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2231
>
> + self.match(VfrSyntaxParser.GrayOutIf)
>
> + self.state = 2244
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 2232
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2233
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2234
>
> + self.flagsField()
>
> + self.state = 2239
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2235
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2236
>
> + self.flagsField()
>
> + self.state = 2241
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2242
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2246
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2247
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + 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 = 2248
>
> + self.vfrStatementStatList()
>
> + self.state = 2253
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2254
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 2255
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementInconsistentIfStatContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
>
> +
>
> + def InconsistentIf(self):
>
> + return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementExpression(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
>
> +
>
> +
>
> + def EndIf(self):
>
> + return self.getToken(VfrSyntaxParser.EndIf, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementInconsistentIfStat
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementInconsistentIfStat" ):
>
> + return visitor.visitVfrStatementInconsistentIfStat(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementInconsistentIfStat(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementInconsistentIfStatContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 268, self.RULE_vfrStatementInconsistentIfStat)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2257
>
> + self.match(VfrSyntaxParser.InconsistentIf)
>
> + self.state = 2258
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 2259
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2260
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2261
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2262
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2263
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2264
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2277
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.FLAGS:
>
> + self.state = 2265
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2266
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2267
>
> + self.flagsField()
>
> + self.state = 2272
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2268
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2269
>
> + self.flagsField()
>
> + self.state = 2274
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2275
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2279
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2280
>
> + self.match(VfrSyntaxParser.EndIf)
>
> + self.state = 2281
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementInvalidContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def vfrStatementInvalidHidden(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidHiddenContext,
> 0)
>
> +
>
> +
>
> + def vfrStatementInvalidInventory(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidInventoryConte
> xt,0)
>
> +
>
> +
>
> + def vfrStatementInvalidSaveRestoreDefaults(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidSaveRestoreDef
> aultsContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementInvalid
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementInvalid" ):
>
> + return visitor.visitVfrStatementInvalid(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementInvalid(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementInvalidContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 270, self.RULE_vfrStatementInvalid)
>
> + try:
>
> + self.state = 2286
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Hidden]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2283
>
> + self.vfrStatementInvalidHidden()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Inventory]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2284
>
> + self.vfrStatementInvalidInventory()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2285
>
> + self.vfrStatementInvalidSaveRestoreDefaults()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementInvalidHiddenContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def Hidden(self):
>
> + return self.getToken(VfrSyntaxParser.Hidden, 0)
>
> +
>
> + def Value(self):
>
> + return self.getToken(VfrSyntaxParser.Value, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementInvalidHidden
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementInvalidHidden" ):
>
> + return visitor.visitVfrStatementInvalidHidden(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementInvalidHidden(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementInvalidHiddenContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 272, self.RULE_vfrStatementInvalidHidden)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2288
>
> + self.match(VfrSyntaxParser.Hidden)
>
> + self.state = 2289
>
> + self.match(VfrSyntaxParser.Value)
>
> + self.state = 2290
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2291
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2292
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2293
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 2294
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2295
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2296
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementInvalidInventoryContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def Inventory(self):
>
> + return self.getToken(VfrSyntaxParser.Inventory, 0)
>
> +
>
> + def Help(self):
>
> + return self.getToken(VfrSyntaxParser.Help, 0)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Text(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Text)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Text, i)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementInvalidInventory
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementInvalidInventory" ):
>
> + return visitor.visitVfrStatementInvalidInventory(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementInvalidInventory(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementInvalidInventoryContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 274, self.RULE_vfrStatementInvalidInventory)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2298
>
> + self.match(VfrSyntaxParser.Inventory)
>
> + self.state = 2299
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 2300
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2301
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2302
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2303
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2304
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2305
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2306
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 2307
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2308
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2309
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2310
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2311
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2312
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2319
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Text:
>
> + self.state = 2313
>
> + self.match(VfrSyntaxParser.Text)
>
> + self.state = 2314
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2315
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2316
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2317
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2318
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> +
>
> +
>
> + self.state = 2321
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementInvalidSaveRestoreDefaultsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> +
>
> + def Defaults(self):
>
> + return self.getToken(VfrSyntaxParser.Defaults, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def FormId(self):
>
> + return self.getToken(VfrSyntaxParser.FormId, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def Prompt(self):
>
> + return self.getToken(VfrSyntaxParser.Prompt, 0)
>
> +
>
> + def StringToken(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.StringToken)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.StringToken, i)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def Help(self):
>
> + return self.getToken(VfrSyntaxParser.Help, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Save(self):
>
> + return self.getToken(VfrSyntaxParser.Save, 0)
>
> +
>
> + def Restore(self):
>
> + return self.getToken(VfrSyntaxParser.Restore, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def flagsField(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
>
> +
>
> +
>
> + def Key(self):
>
> + return self.getToken(VfrSyntaxParser.Key, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementInvalidSaveRestoreDefaults
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementInvalidSaveRestoreDefaults" ):
>
> + return visitor.visitVfrStatementInvalidSaveRestoreDefaults(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementInvalidSaveRestoreDefaults(self):
>
> +
>
> + localctx =
> VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 276,
> self.RULE_vfrStatementInvalidSaveRestoreDefaults)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 2324
>
> + self.match(VfrSyntaxParser.Defaults)
>
> + self.state = 2325
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2326
>
> + self.match(VfrSyntaxParser.FormId)
>
> + self.state = 2327
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2328
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2329
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2330
>
> + self.match(VfrSyntaxParser.Prompt)
>
> + self.state = 2331
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2332
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2333
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2334
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2335
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2336
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2337
>
> + self.match(VfrSyntaxParser.Help)
>
> + self.state = 2338
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2339
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2340
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2341
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2342
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2354
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 2343
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2344
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2345
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2346
>
> + self.flagsField()
>
> + self.state = 2351
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2347
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2348
>
> + self.flagsField()
>
> + self.state = 2353
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> +
>
> +
>
> + self.state = 2360
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 2356
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2357
>
> + self.match(VfrSyntaxParser.Key)
>
> + self.state = 2358
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2359
>
> + self.match(VfrSyntaxParser.Number)
>
> +
>
> +
>
> + self.state = 2362
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementLabelContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
> +
>
> + def Label(self):
>
> + return self.getToken(VfrSyntaxParser.Label, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementLabel
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementLabel" ):
>
> + return visitor.visitVfrStatementLabel(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementLabel(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementLabelContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 278, self.RULE_vfrStatementLabel)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2364
>
> + self.match(VfrSyntaxParser.Label)
>
> + self.state = 2365
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2366
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementBannerContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
> +
>
> + def Banner(self):
>
> + return self.getToken(VfrSyntaxParser.Banner, 0)
>
> +
>
> + def Title(self):
>
> + return self.getToken(VfrSyntaxParser.Title, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Line(self):
>
> + return self.getToken(VfrSyntaxParser.Line, 0)
>
> +
>
> + def Align(self):
>
> + return self.getToken(VfrSyntaxParser.Align, 0)
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Timeout(self):
>
> + return self.getToken(VfrSyntaxParser.Timeout, 0)
>
> +
>
> + def Left(self):
>
> + return self.getToken(VfrSyntaxParser.Left, 0)
>
> +
>
> + def Center(self):
>
> + return self.getToken(VfrSyntaxParser.Center, 0)
>
> +
>
> + def Right(self):
>
> + return self.getToken(VfrSyntaxParser.Right, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementBanner
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementBanner" ):
>
> + return visitor.visitVfrStatementBanner(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementBanner(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementBannerContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 280, self.RULE_vfrStatementBanner)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2368
>
> + self.match(VfrSyntaxParser.Banner)
>
> + self.state = 2370
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 2369
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2372
>
> + self.match(VfrSyntaxParser.Title)
>
> + self.state = 2373
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2374
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2375
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2376
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2377
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2378
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2389
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Line]:
>
> + self.state = 2379
>
> + self.match(VfrSyntaxParser.Line)
>
> + self.state = 2380
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2381
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2382
>
> + self.match(VfrSyntaxParser.Align)
>
> + 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 = 2384
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Timeout]:
>
> + self.state = 2385
>
> + self.match(VfrSyntaxParser.Timeout)
>
> + self.state = 2386
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2387
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2388
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementExtensionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
>
> + self.Buffer = None
>
> + self.Size = 0
>
> + self.TypeName = ''
>
> + self.TypeSize = 0
>
> + self.IsStruct = False
>
> + self.ArrayNum = 0
>
> + self.D = None # Token
>
> +
>
> + def GuidOp(self):
>
> + return self.getToken(VfrSyntaxParser.GuidOp, 0)
>
> +
>
> + def Uuid(self):
>
> + return self.getToken(VfrSyntaxParser.Uuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def EndGuidOp(self):
>
> + return self.getToken(VfrSyntaxParser.EndGuidOp, 0)
>
> +
>
> + def DataType(self):
>
> + return self.getToken(VfrSyntaxParser.DataType, 0)
>
> +
>
> + def Uint64(self):
>
> + return self.getToken(VfrSyntaxParser.Uint64, 0)
>
> +
>
> + def Uint32(self):
>
> + return self.getToken(VfrSyntaxParser.Uint32, 0)
>
> +
>
> + def Uint16(self):
>
> + return self.getToken(VfrSyntaxParser.Uint16, 0)
>
> +
>
> + def Uint8(self):
>
> + return self.getToken(VfrSyntaxParser.Uint8, 0)
>
> +
>
> + def Boolean(self):
>
> + return self.getToken(VfrSyntaxParser.Boolean, 0)
>
> +
>
> + def EFI_STRING_ID(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
>
> +
>
> + def EFI_HII_DATE(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
>
> +
>
> + def EFI_HII_TIME(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
>
> +
>
> + def EFI_HII_REF(self):
>
> + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def vfrExtensionData(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrExtensionDataContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExtensionDataContext,i)
>
> +
>
> +
>
> + def vfrStatementExtension(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExtensionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,i)
>
> +
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementExtension
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementExtension" ):
>
> + return visitor.visitVfrStatementExtension(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementExtension(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementExtensionContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 282, self.RULE_vfrStatementExtension)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2391
>
> + self.match(VfrSyntaxParser.GuidOp)
>
> + self.state = 2392
>
> + self.match(VfrSyntaxParser.Uuid)
>
> + self.state = 2393
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2394
>
> + self.guidDefinition()
>
> + self.state = 2466
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
>
> + if la_ == 1:
>
> + self.state = 2395
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2396
>
> + localctx.D = self.match(VfrSyntaxParser.DataType)
>
> + self.state = 2397
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2458
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Uint64]:
>
> + self.state = 2398
>
> + self.match(VfrSyntaxParser.Uint64)
>
> + self.state = 2402
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2399
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2400
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2401
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint32]:
>
> + self.state = 2404
>
> + self.match(VfrSyntaxParser.Uint32)
>
> + self.state = 2408
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2405
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2406
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2407
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint16]:
>
> + self.state = 2410
>
> + self.match(VfrSyntaxParser.Uint16)
>
> + self.state = 2414
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2411
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2412
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2413
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.Uint8]:
>
> + self.state = 2416
>
> + self.match(VfrSyntaxParser.Uint8)
>
> + self.state = 2420
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2417
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2418
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2419
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.Boolean]:
>
> + self.state = 2422
>
> + self.match(VfrSyntaxParser.Boolean)
>
> + self.state = 2426
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2423
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2424
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2425
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_STRING_ID]:
>
> + self.state = 2428
>
> + self.match(VfrSyntaxParser.EFI_STRING_ID)
>
> + self.state = 2432
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2429
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2430
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2431
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_DATE]:
>
> + self.state = 2434
>
> + self.match(VfrSyntaxParser.EFI_HII_DATE)
>
> + self.state = 2438
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2435
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2436
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2437
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_TIME]:
>
> + self.state = 2440
>
> + self.match(VfrSyntaxParser.EFI_HII_TIME)
>
> + self.state = 2444
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2441
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2442
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2443
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.EFI_HII_REF]:
>
> + self.state = 2446
>
> + self.match(VfrSyntaxParser.EFI_HII_REF)
>
> + self.state = 2450
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2447
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2448
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2449
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + elif token in [VfrSyntaxParser.StringIdentifier]:
>
> + self.state = 2452
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2456
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2453
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2454
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2455
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 2463
>
> + self._errHandler.sync(self)
>
> + _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
>
> + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
>
> + if _alt==1:
>
> + self.state = 2460
>
> + self.vfrExtensionData()
>
> + self.state = 2465
>
> + self._errHandler.sync(self)
>
> + _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
>
> +
>
> +
>
> +
>
> + self.state = 2476
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Comma:
>
> + self.state = 2468
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2472
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.GuidOp:
>
> + self.state = 2469
>
> + self.vfrStatementExtension()
>
> + self.state = 2474
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2475
>
> + self.match(VfrSyntaxParser.EndGuidOp)
>
> +
>
> +
>
> + self.state = 2478
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExtensionDataContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.TFName = ''
>
> + self.FName = ''
>
> + self.TFValue = None
>
> + self.I = None # Token
>
> + self.N = None # Token
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def Data(self):
>
> + return self.getToken(VfrSyntaxParser.Data, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def Dot(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Dot)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Dot, i)
>
> +
>
> + def arrayName(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExtensionData
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExtensionData" ):
>
> + return visitor.visitVfrExtensionData(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExtensionData(self):
>
> +
>
> + 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 = 2480
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2481
>
> + self.match(VfrSyntaxParser.Data)
>
> + self.state = 2485
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.OpenBracket:
>
> + self.state = 2482
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2483
>
> + localctx.I = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2484
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + self.state = 2491
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.Dot:
>
> + self.state = 2487
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 2488
>
> + self.arrayName()
>
> + self.state = 2493
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2494
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2495
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementModalContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = None
>
> +
>
> + def vfrModalTag(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrModalTagContext,0)
>
> +
>
> +
>
> + def Semicolon(self):
>
> + return self.getToken(VfrSyntaxParser.Semicolon, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementModal
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementModal" ):
>
> + return visitor.visitVfrStatementModal(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementModal(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrStatementModalContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 286, self.RULE_vfrStatementModal)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2497
>
> + self.vfrModalTag()
>
> + self.state = 2498
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrModalTagContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Node = IfrTreeNode(EFI_IFR_MODAL_TAG_OP)
>
> +
>
> + def Modal(self):
>
> + return self.getToken(VfrSyntaxParser.Modal, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrModalTag
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrModalTag" ):
>
> + return visitor.visitVfrModalTag(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrModalTag(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrModalTagContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 288, self.RULE_vfrModalTag)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2500
>
> + self.match(VfrSyntaxParser.Modal)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementExpressionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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:
>
> + return self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
>
> + else:
>
> + return self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
>
> +
>
> +
>
> + def OR(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OR)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OR, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementExpression
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementExpression" ):
>
> + return visitor.visitVfrStatementExpression(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementExpression(self, ParentNode):
>
> +
>
> + 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 = 2502
>
> + self.andTerm(localctx.ExpInfo)
>
> + self.state = 2507
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.OR:
>
> + self.state = 2503
>
> + localctx.L = self.match(VfrSyntaxParser.OR)
>
> + self.state = 2504
>
> + self.andTerm(localctx.ExpInfo)
>
> + self.state = 2509
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrStatementExpressionSubContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, 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:
>
> + return self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
>
> + else:
>
> + return self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
>
> +
>
> +
>
> + def OR(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OR)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OR, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrStatementExpressionSub
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrStatementExpressionSub" ):
>
> + return visitor.visitVfrStatementExpressionSub(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrStatementExpressionSub(self, ParentNodes):
>
> +
>
> + 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 = 2510
>
> + self.andTerm(localctx.ExpInfo)
>
> + self.state = 2515
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.OR:
>
> + self.state = 2511
>
> + self.match(VfrSyntaxParser.OR)
>
> + self.state = 2512
>
> + self.andTerm(localctx.ExpInfo)
>
> + self.state = 2517
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class AndTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.L = None # Token
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def bitwiseorTerm(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.BitwiseorTermContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.BitwiseorTermContext,i)
>
> +
>
> +
>
> + def AND(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.AND)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.AND, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_andTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitAndTerm" ):
>
> + return visitor.visitAndTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def andTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.AndTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 294, self.RULE_andTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2518
>
> + self.bitwiseorTerm(ExpInfo)
>
> + self.state = 2523
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.AND:
>
> + self.state = 2519
>
> + localctx.L = self.match(VfrSyntaxParser.AND)
>
> + self.state = 2520
>
> + self.bitwiseorTerm(ExpInfo)
>
> + self.state = 2525
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class BitwiseorTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.L = None # Token
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def bitwiseandTerm(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.BitwiseandTermContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.BitwiseandTermContext,i)
>
> +
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_bitwiseorTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitBitwiseorTerm" ):
>
> + return visitor.visitBitwiseorTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def bitwiseorTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.BitwiseorTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 296, self.RULE_bitwiseorTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2526
>
> + self.bitwiseandTerm(ExpInfo)
>
> + self.state = 2531
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2527
>
> + localctx.L = self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2528
>
> + self.bitwiseandTerm(ExpInfo)
>
> + self.state = 2533
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class BitwiseandTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.L = None # Token
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def equalTerm(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.EqualTermContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.EqualTermContext,i)
>
> +
>
> +
>
> + def BitWiseAnd(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseAnd)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseAnd, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_bitwiseandTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitBitwiseandTerm" ):
>
> + return visitor.visitBitwiseandTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def bitwiseandTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.BitwiseandTermContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 298, self.RULE_bitwiseandTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2534
>
> + self.equalTerm(ExpInfo)
>
> + self.state = 2539
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseAnd:
>
> + self.state = 2535
>
> + localctx.L = self.match(VfrSyntaxParser.BitWiseAnd)
>
> + self.state = 2536
>
> + self.equalTerm(ExpInfo)
>
> + self.state = 2541
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class EqualTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.Line = None
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def compareTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
>
> +
>
> +
>
> + def equalTermSupplementary(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.EqualTermSupplementaryContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.EqualTermSupplementaryContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_equalTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitEqualTerm" ):
>
> + return visitor.visitEqualTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def equalTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.EqualTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 300, self.RULE_equalTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 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 = 2543
>
> + self.equalTermSupplementary(ExpInfo)
>
> + self.state = 2548
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class EqualTermSupplementaryContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_equalTermSupplementary
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
> +
>
> +
>
> +
>
> + class EqualTermEqualRuleContext(EqualTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.EqualTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def Equal(self):
>
> + return self.getToken(VfrSyntaxParser.Equal, 0)
>
> + def compareTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitEqualTermEqualRule" ):
>
> + return visitor.visitEqualTermEqualRule(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class EqualTermNotEqualRuleContext(EqualTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.EqualTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def NotEqual(self):
>
> + return self.getToken(VfrSyntaxParser.NotEqual, 0)
>
> + def compareTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitEqualTermNotEqualRule" ):
>
> + return visitor.visitEqualTermNotEqualRule(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def equalTermSupplementary(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.EqualTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> + self.enterRule(localctx, 302, self.RULE_equalTermSupplementary)
>
> + try:
>
> + 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 = 2549
>
> + self.match(VfrSyntaxParser.Equal)
>
> + self.state = 2550
>
> + self.compareTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NotEqual]:
>
> + localctx = VfrSyntaxParser.EqualTermNotEqualRuleContext(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2551
>
> + self.match(VfrSyntaxParser.NotEqual)
>
> + self.state = 2552
>
> + self.compareTerm(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class CompareTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def shiftTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
>
> +
>
> +
>
> + def compareTermSupplementary(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.CompareTermSupplementaryCont
> ext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CompareTermSupplementaryConte
> xt,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_compareTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCompareTerm" ):
>
> + return visitor.visitCompareTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def compareTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.CompareTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 304, self.RULE_compareTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2555
>
> + self.shiftTerm(ExpInfo)
>
> + 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 = 2556
>
> + self.compareTermSupplementary(ExpInfo)
>
> + self.state = 2561
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class CompareTermSupplementaryContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_compareTermSupplementary
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
> +
>
> +
>
> +
>
> + class
> CompareTermLessRuleContext(CompareTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.CompareTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def Less(self):
>
> + return self.getToken(VfrSyntaxParser.Less, 0)
>
> + def shiftTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCompareTermLessRule" ):
>
> + return visitor.visitCompareTermLessRule(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> CompareTermGreaterEqualRuleContext(CompareTermSupplementaryContext
> ):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.CompareTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def GreaterEqual(self):
>
> + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
>
> + def shiftTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCompareTermGreaterEqualRule" ):
>
> + return visitor.visitCompareTermGreaterEqualRule(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> CompareTermGreaterRuleContext(CompareTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.CompareTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def Greater(self):
>
> + return self.getToken(VfrSyntaxParser.Greater, 0)
>
> + def shiftTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCompareTermGreaterRule" ):
>
> + return visitor.visitCompareTermGreaterRule(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> CompareTermLessEqualRuleContext(CompareTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.CompareTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def LessEqual(self):
>
> + return self.getToken(VfrSyntaxParser.LessEqual, 0)
>
> + def shiftTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCompareTermLessEqualRule" ):
>
> + return visitor.visitCompareTermLessEqualRule(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def compareTermSupplementary(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.CompareTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> + self.enterRule(localctx, 306, self.RULE_compareTermSupplementary)
>
> + try:
>
> + 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 = 2562
>
> + self.match(VfrSyntaxParser.Less)
>
> + self.state = 2563
>
> + self.shiftTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.LessEqual]:
>
> + localctx = VfrSyntaxParser.CompareTermLessEqualRuleContext(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2564
>
> + self.match(VfrSyntaxParser.LessEqual)
>
> + self.state = 2565
>
> + self.shiftTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Greater]:
>
> + localctx = VfrSyntaxParser.CompareTermGreaterRuleContext(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2566
>
> + self.match(VfrSyntaxParser.Greater)
>
> + self.state = 2567
>
> + self.shiftTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.GreaterEqual]:
>
> + localctx =
> VfrSyntaxParser.CompareTermGreaterEqualRuleContext(self, localctx)
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2568
>
> + self.match(VfrSyntaxParser.GreaterEqual)
>
> + self.state = 2569
>
> + self.shiftTerm(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ShiftTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def addMinusTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
>
> +
>
> +
>
> + def shiftTermSupplementary(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.ShiftTermSupplementaryContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermSupplementaryContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_shiftTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitShiftTerm" ):
>
> + return visitor.visitShiftTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def shiftTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.ShiftTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 308, self.RULE_shiftTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2572
>
> + self.addMinusTerm(ExpInfo)
>
> + self.state = 2576
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.T__9 or _la==VfrSyntaxParser.T__10:
>
> + self.state = 2573
>
> + self.shiftTermSupplementary(ExpInfo)
>
> + self.state = 2578
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ShiftTermSupplementaryContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_shiftTermSupplementary
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
> +
>
> +
>
> +
>
> + class ShiftTermRightContext(ShiftTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.ShiftTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def addMinusTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitShiftTermRight" ):
>
> + return visitor.visitShiftTermRight(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class ShiftTermLeftContext(ShiftTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.ShiftTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def addMinusTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitShiftTermLeft" ):
>
> + return visitor.visitShiftTermLeft(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def shiftTermSupplementary(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.ShiftTermSupplementaryContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 310, self.RULE_shiftTermSupplementary)
>
> + try:
>
> + 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 = 2579
>
> + self.match(VfrSyntaxParser.T__9)
>
> + self.state = 2580
>
> + self.addMinusTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.T__10]:
>
> + localctx = VfrSyntaxParser.ShiftTermRightContext(self, localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2581
>
> + self.match(VfrSyntaxParser.T__10)
>
> + self.state = 2582
>
> + self.addMinusTerm(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class AddMinusTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def multdivmodTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
>
> +
>
> +
>
> + def addMinusTermSupplementary(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.AddMinusTermSupplementaryCon
> text)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermSupplementaryCont
> ext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_addMinusTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitAddMinusTerm" ):
>
> + return visitor.visitAddMinusTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def addMinusTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.AddMinusTermContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 312, self.RULE_addMinusTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2585
>
> + self.multdivmodTerm(ExpInfo)
>
> + self.state = 2589
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.T__11 or _la==VfrSyntaxParser.Negative:
>
> + self.state = 2586
>
> + self.addMinusTermSupplementary(ExpInfo)
>
> + self.state = 2591
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class AddMinusTermSupplementaryContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_addMinusTermSupplementary
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
> +
>
> +
>
> +
>
> + class
> AddMinusTermpAddContext(AddMinusTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.AddMinusTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def multdivmodTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitAddMinusTermpAdd" ):
>
> + return visitor.visitAddMinusTermpAdd(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> AddMinusTermSubtractContext(AddMinusTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.AddMinusTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def Negative(self):
>
> + return self.getToken(VfrSyntaxParser.Negative, 0)
>
> + def multdivmodTerm(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitAddMinusTermSubtract" ):
>
> + return visitor.visitAddMinusTermSubtract(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def addMinusTermSupplementary(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.AddMinusTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> + self.enterRule(localctx, 314, self.RULE_addMinusTermSupplementary)
>
> + try:
>
> + 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 = 2592
>
> + self.match(VfrSyntaxParser.T__11)
>
> + self.state = 2593
>
> + self.multdivmodTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Negative]:
>
> + localctx = VfrSyntaxParser.AddMinusTermSubtractContext(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2594
>
> + self.match(VfrSyntaxParser.Negative)
>
> + self.state = 2595
>
> + self.multdivmodTerm(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class MultdivmodTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def castTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
>
> +
>
> +
>
> + def multdivmodTermSupplementary(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.MultdivmodTermSupplementaryC
> ontext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermSupplementaryCo
> ntext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_multdivmodTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMultdivmodTerm" ):
>
> + return visitor.visitMultdivmodTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def multdivmodTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.MultdivmodTermContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 316, self.RULE_multdivmodTerm)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2598
>
> + self.castTerm(ExpInfo)
>
> + 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 = 2599
>
> + self.multdivmodTermSupplementary(ExpInfo)
>
> + self.state = 2604
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class MultdivmodTermSupplementaryContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_multdivmodTermSupplementary
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.ExpInfo = ctx.ExpInfo
>
> + self.Nodes = ctx.Nodes
>
> +
>
> +
>
> +
>
> + class
> MultdivmodTermDivContext(MultdivmodTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.MultdivmodTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def Slash(self):
>
> + return self.getToken(VfrSyntaxParser.Slash, 0)
>
> + def castTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMultdivmodTermDiv" ):
>
> + return visitor.visitMultdivmodTermDiv(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> MultdivmodTermMulContext(MultdivmodTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.MultdivmodTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def castTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMultdivmodTermMul" ):
>
> + return visitor.visitMultdivmodTermMul(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> MultdivmodTermModuloContext(MultdivmodTermSupplementaryContext):
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.MultdivmodTermSupplementaryContext
>
> + super().__init__(parser)
>
> + self.copyFrom(ctx)
>
> +
>
> + def castTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMultdivmodTermModulo" ):
>
> + return visitor.visitMultdivmodTermModulo(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def multdivmodTermSupplementary(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.MultdivmodTermSupplementaryContext(self,
> self._ctx, self.state, ExpInfo)
>
> + self.enterRule(localctx, 318, self.RULE_multdivmodTermSupplementary)
>
> + try:
>
> + 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 = 2605
>
> + self.match(VfrSyntaxParser.T__12)
>
> + self.state = 2606
>
> + self.castTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Slash]:
>
> + localctx = VfrSyntaxParser.MultdivmodTermDivContext(self, localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2607
>
> + self.match(VfrSyntaxParser.Slash)
>
> + self.state = 2608
>
> + self.castTerm(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.T__13]:
>
> + localctx = VfrSyntaxParser.MultdivmodTermModuloContext(self,
> localctx)
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2609
>
> + self.match(VfrSyntaxParser.T__13)
>
> + self.state = 2610
>
> + self.castTerm(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class CastTermContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def atomTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
>
> +
>
> +
>
> + def castTermSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.CastTermSubContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CastTermSubContext,i)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_castTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitCastTerm" ):
>
> + return visitor.visitCastTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def castTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.CastTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 320, self.RULE_castTerm)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2616
>
> + self._errHandler.sync(self)
>
> + _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
>
> + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
>
> + if _alt==1:
>
> + self.state = 2613
>
> + self.castTermSub()
>
> + self.state = 2618
>
> + self._errHandler.sync(self)
>
> + _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
>
> +
>
> + self.state = 2619
>
> + self.atomTerm(ExpInfo)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class 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):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionCatenateContext,0)
>
> +
>
> +
>
> + def vfrExpressionMatch(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatchContext,0)
>
> +
>
> +
>
> + def vfrExpressionMatch2(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatch2Context,0)
>
> +
>
> +
>
> + def vfrExpressionParen(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionParenContext,0)
>
> +
>
> +
>
> + def vfrExpressionBuildInFunction(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionBuildInFunctionConte
> xt,0)
>
> +
>
> +
>
> + def vfrExpressionConstant(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionConstantContext,0)
>
> +
>
> +
>
> + def vfrExpressionUnaryOp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionUnaryOpContext,0)
>
> +
>
> +
>
> + def vfrExpressionTernaryOp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionTernaryOpContext,0)
>
> +
>
> +
>
> + def vfrExpressionMap(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMapContext,0)
>
> +
>
> +
>
> + def NOT(self):
>
> + return self.getToken(VfrSyntaxParser.NOT, 0)
>
> +
>
> + def atomTerm(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_atomTerm
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitAtomTerm" ):
>
> + return visitor.visitAtomTerm(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def atomTerm(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.AtomTermContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 324, self.RULE_atomTerm)
>
> + try:
>
> + self.state = 2636
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Catenate]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2625
>
> + self.vfrExpressionCatenate(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Match]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2626
>
> + self.vfrExpressionMatch(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Match2]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2627
>
> + self.vfrExpressionMatch2(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.OpenParen]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2628
>
> + self.vfrExpressionParen(ExpInfo)
>
> + pass
>
> + 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 = 2629
>
> + self.vfrExpressionBuildInFunction(ExpInfo)
>
> + pass
>
> + 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 = 2630
>
> + self.vfrExpressionConstant(ExpInfo)
>
> + pass
>
> + 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 = 2631
>
> + self.vfrExpressionUnaryOp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Cond, VfrSyntaxParser.Find,
> VfrSyntaxParser.Mid, VfrSyntaxParser.Tok, VfrSyntaxParser.Span]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 2632
>
> + self.vfrExpressionTernaryOp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Map]:
>
> + self.enterOuterAlt(localctx, 9)
>
> + self.state = 2633
>
> + self.vfrExpressionMap(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.NOT]:
>
> + self.enterOuterAlt(localctx, 10)
>
> + self.state = 2634
>
> + self.match(VfrSyntaxParser.NOT)
>
> + self.state = 2635
>
> + self.atomTerm(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionCatenateContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Catenate(self):
>
> + return self.getToken(VfrSyntaxParser.Catenate, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionCatenate
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionCatenate" ):
>
> + return visitor.visitVfrExpressionCatenate(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionCatenate(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionCatenateContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 326, self.RULE_vfrExpressionCatenate)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2638
>
> + self.match(VfrSyntaxParser.Catenate)
>
> + self.state = 2639
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2640
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2641
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2642
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2643
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionMatchContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Match(self):
>
> + return self.getToken(VfrSyntaxParser.Match, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionMatch
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionMatch" ):
>
> + return visitor.visitVfrExpressionMatch(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionMatch(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionMatchContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 328, self.RULE_vfrExpressionMatch)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2645
>
> + self.match(VfrSyntaxParser.Match)
>
> + self.state = 2646
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2647
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2648
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2649
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2650
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionMatch2Context(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Match2(self):
>
> + return self.getToken(VfrSyntaxParser.Match2, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionMatch2
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionMatch2" ):
>
> + return visitor.visitVfrExpressionMatch2(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionMatch2(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionMatch2Context(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 330, self.RULE_vfrExpressionMatch2)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2652
>
> + self.match(VfrSyntaxParser.Match2)
>
> + self.state = 2653
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2654
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2655
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2656
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2657
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2658
>
> + self.guidDefinition()
>
> + self.state = 2659
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionParenContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionParen
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionParen" ):
>
> + return visitor.visitVfrExpressionParen(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionParen(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionParenContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 332, self.RULE_vfrExpressionParen)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2661
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2662
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2663
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionBuildInFunctionContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = None
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def dupExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.DupExpContext,0)
>
> +
>
> +
>
> + def vareqvalExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VareqvalExpContext,0)
>
> +
>
> +
>
> + def ideqvalExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.IdeqvalExpContext,0)
>
> +
>
> +
>
> + def ideqidExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.IdeqidExpContext,0)
>
> +
>
> +
>
> + def ideqvallistExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.IdeqvallistExpContext,0)
>
> +
>
> +
>
> + def questionref1Exp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.Questionref1ExpContext,0)
>
> +
>
> +
>
> + def rulerefExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.RulerefExpContext,0)
>
> +
>
> +
>
> + def stringref1Exp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.Stringref1ExpContext,0)
>
> +
>
> +
>
> + def pushthisExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.PushthisExpContext,0)
>
> +
>
> +
>
> + def securityExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.SecurityExpContext,0)
>
> +
>
> +
>
> + def getExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.GetExpContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionBuildInFunction
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionBuildInFunction" ):
>
> + return visitor.visitVfrExpressionBuildInFunction(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionBuildInFunction(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionBuildInFunctionContext(self,
> self._ctx, self.state, ExpInfo)
>
> + self.enterRule(localctx, 334, self.RULE_vfrExpressionBuildInFunction)
>
> + try:
>
> + self.state = 2676
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Dup]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2665
>
> + self.dupExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.VarEqVal]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2666
>
> + self.vareqvalExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.IdEqVal]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2667
>
> + self.ideqvalExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.IdEqId]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2668
>
> + self.ideqidExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.IdEqValList]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 2669
>
> + self.ideqvallistExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.QuestionRef]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 2670
>
> + self.questionref1Exp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.RuleRef]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 2671
>
> + self.rulerefExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.StringRef]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 2672
>
> + self.stringref1Exp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.PushThis]:
>
> + self.enterOuterAlt(localctx, 9)
>
> + self.state = 2673
>
> + self.pushthisExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Security]:
>
> + self.enterOuterAlt(localctx, 10)
>
> + self.state = 2674
>
> + self.securityExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Get]:
>
> + self.enterOuterAlt(localctx, 11)
>
> + self.state = 2675
>
> + self.getExp(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class DupExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_DUP_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Dup(self):
>
> + return self.getToken(VfrSyntaxParser.Dup, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_dupExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitDupExp" ):
>
> + return visitor.visitDupExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def dupExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.DupExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 336, self.RULE_dupExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2678
>
> + self.match(VfrSyntaxParser.Dup)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VareqvalExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = None
>
> + self.VN = None # Token
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def VarEqVal(self):
>
> + return self.getToken(VfrSyntaxParser.VarEqVal, 0)
>
> +
>
> + def Var(self):
>
> + return self.getToken(VfrSyntaxParser.Var, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def 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 Equal(self):
>
> + return self.getToken(VfrSyntaxParser.Equal, 0)
>
> +
>
> + def LessEqual(self):
>
> + return self.getToken(VfrSyntaxParser.LessEqual, 0)
>
> +
>
> + def Less(self):
>
> + return self.getToken(VfrSyntaxParser.Less, 0)
>
> +
>
> + def GreaterEqual(self):
>
> + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
>
> +
>
> + def Greater(self):
>
> + return self.getToken(VfrSyntaxParser.Greater, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vareqvalExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVareqvalExp" ):
>
> + return visitor.visitVareqvalExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vareqvalExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VareqvalExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 338, self.RULE_vareqvalExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2680
>
> + self.match(VfrSyntaxParser.VarEqVal)
>
> + self.state = 2681
>
> + self.match(VfrSyntaxParser.Var)
>
> + self.state = 2682
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2683
>
> + localctx.VN = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2684
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2695
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Equal]:
>
> + self.state = 2685
>
> + self.match(VfrSyntaxParser.Equal)
>
> + self.state = 2686
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.LessEqual]:
>
> + self.state = 2687
>
> + self.match(VfrSyntaxParser.LessEqual)
>
> + self.state = 2688
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Less]:
>
> + self.state = 2689
>
> + self.match(VfrSyntaxParser.Less)
>
> + self.state = 2690
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.GreaterEqual]:
>
> + self.state = 2691
>
> + self.match(VfrSyntaxParser.GreaterEqual)
>
> + self.state = 2692
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Greater]:
>
> + self.state = 2693
>
> + self.match(VfrSyntaxParser.Greater)
>
> + self.state = 2694
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class IdeqvalExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = None
>
> + self.I = None # Token
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def vfrQuestionDataFieldName(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,
> 0)
>
> +
>
> +
>
> + def IdEqVal(self):
>
> + return self.getToken(VfrSyntaxParser.IdEqVal, 0)
>
> +
>
> + def Equal(self):
>
> + return self.getToken(VfrSyntaxParser.Equal, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def LessEqual(self):
>
> + return self.getToken(VfrSyntaxParser.LessEqual, 0)
>
> +
>
> + def Less(self):
>
> + return self.getToken(VfrSyntaxParser.Less, 0)
>
> +
>
> + def GreaterEqual(self):
>
> + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
>
> +
>
> + def Greater(self):
>
> + return self.getToken(VfrSyntaxParser.Greater, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_ideqvalExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitIdeqvalExp" ):
>
> + return visitor.visitIdeqvalExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def ideqvalExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.IdeqvalExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 340, self.RULE_ideqvalExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2697
>
> + localctx.I = self.match(VfrSyntaxParser.IdEqVal)
>
> + self.state = 2698
>
> + self.vfrQuestionDataFieldName()
>
> + self.state = 2709
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Equal]:
>
> + self.state = 2699
>
> + self.match(VfrSyntaxParser.Equal)
>
> + self.state = 2700
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.LessEqual]:
>
> + self.state = 2701
>
> + self.match(VfrSyntaxParser.LessEqual)
>
> + self.state = 2702
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Less]:
>
> + self.state = 2703
>
> + self.match(VfrSyntaxParser.Less)
>
> + self.state = 2704
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.GreaterEqual]:
>
> + self.state = 2705
>
> + self.match(VfrSyntaxParser.GreaterEqual)
>
> + self.state = 2706
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Greater]:
>
> + self.state = 2707
>
> + self.match(VfrSyntaxParser.Greater)
>
> + self.state = 2708
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class IdeqidExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = None
>
> + self.I = None # Token
>
> + self.E = None # Token
>
> + self.LE = None # Token
>
> + self.L = None # Token
>
> + self.BE = None # Token
>
> + self.B = None # Token
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def vfrQuestionDataFieldName(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrQuestionDataFieldNameContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,
> i)
>
> +
>
> +
>
> + def IdEqId(self):
>
> + return self.getToken(VfrSyntaxParser.IdEqId, 0)
>
> +
>
> + def Equal(self):
>
> + return self.getToken(VfrSyntaxParser.Equal, 0)
>
> +
>
> + def LessEqual(self):
>
> + return self.getToken(VfrSyntaxParser.LessEqual, 0)
>
> +
>
> + def Less(self):
>
> + return self.getToken(VfrSyntaxParser.Less, 0)
>
> +
>
> + def GreaterEqual(self):
>
> + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
>
> +
>
> + def Greater(self):
>
> + return self.getToken(VfrSyntaxParser.Greater, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_ideqidExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitIdeqidExp" ):
>
> + return visitor.visitIdeqidExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def ideqidExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.IdeqidExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 342, self.RULE_ideqidExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2711
>
> + localctx.I = self.match(VfrSyntaxParser.IdEqId)
>
> + self.state = 2712
>
> + self.vfrQuestionDataFieldName()
>
> + self.state = 2723
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Equal]:
>
> + self.state = 2713
>
> + localctx.E = self.match(VfrSyntaxParser.Equal)
>
> + self.state = 2714
>
> + self.vfrQuestionDataFieldName()
>
> + pass
>
> + elif token in [VfrSyntaxParser.LessEqual]:
>
> + self.state = 2715
>
> + localctx.LE = self.match(VfrSyntaxParser.LessEqual)
>
> + self.state = 2716
>
> + self.vfrQuestionDataFieldName()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Less]:
>
> + self.state = 2717
>
> + localctx.L = self.match(VfrSyntaxParser.Less)
>
> + self.state = 2718
>
> + self.vfrQuestionDataFieldName()
>
> + pass
>
> + elif token in [VfrSyntaxParser.GreaterEqual]:
>
> + self.state = 2719
>
> + localctx.BE = self.match(VfrSyntaxParser.GreaterEqual)
>
> + self.state = 2720
>
> + self.vfrQuestionDataFieldName()
>
> + pass
>
> + elif token in [VfrSyntaxParser.Greater]:
>
> + self.state = 2721
>
> + localctx.B = self.match(VfrSyntaxParser.Greater)
>
> + self.state = 2722
>
> + self.vfrQuestionDataFieldName()
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class IdeqvallistExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = None
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def IdEqValList(self):
>
> + return self.getToken(VfrSyntaxParser.IdEqValList, 0)
>
> +
>
> + def vfrQuestionDataFieldName(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,
> 0)
>
> +
>
> +
>
> + def Equal(self):
>
> + return self.getToken(VfrSyntaxParser.Equal, 0)
>
> +
>
> + def Number(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Number)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Number, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_ideqvallistExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitIdeqvallistExp" ):
>
> + return visitor.visitIdeqvallistExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def ideqvallistExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.IdeqvallistExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 344, self.RULE_ideqvallistExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2725
>
> + self.match(VfrSyntaxParser.IdEqValList)
>
> + self.state = 2726
>
> + self.vfrQuestionDataFieldName()
>
> + self.state = 2727
>
> + self.match(VfrSyntaxParser.Equal)
>
> + self.state = 2729
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while True:
>
> + self.state = 2728
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2731
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if not (_la==VfrSyntaxParser.Number):
>
> + break
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrQuestionDataFieldNameContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.QId = EFI_QUESTION_ID_INVALID
>
> + self.Mask = 0
>
> + self.VarIdStr = ''
>
> + self.Line = None
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrQuestionDataFieldName
>
> +
>
> +
>
> + def copyFrom(self, ctx:ParserRuleContext):
>
> + super().copyFrom(ctx)
>
> + self.QId = ctx.QId
>
> + self.Mask = ctx.Mask
>
> + self.VarIdStr = ctx.VarIdStr
>
> + self.Line = ctx.Line
>
> +
>
> +
>
> +
>
> + class
> VfrQuestionDataFieldNameRule2Context(VfrQuestionDataFieldNameContext)
> :
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.VfrQuestionDataFieldNameContext
>
> + super().__init__(parser)
>
> + self.SN2 = None # Token
>
> + self.copyFrom(ctx)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> + def Dot(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Dot)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Dot, i)
>
> + def arrayName(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
>
> +
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrQuestionDataFieldNameRule2" ):
>
> + return visitor.visitVfrQuestionDataFieldNameRule2(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> + class
> VfrQuestionDataFieldNameRule1Context(VfrQuestionDataFieldNameContext)
> :
>
> +
>
> + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> VfrSyntaxParser.VfrQuestionDataFieldNameContext
>
> + super().__init__(parser)
>
> + self.SN1 = None # Token
>
> + self.I = None # Token
>
> + self.copyFrom(ctx)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrQuestionDataFieldNameRule1" ):
>
> + return visitor.visitVfrQuestionDataFieldNameRule1(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> + def vfrQuestionDataFieldName(self):
>
> +
>
> + localctx = VfrSyntaxParser.VfrQuestionDataFieldNameContext(self,
> self._ctx, self.state)
>
> + self.enterRule(localctx, 346, self.RULE_vfrQuestionDataFieldName)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.state = 2745
>
> + self._errHandler.sync(self)
>
> + la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
>
> + if la_ == 1:
>
> + localctx =
> VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context(self, localctx)
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2733
>
> + localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2734
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2735
>
> + localctx.I = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2736
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> + pass
>
> +
>
> + elif la_ == 2:
>
> + localctx =
> VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context(self, localctx)
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2737
>
> + localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2742
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.Dot:
>
> + self.state = 2738
>
> + self.match(VfrSyntaxParser.Dot)
>
> + self.state = 2739
>
> + self.arrayName()
>
> + self.state = 2744
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + pass
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ArrayNameContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.SubStr = ''
>
> + self.SubStrZ = ''
>
> + self.N = None # Token
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def OpenBracket(self):
>
> + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
>
> +
>
> + def CloseBracket(self):
>
> + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_arrayName
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitArrayName" ):
>
> + return visitor.visitArrayName(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def arrayName(self):
>
> +
>
> + localctx = VfrSyntaxParser.ArrayNameContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 348, self.RULE_arrayName)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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 = 2748
>
> + self.match(VfrSyntaxParser.OpenBracket)
>
> + self.state = 2749
>
> + localctx.N = self.match(VfrSyntaxParser.Number)
>
> + self.state = 2750
>
> + self.match(VfrSyntaxParser.CloseBracket)
>
> +
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class Questionref1ExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_QUESTION_REF1_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def QuestionRef(self):
>
> + return self.getToken(VfrSyntaxParser.QuestionRef, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_questionref1Exp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitQuestionref1Exp" ):
>
> + return visitor.visitQuestionref1Exp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def questionref1Exp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.Questionref1ExpContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 350, self.RULE_questionref1Exp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2753
>
> + self.match(VfrSyntaxParser.QuestionRef)
>
> + self.state = 2754
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + 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 = 2756
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class RulerefExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_RULE_REF_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def RuleRef(self):
>
> + return self.getToken(VfrSyntaxParser.RuleRef, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def StringIdentifier(self):
>
> + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_rulerefExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitRulerefExp" ):
>
> + return visitor.visitRulerefExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def rulerefExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.RulerefExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 352, self.RULE_rulerefExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2758
>
> + self.match(VfrSyntaxParser.RuleRef)
>
> + self.state = 2759
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2760
>
> + self.match(VfrSyntaxParser.StringIdentifier)
>
> + self.state = 2761
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class Stringref1ExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_STRING_REF1_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def StringRef(self):
>
> + return self.getToken(VfrSyntaxParser.StringRef, 0)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_stringref1Exp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitStringref1Exp" ):
>
> + return visitor.visitStringref1Exp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def stringref1Exp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.Stringref1ExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 354, self.RULE_stringref1Exp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2763
>
> + self.match(VfrSyntaxParser.StringRef)
>
> + self.state = 2764
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2770
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.StringToken]:
>
> + self.state = 2765
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2766
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2767
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2768
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Number]:
>
> + self.state = 2769
>
> + self.match(VfrSyntaxParser.Number)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + self.state = 2772
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class PushthisExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_THIS_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def PushThis(self):
>
> + return self.getToken(VfrSyntaxParser.PushThis, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_pushthisExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitPushthisExp" ):
>
> + return visitor.visitPushthisExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def pushthisExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.PushthisExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 356, self.RULE_pushthisExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2774
>
> + self.match(VfrSyntaxParser.PushThis)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class SecurityExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = IfrTreeNode(EFI_IFR_SECURITY_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Security(self):
>
> + return self.getToken(VfrSyntaxParser.Security, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_securityExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitSecurityExp" ):
>
> + return visitor.visitSecurityExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def securityExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.SecurityExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 358, self.RULE_securityExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2776
>
> + self.match(VfrSyntaxParser.Security)
>
> + self.state = 2777
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2778
>
> + self.guidDefinition()
>
> + self.state = 2779
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class NumericVarStoreTypeContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.VarType = None
>
> +
>
> + def NumericSizeOne(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
>
> +
>
> + def NumericSizeTwo(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
>
> +
>
> + def NumericSizeFour(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
>
> +
>
> + def NumericSizeEight(self):
>
> + return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_numericVarStoreType
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitNumericVarStoreType" ):
>
> + return visitor.visitNumericVarStoreType(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def numericVarStoreType(self):
>
> +
>
> + localctx = VfrSyntaxParser.NumericVarStoreTypeContext(self, self._ctx,
> self.state)
>
> + self.enterRule(localctx, 360, self.RULE_numericVarStoreType)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class GetExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.BaseInfo = EFI_VARSTORE_INFO()
>
> + self.Node = IfrTreeNode(EFI_IFR_GET_OP)
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Get(self):
>
> + return self.getToken(VfrSyntaxParser.Get, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStorageVarId(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def BitWiseOr(self):
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def numericVarStoreType(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_getExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitGetExp" ):
>
> + return visitor.visitGetExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def getExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.GetExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 362, self.RULE_getExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2783
>
> + self.match(VfrSyntaxParser.Get)
>
> + self.state = 2784
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2785
>
> + self.vfrStorageVarId(localctx.BaseInfo, False)
>
> + self.state = 2790
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2786
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2787
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2788
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2789
>
> + self.numericVarStoreType()
>
> +
>
> +
>
> + self.state = 2792
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionConstantContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Node = None
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def TrueSymbol(self):
>
> + return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
>
> +
>
> + def FalseSymbol(self):
>
> + return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
>
> +
>
> + def One(self):
>
> + return self.getToken(VfrSyntaxParser.One, 0)
>
> +
>
> + def Ones(self):
>
> + return self.getToken(VfrSyntaxParser.Ones, 0)
>
> +
>
> + def Zero(self):
>
> + return self.getToken(VfrSyntaxParser.Zero, 0)
>
> +
>
> + def Undefined(self):
>
> + return self.getToken(VfrSyntaxParser.Undefined, 0)
>
> +
>
> + def Version(self):
>
> + return self.getToken(VfrSyntaxParser.Version, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionConstant
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionConstant" ):
>
> + return visitor.visitVfrExpressionConstant(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionConstant(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionConstantContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 364, self.RULE_vfrExpressionConstant)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionUnaryOpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = None
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def lengthExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.LengthExpContext,0)
>
> +
>
> +
>
> + def bitwisenotExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.BitwisenotExpContext,0)
>
> +
>
> +
>
> + def question23refExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.Question23refExpContext,0)
>
> +
>
> +
>
> + def stringref2Exp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.Stringref2ExpContext,0)
>
> +
>
> +
>
> + def toboolExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.ToboolExpContext,0)
>
> +
>
> +
>
> + def tostringExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.TostringExpContext,0)
>
> +
>
> +
>
> + def unintExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.UnintExpContext,0)
>
> +
>
> +
>
> + def toupperExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ToupperExpContext,0)
>
> +
>
> +
>
> + def tolwerExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.TolwerExpContext,0)
>
> +
>
> +
>
> + def setExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.SetExpContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionUnaryOp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionUnaryOp" ):
>
> + return visitor.visitVfrExpressionUnaryOp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionUnaryOp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionUnaryOpContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 366, self.RULE_vfrExpressionUnaryOp)
>
> + try:
>
> + self.state = 2806
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Length]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2796
>
> + self.lengthExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.BitWiseNot]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2797
>
> + self.bitwisenotExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.QuestionRefVal]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2798
>
> + self.question23refExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.StringRefVal]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2799
>
> + self.stringref2Exp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.BoolVal]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 2800
>
> + self.toboolExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.StringVal]:
>
> + self.enterOuterAlt(localctx, 6)
>
> + self.state = 2801
>
> + self.tostringExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.UnIntVal]:
>
> + self.enterOuterAlt(localctx, 7)
>
> + self.state = 2802
>
> + self.unintExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ToUpper]:
>
> + self.enterOuterAlt(localctx, 8)
>
> + self.state = 2803
>
> + self.toupperExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.ToLower]:
>
> + self.enterOuterAlt(localctx, 9)
>
> + self.state = 2804
>
> + self.tolwerExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Set]:
>
> + self.enterOuterAlt(localctx, 10)
>
> + self.state = 2805
>
> + self.setExp(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class LengthExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Length(self):
>
> + return self.getToken(VfrSyntaxParser.Length, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_lengthExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitLengthExp" ):
>
> + return visitor.visitLengthExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def lengthExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.LengthExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 368, self.RULE_lengthExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2808
>
> + self.match(VfrSyntaxParser.Length)
>
> + self.state = 2809
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2810
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2811
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class BitwisenotExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def BitWiseNot(self):
>
> + return self.getToken(VfrSyntaxParser.BitWiseNot, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_bitwisenotExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitBitwisenotExp" ):
>
> + return visitor.visitBitwisenotExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def bitwisenotExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.BitwisenotExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 370, self.RULE_bitwisenotExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2813
>
> + self.match(VfrSyntaxParser.BitWiseNot)
>
> + self.state = 2814
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2815
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2816
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class Question23refExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def QuestionRefVal(self):
>
> + return self.getToken(VfrSyntaxParser.QuestionRefVal, 0)
>
> +
>
> + def OpenParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.OpenParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.OpenParen, i)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.CloseParen)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.CloseParen, i)
>
> +
>
> + def DevicePath(self):
>
> + return self.getToken(VfrSyntaxParser.DevicePath, 0)
>
> +
>
> + def StringToken(self):
>
> + return self.getToken(VfrSyntaxParser.StringToken, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Uuid(self):
>
> + return self.getToken(VfrSyntaxParser.Uuid, 0)
>
> +
>
> + def guidDefinition(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_question23refExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitQuestion23refExp" ):
>
> + return visitor.visitQuestion23refExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def question23refExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.Question23refExpContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 372, self.RULE_question23refExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2818
>
> + self.match(VfrSyntaxParser.QuestionRefVal)
>
> + self.state = 2819
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2827
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.DevicePath:
>
> + self.state = 2820
>
> + self.match(VfrSyntaxParser.DevicePath)
>
> + self.state = 2821
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2822
>
> + self.match(VfrSyntaxParser.StringToken)
>
> + self.state = 2823
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2824
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2825
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + self.state = 2826
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2834
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.Uuid:
>
> + self.state = 2829
>
> + self.match(VfrSyntaxParser.Uuid)
>
> + self.state = 2830
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2831
>
> + self.guidDefinition()
>
> + self.state = 2832
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2836
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2837
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class Stringref2ExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def StringRefVal(self):
>
> + return self.getToken(VfrSyntaxParser.StringRefVal, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_stringref2Exp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitStringref2Exp" ):
>
> + return visitor.visitStringref2Exp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def stringref2Exp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.Stringref2ExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 374, self.RULE_stringref2Exp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2839
>
> + self.match(VfrSyntaxParser.StringRefVal)
>
> + self.state = 2840
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2841
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2842
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ToboolExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def BoolVal(self):
>
> + return self.getToken(VfrSyntaxParser.BoolVal, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_toboolExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitToboolExp" ):
>
> + return visitor.visitToboolExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def toboolExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.ToboolExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 376, self.RULE_toboolExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2844
>
> + self.match(VfrSyntaxParser.BoolVal)
>
> + self.state = 2845
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2846
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2847
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class TostringExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def StringVal(self):
>
> + return self.getToken(VfrSyntaxParser.StringVal, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_tostringExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitTostringExp" ):
>
> + return visitor.visitTostringExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def tostringExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.TostringExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 378, self.RULE_tostringExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2849
>
> + self.match(VfrSyntaxParser.StringVal)
>
> + self.state = 2854
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.T__14:
>
> + self.state = 2850
>
> + self.match(VfrSyntaxParser.T__14)
>
> + self.state = 2851
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2852
>
> + self.match(VfrSyntaxParser.Number)
>
> + self.state = 2853
>
> + self.match(VfrSyntaxParser.Comma)
>
> +
>
> +
>
> + self.state = 2856
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2857
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2858
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class UnintExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def UnIntVal(self):
>
> + return self.getToken(VfrSyntaxParser.UnIntVal, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_unintExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitUnintExp" ):
>
> + return visitor.visitUnintExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def unintExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.UnintExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 380, self.RULE_unintExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2860
>
> + self.match(VfrSyntaxParser.UnIntVal)
>
> + self.state = 2861
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2862
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2863
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ToupperExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def ToUpper(self):
>
> + return self.getToken(VfrSyntaxParser.ToUpper, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_toupperExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitToupperExp" ):
>
> + return visitor.visitToupperExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def toupperExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.ToupperExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 382, self.RULE_toupperExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2865
>
> + self.match(VfrSyntaxParser.ToUpper)
>
> + self.state = 2866
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2867
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2868
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class TolwerExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def ToLower(self):
>
> + return self.getToken(VfrSyntaxParser.ToLower, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_tolwerExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitTolwerExp" ):
>
> + return visitor.visitTolwerExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def tolwerExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.TolwerExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 384, self.RULE_tolwerExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2870
>
> + self.match(VfrSyntaxParser.ToLower)
>
> + self.state = 2871
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2872
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2873
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class SetExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.BaseInfo = EFI_VARSTORE_INFO()
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Set(self):
>
> + return self.getToken(VfrSyntaxParser.Set, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStorageVarId(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
>
> +
>
> +
>
> + def Comma(self):
>
> + return self.getToken(VfrSyntaxParser.Comma, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def BitWiseOr(self):
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def numericVarStoreType(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_setExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitSetExp" ):
>
> + return visitor.visitSetExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def setExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.SetExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 386, self.RULE_setExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2875
>
> + self.match(VfrSyntaxParser.Set)
>
> + self.state = 2876
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2877
>
> + self.vfrStorageVarId(localctx.BaseInfo, False)
>
> + self.state = 2882
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + if _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2878
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2879
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2880
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2881
>
> + self.numericVarStoreType()
>
> +
>
> +
>
> + self.state = 2884
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2885
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2886
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionTernaryOpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = None
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def conditionalExp(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.ConditionalExpContext,0)
>
> +
>
> +
>
> + def findExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.FindExpContext,0)
>
> +
>
> +
>
> + def midExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.MidExpContext,0)
>
> +
>
> +
>
> + def tokenExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.TokenExpContext,0)
>
> +
>
> +
>
> + def spanExp(self):
>
> + return self.getTypedRuleContext(VfrSyntaxParser.SpanExpContext,0)
>
> +
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionTernaryOp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionTernaryOp" ):
>
> + return visitor.visitVfrExpressionTernaryOp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionTernaryOp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionTernaryOpContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 388, self.RULE_vfrExpressionTernaryOp)
>
> + try:
>
> + self.state = 2893
>
> + self._errHandler.sync(self)
>
> + token = self._input.LA(1)
>
> + if token in [VfrSyntaxParser.Cond]:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2888
>
> + self.conditionalExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Find]:
>
> + self.enterOuterAlt(localctx, 2)
>
> + self.state = 2889
>
> + self.findExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Mid]:
>
> + self.enterOuterAlt(localctx, 3)
>
> + self.state = 2890
>
> + self.midExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Tok]:
>
> + self.enterOuterAlt(localctx, 4)
>
> + self.state = 2891
>
> + self.tokenExp(ExpInfo)
>
> + pass
>
> + elif token in [VfrSyntaxParser.Span]:
>
> + self.enterOuterAlt(localctx, 5)
>
> + self.state = 2892
>
> + self.spanExp(ExpInfo)
>
> + pass
>
> + else:
>
> + raise NoViableAltException(self)
>
> +
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class ConditionalExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Cond(self):
>
> + return self.getToken(VfrSyntaxParser.Cond, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def Colon(self):
>
> + return self.getToken(VfrSyntaxParser.Colon, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_conditionalExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitConditionalExp" ):
>
> + return visitor.visitConditionalExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def conditionalExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.ConditionalExpContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 390, self.RULE_conditionalExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2895
>
> + self.match(VfrSyntaxParser.Cond)
>
> + self.state = 2896
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2897
>
> + 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
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class FindExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Find(self):
>
> + return self.getToken(VfrSyntaxParser.Find, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def findFormat(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.FindFormatContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.FindFormatContext,i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_findExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitFindExp" ):
>
> + return visitor.visitFindExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def findExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.FindExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 392, self.RULE_findExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2904
>
> + self.match(VfrSyntaxParser.Find)
>
> + self.state = 2905
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2906
>
> + self.findFormat(ExpInfo)
>
> + self.state = 2911
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2907
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2908
>
> + self.findFormat(ExpInfo)
>
> + self.state = 2913
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2914
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2915
>
> + 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
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class FindFormatContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Format = 0
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Sensitive(self):
>
> + return self.getToken(VfrSyntaxParser.Sensitive, 0)
>
> +
>
> + def Insensitive(self):
>
> + return self.getToken(VfrSyntaxParser.Insensitive, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_findFormat
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitFindFormat" ):
>
> + return visitor.visitFindFormat(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def findFormat(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.FindFormatContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 394, self.RULE_findFormat)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2922
>
> + _la = self._input.LA(1)
>
> + if not(_la==VfrSyntaxParser.Insensitive or
> _la==VfrSyntaxParser.Sensitive):
>
> + self._errHandler.recoverInline(self)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class MidExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Mid(self):
>
> + return self.getToken(VfrSyntaxParser.Mid, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_midExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitMidExp" ):
>
> + return visitor.visitMidExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def midExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.MidExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 396, self.RULE_midExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2924
>
> + self.match(VfrSyntaxParser.Mid)
>
> + self.state = 2925
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2926
>
> + 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
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class TokenExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Tok(self):
>
> + return self.getToken(VfrSyntaxParser.Tok, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_tokenExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitTokenExp" ):
>
> + return visitor.visitTokenExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def tokenExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.TokenExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 398, self.RULE_tokenExp)
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2933
>
> + self.match(VfrSyntaxParser.Tok)
>
> + self.state = 2934
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2935
>
> + 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
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class SpanExpContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Span(self):
>
> + return self.getToken(VfrSyntaxParser.Span, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def FLAGS(self):
>
> + return self.getToken(VfrSyntaxParser.FLAGS, 0)
>
> +
>
> + def spanFlags(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.SpanFlagsContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.SpanFlagsContext,i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def vfrStatementExpressionSub(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> t)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> i)
>
> +
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def BitWiseOr(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.BitWiseOr)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_spanExp
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitSpanExp" ):
>
> + return visitor.visitSpanExp(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def spanExp(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.SpanExpContext(self, self._ctx, self.state,
> ExpInfo)
>
> + self.enterRule(localctx, 400, self.RULE_spanExp)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2942
>
> + self.match(VfrSyntaxParser.Span)
>
> + self.state = 2943
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2944
>
> + self.match(VfrSyntaxParser.FLAGS)
>
> + self.state = 2945
>
> + self.match(VfrSyntaxParser.T__5)
>
> + self.state = 2946
>
> + self.spanFlags()
>
> + self.state = 2951
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> + while _la==VfrSyntaxParser.BitWiseOr:
>
> + self.state = 2947
>
> + self.match(VfrSyntaxParser.BitWiseOr)
>
> + self.state = 2948
>
> + self.spanFlags()
>
> + self.state = 2953
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2954
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2955
>
> + 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
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class SpanFlagsContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.Flag = 0
>
> +
>
> + def Number(self):
>
> + return self.getToken(VfrSyntaxParser.Number, 0)
>
> +
>
> + def LastNonMatch(self):
>
> + return self.getToken(VfrSyntaxParser.LastNonMatch, 0)
>
> +
>
> + def FirstNonMatch(self):
>
> + return self.getToken(VfrSyntaxParser.FirstNonMatch, 0)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_spanFlags
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitSpanFlags" ):
>
> + return visitor.visitSpanFlags(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def spanFlags(self):
>
> +
>
> + localctx = VfrSyntaxParser.SpanFlagsContext(self, self._ctx, self.state)
>
> + self.enterRule(localctx, 402, self.RULE_spanFlags)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + 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)
>
> + else:
>
> + self._errHandler.reportMatch(self)
>
> + self.consume()
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> +
>
> +
>
> + class VfrExpressionMapContext(ParserRuleContext):
>
> +
>
> + def __init__(self, parser, parent:ParserRuleContext=None,
> invokingState:int=-1, ExpInfo=None):
>
> + super().__init__(parent, invokingState)
>
> + self.parser = parser
>
> + self.ExpInfo = None
>
> + self.Nodes = []
>
> + self.Node = IfrTreeNode()
>
> + self.ExpInfo = ExpInfo
>
> +
>
> + def Map(self):
>
> + return self.getToken(VfrSyntaxParser.Map, 0)
>
> +
>
> + def OpenParen(self):
>
> + return self.getToken(VfrSyntaxParser.OpenParen, 0)
>
> +
>
> + def vfrStatementExpressionSub(self):
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> 0)
>
> +
>
> +
>
> + def Colon(self):
>
> + return self.getToken(VfrSyntaxParser.Colon, 0)
>
> +
>
> + def CloseParen(self):
>
> + return self.getToken(VfrSyntaxParser.CloseParen, 0)
>
> +
>
> + def vfrStatementExpression(self, i:int=None):
>
> + if i is None:
>
> + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionContext)
>
> + else:
>
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,i)
>
> +
>
> +
>
> + def Comma(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Comma)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Comma, i)
>
> +
>
> + def Semicolon(self, i:int=None):
>
> + if i is None:
>
> + return self.getTokens(VfrSyntaxParser.Semicolon)
>
> + else:
>
> + return self.getToken(VfrSyntaxParser.Semicolon, i)
>
> +
>
> + def getRuleIndex(self):
>
> + return VfrSyntaxParser.RULE_vfrExpressionMap
>
> +
>
> + def accept(self, visitor:ParseTreeVisitor):
>
> + if hasattr( visitor, "visitVfrExpressionMap" ):
>
> + return visitor.visitVfrExpressionMap(self)
>
> + else:
>
> + return visitor.visitChildren(self)
>
> +
>
> +
>
> +
>
> +
>
> + def vfrExpressionMap(self, ExpInfo):
>
> +
>
> + localctx = VfrSyntaxParser.VfrExpressionMapContext(self, self._ctx,
> self.state, ExpInfo)
>
> + self.enterRule(localctx, 404, self.RULE_vfrExpressionMap)
>
> + self._la = 0 # Token type
>
> + try:
>
> + self.enterOuterAlt(localctx, 1)
>
> + self.state = 2964
>
> + self.match(VfrSyntaxParser.Map)
>
> + self.state = 2965
>
> + self.match(VfrSyntaxParser.OpenParen)
>
> + self.state = 2966
>
> + self.vfrStatementExpressionSub(localctx.Nodes)
>
> + self.state = 2967
>
> + self.match(VfrSyntaxParser.Colon)
>
> + 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 = 2968
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2969
>
> + self.match(VfrSyntaxParser.Comma)
>
> + self.state = 2970
>
> + self.vfrStatementExpression(localctx.Node)
>
> + self.state = 2971
>
> + self.match(VfrSyntaxParser.Semicolon)
>
> + self.state = 2977
>
> + self._errHandler.sync(self)
>
> + _la = self._input.LA(1)
>
> +
>
> + self.state = 2978
>
> + self.match(VfrSyntaxParser.CloseParen)
>
> + except RecognitionException as re:
>
> + localctx.exception = re
>
> + self._errHandler.reportError(self, re)
>
> + self._errHandler.recover(self, re)
>
> + finally:
>
> + self.exitRule()
>
> + return localctx
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> new file mode 100644
> index 0000000000..622e63347c
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> @@ -0,0 +1,5504 @@
> +## @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/__init__.py
> b/BaseTools/Source/Python/VfrCompiler/__init__.py
> new file mode 100644
> index 0000000000..72d3a47bb7
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/__init__.py
> @@ -0,0 +1 @@
> +__all__ = ["VfrCompiler"]
>
> --
> 2.39.1.windows.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#110914): https://edk2.groups.io/g/devel/message/110914
Mute This Topic: https://groups.io/mt/102463460/7686176
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [rebecca@openfw.io]
-=-=-=-=-=-=-=-=-=-=-=-
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [edk2-devel] [PATCH] BaseTools: Python VfrCompiler implementation
[not found] ` <1795A9DEEBB01830.6123@groups.io>
@ 2023-11-09 0:25 ` Yuwei Chen
0 siblings, 0 replies; 4+ messages in thread
From: Yuwei Chen @ 2023-11-09 0:25 UTC (permalink / raw)
To: devel@edk2.groups.io, Chen, Christine, Rebecca Cran, Gao, Liming,
Zimmer, Vincent
Cc: Feng, Bob C, Yang, Yuting2, Hartung, Stephen, Narayanan, Bimod,
He, Haiyang
+ Cc Bimod Haiyang
> -----Original Message-----
> From: devel@edk2.groups.io <devel@edk2.groups.io> On Behalf Of Yuwei
> Chen
> Sent: Wednesday, November 8, 2023 9:46 PM
> To: Rebecca Cran <rebecca@bsdio.com>; Gao, Liming
> <gaoliming@byosoft.com.cn>; Zimmer, Vincent <vincent.zimmer@intel.com>
> Cc: Feng, Bob C <bob.c.feng@intel.com>; Yang, Yuting2
> <yuting2.yang@intel.com>; devel@edk2.groups.io; Hartung, Stephen
> <stephen.hartung@intel.com>
> Subject: Re: [edk2-devel] [PATCH] BaseTools: Python VfrCompiler
> implementation
>
> Hi Liming and Cran,
>
> Could you help on quick reviewing this new VfrCompiler python tool, it has
> the same functions with origin C version VfrCompiler, meanwhile it supports
> more new features such as generated Vfr files config info into Yaml format.
>
> This feature is urgent for us to use, and we really hope it can be merged into
> this stable tag. This patch is linked to the edk2-basetools PR:
> https://github.com/tianocore/edk2-basetools/pull/109. We list all the known
> issues which will be enhanced in the ReadMe file. And will enhance them one
> by one after the patch merged.
>
> For the code quality, in this patch, the new tool is not enabled in build
> process, it just saves in the basetools python folder, which will not influence
> the current edk2 behaviors. We will enable it with a new patch when
> everything is ready.
>
> Many thanks~
>
> Hi Vincent, please help add more information if necessary~ Thanks a lot~
>
> Thanks,
> Christine
> > -----Original Message-----
> > From: Yang, Yuting2 <yuting2.yang@intel.com>
> > Sent: Wednesday, November 8, 2023 8:46 PM
> > To: devel@edk2.groups.io
> > Cc: Rebecca Cran <rebecca@bsdio.com>; Gao, Liming
> > <gaoliming@byosoft.com.cn>; Feng, Bob C <bob.c.feng@intel.com>; Chen,
> > Christine <yuwei.chen@intel.com>
> > Subject: [PATCH] BaseTools: Python VfrCompiler implementation
> >
> > 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>
> > Signed-off-by: Yuwei Chen <yuwei.chen@intel.com>
> > ---
> > .../Source/Python/VfrCompiler/IfrCommon.py | 100 +
> > .../Source/Python/VfrCompiler/IfrCompiler.py | 586 +
> > .../Source/Python/VfrCompiler/IfrCtypes.py | 1811 ++
> > .../Source/Python/VfrCompiler/IfrError.py | 153 +
> > .../Source/Python/VfrCompiler/IfrFormPkg.py | 2937 +++
> > .../Python/VfrCompiler/IfrPreProcess.py | 245 +
> > .../Source/Python/VfrCompiler/IfrTree.py | 1132 +
> > .../Source/Python/VfrCompiler/IfrUtility.py | 2226 ++
> > BaseTools/Source/Python/VfrCompiler/Readme.md | 68 +
> > .../Source/Python/VfrCompiler/VfrSyntax.g4 | 1921 ++
> > .../Python/VfrCompiler/VfrSyntaxLexer.py | 1708 ++
> > .../Python/VfrCompiler/VfrSyntaxParser.py | 20475 ++++++++++++++++
> > .../Python/VfrCompiler/VfrSyntaxVisitor.py | 5504 +++++
> > .../Source/Python/VfrCompiler/__init__.py | 1 +
> > 14 files changed, 38867 insertions(+)
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrError.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
> > create mode 100644
> BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrTree.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/Readme.md
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> > create mode 100644
> > BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> > create mode 100644
> > BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> > create mode 100644
> > BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> > create mode 100644 BaseTools/Source/Python/VfrCompiler/__init__.py
> >
> > diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> > b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> > new file mode 100644
> > index 0000000000..7425abe9a9
> > --- /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..15bf3d59ba
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> > @@ -0,0 +1,586 @@
> > +## @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.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..a7f7a32a27
> > --- /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..c50288e9e5
> > --- /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..35f50b0cef
> > --- /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..ed454cdcf3
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> > @@ -0,0 +1,245 @@
> > +## @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 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._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)
> >
> > + return UniDict
> >
> > +
> >
> > + 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..faa2e4677d
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/IfrTree.py
> > @@ -0,0 +1,1132 @@
> > +## @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()
> >
> > + 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 _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
> >
> > diff --git a/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> > b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> > new file mode 100644
> > index 0000000000..3c5cec25ce
> > --- /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
> > new file mode 100644
> > index 0000000000..7bdc85023a
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/Readme.md
> > @@ -0,0 +1,68 @@
> > +# 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/VfrSyntax.g4
> > b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> > new file mode 100644
> > index 0000000000..2895377b74
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> > @@ -0,0 +1,1921 @@
> > +//// @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
> > new file mode 100644
> > index 0000000000..0e165a0446
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> > @@ -0,0 +1,1708 @@
> > +# Generated from VfrSyntax.g4 by ANTLR 4.7.2
> >
> > +
> >
> > +import sys
> >
> > +from antlr4 import *
> >
> > +from io import StringIO
> >
> > +from typing import TextIO
> >
> > +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\2\u010
> > 2")
> >
> > + buf.write("\u0ab7\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
> >
> > + buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
> >
> > + buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
> >
> > + buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
> >
> > + buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
> >
> > + buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
> >
> > + buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
> >
> > + buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
> >
> > + buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
> >
> > + buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
> >
> > + buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\t")
> >
> > +
> > buf.write("L\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\t")
> >
> > + buf.write("U\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4")
> >
> > + buf.write("^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4")
> >
> > + buf.write("g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4")
> >
> > + buf.write("p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4")
> >
> > + buf.write("y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080")
> >
> > +
> > buf.write("\t\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083")
> >
> > +
> > buf.write("\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087")
> >
> > +
> > buf.write("\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a")
> >
> > +
> > buf.write("\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e")
> >
> > +
> > buf.write("\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091")
> >
> > +
> > buf.write("\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095")
> >
> > +
> > buf.write("\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098")
> >
> > +
> > buf.write("\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c")
> >
> > +
> > buf.write("\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f")
> >
> > +
> > buf.write("\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3")
> >
> > +
> > buf.write("\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6")
> >
> > +
> > buf.write("\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa")
> >
> > +
> > buf.write("\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad")
> >
> > +
> > buf.write("\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1")
> >
> > +
> > buf.write("\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4")
> >
> > +
> > buf.write("\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8")
> >
> > +
> > buf.write("\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb")
> >
> > +
> > buf.write("\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf")
> >
> > +
> > buf.write("\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2")
> >
> > +
> > buf.write("\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6")
> >
> > +
> > buf.write("\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9")
> >
> > +
> > buf.write("\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd")
> >
> > +
> > buf.write("\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0")
> >
> > +
> > buf.write("\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4")
> >
> > +
> > buf.write("\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7")
> >
> > +
> >
> buf.write("\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db")
> >
> > +
> > buf.write("\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de")
> >
> > +
> > buf.write("\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2")
> >
> > +
> > buf.write("\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5")
> >
> > +
> > buf.write("\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9")
> >
> > +
> > buf.write("\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec")
> >
> > +
> > buf.write("\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0")
> >
> > +
> buf.write("\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3")
> >
> > +
> buf.write("\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7")
> >
> > +
> buf.write("\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa")
> >
> > +
> buf.write("\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe")
> >
> > +
> > buf.write("\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101")
> >
> > + buf.write("\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3")
> >
> > + buf.write("\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6")
> >
> > + buf.write("\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
> >
> > + buf.write("\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n")
> >
> > + buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3")
> >
> > + buf.write("\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20")
> >
> > +
> buf.write("\3\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\3\22")
> >
> > +
> buf.write("\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23")
> >
> > +
> buf.write("\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
> >
> > +
> buf.write("\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30\3\31")
> >
> > +
> buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36")
> >
> > + buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3")
> >
> > + buf.write("%\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3")
> >
> > +
> buf.write(")\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3")
> >
> > + buf.write("+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3")
> >
> > + buf.write("-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60")
> >
> > +
> buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61")
> >
> > +
> buf.write("\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
> >
> > +
> buf.write("\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63")
> >
> > +
> buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64")
> >
> > +
> buf.write("\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
> >
> > +
> buf.write("\3\65\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67")
> >
> > +
> buf.write("\3\67\3\67\3\67\38\38\38\38\38\38\38\38\38\39\39\39\3")
> >
> > + buf.write("9\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;\3")
> >
> > + buf.write(";\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3")
> >
> > +
> >
> buf.write(">\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@\3@\3")
> >
> > +
> > buf.write("A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3")
> >
> > +
> > buf.write("C\3D\3D\3D\3D\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3")
> >
> > +
> > buf.write("G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3")
> >
> > + buf.write("I\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3L\3")
> >
> > +
> >
> buf.write("L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\
> > 3")
> >
> > +
> >
> buf.write("N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3N\3O\3O\3"
> > )
> >
> > +
> >
> buf.write("O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3")
> >
> > +
> > buf.write("Q\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3")
> >
> > +
> > buf.write("T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3")
> >
> > +
> >
> buf.write("V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\
> > 3W\3")
> >
> > +
> > buf.write("W\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3")
> >
> > + buf.write("Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3")
> >
> > + buf.write("[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
> >
> > + buf.write("\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3")
> >
> > + buf.write("^\3^\3^\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3")
> >
> > +
> buf.write("`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3")
> >
> > +
> > buf.write("c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3")
> >
> > + buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3f\3f\3f\3g\3g\3")
> >
> > + buf.write("g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3")
> >
> > + buf.write("i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3k\3k\3")
> >
> > + buf.write("k\3k\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3")
> >
> > +
> > buf.write("m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3")
> >
> > +
> > buf.write("o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3")
> >
> > +
> > buf.write("p\3p\3p\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3q\3r\3r\3r\3r\3")
> >
> > + buf.write("r\3r\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3u\3u\3u\3u\3")
> >
> > +
> > buf.write("u\3u\3u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3v\3v\3")
> >
> > +
> > buf.write("v\3v\3v\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3w\3")
> >
> > +
> >
> buf.write("w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3"
> > )
> >
> > + buf.write("x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3y\3y\3y\3z\3z\3")
> >
> > + buf.write("z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3")
> >
> > + buf.write("{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3")
> >
> > + buf.write("|\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3")
> >
> > +
> buf.write("~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3")
> >
> > +
> > buf.write("\177\3\177\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080")
> >
> > +
> >
> buf.write("\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0081\3\u0081")
> >
> > +
> >
> buf.write("\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081")
> >
> > +
> >
> buf.write("\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082")
> >
> > +
> >
> buf.write("\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083")
> >
> > +
> >
> buf.write("\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084")
> >
> > +
> >
> buf.write("\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085")
> >
> > +
> >
> buf.write("\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0086")
> >
> > +
> >
> buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087")
> >
> > +
> >
> buf.write("\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088")
> >
> > +
> >
> buf.write("\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089")
> >
> > +
> >
> buf.write("\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008a")
> >
> > +
> >
> buf.write("\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
> >
> > +
> > buf.write("\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d")
> >
> > +
> >
> buf.write("\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e")
> >
> > +
> > buf.write("\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f")
> >
> > +
> > buf.write("\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090")
> >
> > +
> >
> buf.write("\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090")
> >
> > +
> >
> buf.write("\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091")
> >
> > +
> >
> buf.write("\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092")
> >
> > +
> >
> buf.write("\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094")
> >
> > +
> >
> buf.write("\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094")
> >
> > +
> >
> buf.write("\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096")
> >
> > +
> >
> buf.write("\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097")
> >
> > +
> >
> buf.write("\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098")
> >
> > +
> >
> buf.write("\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098")
> >
> > +
> >
> buf.write("\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
> >
> > +
> >
> buf.write("\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099")
> >
> > +
> >
> buf.write("\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
> >
> > +
> >
> buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
> >
> > +
> >
> buf.write("\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b")
> >
> > +
> >
> buf.write("\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c")
> >
> > +
> > buf.write("\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d")
> >
> > +
> >
> buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d")
> >
> > +
> >
> buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e")
> >
> > +
> > buf.write("\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009f\3\u009f")
> >
> > +
> > buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
> >
> > +
> > buf.write("\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
> >
> > +
> > buf.write("\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0")
> >
> > +
> >
> buf.write("\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1")
> >
> > +
> >
> buf.write("\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2")
> >
> > +
> >
> buf.write("\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3")
> >
> > +
> >
> buf.write("\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a4")
> >
> > +
> >
> buf.write("\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4")
> >
> > +
> >
> buf.write("\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
> >
> > +
> >
> buf.write("\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5")
> >
> > +
> >
> buf.write("\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6")
> >
> > +
> >
> buf.write("\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
> >
> > +
> >
> buf.write("\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8")
> >
> > +
> >
> buf.write("\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8")
> >
> > +
> >
> buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa")
> >
> > +
> >
> buf.write("\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab")
> >
> > +
> >
> buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab")
> >
> > +
> > buf.write("\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
> >
> > +
> > buf.write("\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad")
> >
> > +
> >
> buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad")
> >
> > +
> >
> buf.write("\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae")
> >
> > +
> >
> buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae")
> >
> > +
> > buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00af")
> >
> > +
> > buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af")
> >
> > +
> > buf.write("\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00b0\3\u00b0")
> >
> > +
> >
> buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
> >
> > +
> >
> buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1")
> >
> > +
> >
> buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1")
> >
> > +
> >
> buf.write("\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2")
> >
> > +
> >
> buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
> >
> > +
> >
> buf.write("\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2")
> >
> > +
> >
> buf.write("\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
> >
> > +
> >
> buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
> >
> > +
> >
> buf.write("\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3")
> >
> > +
> >
> buf.write("\3\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4")
> >
> > +
> >
> buf.write("\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5")
> >
> > +
> >
> buf.write("\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5")
> >
> > +
> >
> buf.write("\3\u00b5\3\u00b5\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
> >
> > +
> >
> buf.write("\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b6")
> >
> > +
> >
> buf.write("\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
> >
> > +
> >
> buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7")
> >
> > +
> >
> buf.write("\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
> >
> > +
> >
> buf.write("\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8")
> >
> > +
> >
> buf.write("\3\u00b8\3\u00b8\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
> >
> > +
> >
> buf.write("\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9")
> >
> > +
> >
> buf.write("\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
> >
> > +
> >
> buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00ba")
> >
> > +
> >
> buf.write("\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb")
> >
> > +
> >
> buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"
> > )
> >
> > +
> >
> buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc")
> >
> > +
> > buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
> >
> > +
> > buf.write("\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc")
> >
> > +
> >
> buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd"
> > )
> >
> > +
> >
> buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be"
> > )
> >
> > +
> >
> buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
> >
> > +
> >
> buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
> >
> > +
> > buf.write("\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf")
> >
> > +
> > buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0")
> >
> > +
> > buf.write("\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2")
> >
> > +
> > buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3")
> >
> > +
> > buf.write("\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4")
> >
> > +
> > buf.write("\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6")
> >
> > +
> > buf.write("\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
> >
> > +
> > buf.write("\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8")
> >
> > +
> > buf.write("\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9\3\u00c9")
> >
> > +
> > buf.write("\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca")
> >
> > +
> > buf.write("\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
> >
> > +
> > buf.write("\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cb")
> >
> > +
> > buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc")
> >
> > +
> > buf.write("\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd")
> >
> > +
> > buf.write("\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00ce")
> >
> > +
> > buf.write("\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce")
> >
> > +
> > buf.write("\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf")
> >
> > +
> > buf.write("\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0")
> >
> > +
> >
> buf.write("\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1")
> >
> > +
> >
> buf.write("\3\u00d1\3\u00d1\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2")
> >
> > +
> >
> buf.write("\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3")
> >
> > +
> >
> buf.write("\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5")
> >
> > +
> >
> buf.write("\3\u00d5\3\u00d5\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6")
> >
> > +
> >
> buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7")
> >
> > +
> >
> buf.write("\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8")
> >
> > +
> >
> buf.write("\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9")
> >
> > +
> >
> buf.write("\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da")
> >
> > +
> >
> buf.write("\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc")
> >
> > +
> >
> buf.write("\3\u00dc\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de")
> >
> > +
> > buf.write("\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df")
> >
> > +
> >
> buf.write("\3\u00df\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0")
> >
> > +
> >
> buf.write("\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1")
> >
> > +
> >
> buf.write("\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2")
> >
> > +
> >
> buf.write("\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2")
> >
> > +
> >
> buf.write("\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3")
> >
> > +
> >
> buf.write("\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4")
> >
> > +
> >
> buf.write("\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5")
> >
> > +
> >
> buf.write("\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6")
> >
> > +
> >
> buf.write("\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
> >
> > +
> >
> buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7")
> >
> > +
> >
> buf.write("\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
> >
> > +
> >
> buf.write("\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8")
> >
> > +
> >
> buf.write("\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00ea")
> >
> > +
> >
> buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea")
> >
> > +
> >
> buf.write("\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb")
> >
> > +
> >
> buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb")
> >
> > +
> > buf.write("\3\u00eb\3\u00eb\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
> >
> > +
> > buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec")
> >
> > +
> > buf.write("\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed")
> >
> > +
> >
> buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
> >
> > +
> >
> buf.write("\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed")
> >
> > +
> >
> buf.write("\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
> >
> > +
> >
> buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee")
> >
> > +
> > buf.write("\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
> >
> > +
> > buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef")
> >
> > +
> > buf.write("\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00f0\3\u00f0\3\u00f0")
> >
> > +
> > buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0")
> >
> > +
> > buf.write("\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1")
> >
> > +
> > buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1")
> >
> > +
> > buf.write("\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f2")
> >
> > +
> > buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
> >
> > +
> > buf.write("\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f2")
> >
> > +
> > buf.write("\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
> >
> > +
> > buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3")
> >
> > +
> > buf.write("\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4")
> >
> > +
> > buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
> >
> > +
> > buf.write("\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4")
> >
> > +
> > buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5")
> >
> > +
> > buf.write("\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6")
> >
> > +
> > buf.write("\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6")
> >
> > +
> > buf.write("\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
> >
> > +
> > buf.write("\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f7")
> >
> > +
> > buf.write("\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
> >
> > +
> > buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8")
> >
> > +
> > buf.write("\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00f9")
> >
> > +
> buf.write("\3\u00f9\6\u00f9\u0a44\n\u00f9\r\u00f9\16\u00f9\u0a45")
> >
> > +
> buf.write("\3\u00f9\6\u00f9\u0a49\n\u00f9\r\u00f9\16\u00f9\u0a4a")
> >
> > +
> > buf.write("\5\u00f9\u0a4d\n\u00f9\3\u00fa\3\u00fa\7\u00fa\u0a51\n")
> >
> > +
> buf.write("\u00fa\f\u00fa\16\u00fa\u0a54\13\u00fa\3\u00fb\3\u00fb")
> >
> > +
> buf.write("\5\u00fb\u0a58\n\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fb")
> >
> > +
> buf.write("\3\u00fb\3\u00fb\3\u00fb\3\u00fb\7\u00fb\u0a62\n\u00fb")
> >
> > +
> > buf.write("\f\u00fb\16\u00fb\u0a65\13\u00fb\3\u00fb\3\u00fb\3\u00fc")
> >
> > + buf.write("\3\u00fc\5\u00fc\u0a6b\n\u00fc\3\u00fc\3\u00fc\3\u00fc")
> >
> > + buf.write("\3\u00fc\3\u00fc\3\u00fc\7\u00fc\u0a73\n\u00fc\f\u00fc")
> >
> > +
> > buf.write("\16\u00fc\u0a76\13\u00fc\3\u00fc\3\u00fc\3\u00fd\3\u00fd")
> >
> > +
> buf.write("\5\u00fd\u0a7c\n\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd")
> >
> > +
> buf.write("\3\u00fd\3\u00fd\3\u00fd\3\u00fd\3\u00fd\7\u00fd\u0a87")
> >
> > +
> > buf.write("\n\u00fd\f\u00fd\16\u00fd\u0a8a\13\u00fd\3\u00fd\3\u00fd")
> >
> > + buf.write("\3\u00fe\6\u00fe\u0a8f\n\u00fe\r\u00fe\16\u00fe\u0a90")
> >
> > + buf.write("\3\u00fe\3\u00fe\3\u00ff\3\u00ff\5\u00ff\u0a97\n\u00ff")
> >
> > + buf.write("\3\u00ff\5\u00ff\u0a9a\n\u00ff\3\u00ff\3\u00ff\3\u0100")
> >
> > +
> > buf.write("\3\u0100\3\u0100\3\u0100\7\u0100\u0aa2\n\u0100\f\u0100")
> >
> > +
> >
> buf.write("\16\u0100\u0aa5\13\u0100\3\u0100\3\u0100\3\u0101\3\u0101")
> >
> > +
> >
> buf.write("\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\3\u0101\7\u0101")
> >
> > +
> > buf.write("\u0ab1\n\u0101\f\u0101\16\u0101\u0ab4\13\u0101\3\u0101")
> >
> > + buf.write("\3\u0101\2\2\u0102\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n")
> >
> > +
> buf.write("\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'")
> >
> > + buf.write("\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ")
> >
> > + buf.write("?!A\"C#E$G%I&K\'M(O)Q*S+U,W-
> > Y.[/]\60_\61a\62c\63e\64g")
> >
> > +
> > buf.write("\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085")
> >
> > +
> >
> buf.write("D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095"
> > )
> >
> > +
> >
> buf.write("L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a
> > 5")
> >
> > +
> >
> buf.write("T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5
> > ")
> >
> > +
> >
> buf.write("\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5")
> >
> > +
> > buf.write("d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5")
> >
> > +
> >
> buf.write("l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5
> > ")
> >
> > +
> >
> buf.write("t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1z\u00f3{\u00f5")
> >
> > +
> > buf.write("|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff\u0081\u0101")
> >
> > +
> > buf.write("\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\u0086")
> >
> > +
> > buf.write("\u010b\u0087\u010d\u0088\u010f\u0089\u0111\u008a\u0113")
> >
> > +
> > buf.write("\u008b\u0115\u008c\u0117\u008d\u0119\u008e\u011b\u008f")
> >
> > +
> > buf.write("\u011d\u0090\u011f\u0091\u0121\u0092\u0123\u0093\u0125")
> >
> > +
> >
> buf.write("\u0094\u0127\u0095\u0129\u0096\u012b\u0097\u012d\u0098")
> >
> > +
> > buf.write("\u012f\u0099\u0131\u009a\u0133\u009b\u0135\u009c\u0137")
> >
> > +
> > buf.write("\u009d\u0139\u009e\u013b\u009f\u013d\u00a0\u013f\u00a1")
> >
> > +
> > buf.write("\u0141\u00a2\u0143\u00a3\u0145\u00a4\u0147\u00a5\u0149")
> >
> > +
> > buf.write("\u00a6\u014b\u00a7\u014d\u00a8\u014f\u00a9\u0151\u00aa")
> >
> > +
> >
> buf.write("\u0153\u00ab\u0155\u00ac\u0157\u00ad\u0159\u00ae\u015b")
> >
> > +
> > buf.write("\u00af\u015d\u00b0\u015f\u00b1\u0161\u00b2\u0163\u00b3")
> >
> > +
> >
> buf.write("\u0165\u00b4\u0167\u00b5\u0169\u00b6\u016b\u00b7\u016d")
> >
> > +
> > buf.write("\u00b8\u016f\u00b9\u0171\u00ba\u0173\u00bb\u0175\u00bc")
> >
> > +
> > buf.write("\u0177\u00bd\u0179\u00be\u017b\u00bf\u017d\u00c0\u017f")
> >
> > +
> > buf.write("\u00c1\u0181\u00c2\u0183\u00c3\u0185\u00c4\u0187\u00c5")
> >
> > +
> > buf.write("\u0189\u00c6\u018b\u00c7\u018d\u00c8\u018f\u00c9\u0191")
> >
> > +
> > buf.write("\u00ca\u0193\u00cb\u0195\u00cc\u0197\u00cd\u0199\u00ce")
> >
> > +
> > buf.write("\u019b\u00cf\u019d\u00d0\u019f\u00d1\u01a1\u00d2\u01a3")
> >
> > +
> >
> buf.write("\u00d3\u01a5\u00d4\u01a7\u00d5\u01a9\u00d6\u01ab\u00d7")
> >
> > +
> >
> buf.write("\u01ad\u00d8\u01af\u00d9\u01b1\u00da\u01b3\u00db\u01b5")
> >
> > +
> >
> buf.write("\u00dc\u01b7\u00dd\u01b9\u00de\u01bb\u00df\u01bd\u00e0")
> >
> > +
> > buf.write("\u01bf\u00e1\u01c1\u00e2\u01c3\u00e3\u01c5\u00e4\u01c7")
> >
> > +
> > buf.write("\u00e5\u01c9\u00e6\u01cb\u00e7\u01cd\u00e8\u01cf\u00e9")
> >
> > +
> >
> buf.write("\u01d1\u00ea\u01d3\u00eb\u01d5\u00ec\u01d7\u00ed\u01d9")
> >
> > +
> > buf.write("\u00ee\u01db\u00ef\u01dd\u00f0\u01df\u00f1\u01e1\u00f2")
> >
> > +
> > buf.write("\u01e3\u00f3\u01e5\u00f4\u01e7\u00f5\u01e9\u00f6\u01eb")
> >
> > +
> > buf.write("\u00f7\u01ed\u00f8\u01ef\u00f9\u01f1\u00fa\u01f3\u00fb")
> >
> > +
> buf.write("\u01f5\u00fc\u01f7\u00fd\u01f9\u00fe\u01fb\u00ff\u01fd")
> >
> > +
> > buf.write("\u0100\u01ff\u0101\u0201\u0102\3\2\t\5\2\62;CHch\3\2\62")
> >
> > + buf.write(";\5\2C\\aac|\6\2\62;C\\aac|\5\2\f\f\17\17%%\4\2\13\13")
> >
> > + buf.write("\"\"\4\2\f\f\17\17\2\u0ac5\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
> >
> > + buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
> >
> > + buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
> >
> > + buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
> >
> > + buf.write("\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2")
> >
> > + buf.write("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
> >
> > + buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
> >
> > + buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2")
> >
> > + buf.write("\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3")
> >
> > +
> buf.write("\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y")
> >
> > + buf.write("\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2")
> >
> > + buf.write("c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2")
> >
> > + buf.write("\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2")
> >
> > + buf.write("\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3")
> >
> > +
> buf.write("\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2")
> >
> > +
> > buf.write("\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d")
> >
> > +
> buf.write("\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b")
> >
> > +
> buf.write("\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9")
> >
> > +
> buf.write("\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7")
> >
> > +
> buf.write("\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2")
> >
> > +
> > buf.write("\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5")
> >
> > +
> buf.write("\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2")
> >
> > +
> > buf.write("\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3")
> >
> > +
> buf.write("\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1")
> >
> > +
> buf.write("\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef")
> >
> > + buf.write("\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2")
> >
> > +
> > buf.write("\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd")
> >
> > + buf.write("\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0105\3\2\2\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b")
> >
> > +
> buf.write("\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2\2\2\u0111\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119")
> >
> > +
> buf.write("\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u0127")
> >
> > +
> buf.write("\3\2\2\2\2\u0129\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2")
> >
> > +
> > buf.write("\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\2\u0135")
> >
> > +
> buf.write("\3\2\2\2\2\u0137\3\2\2\2\2\u0139\3\2\2\2\2\u013b\3\2\2")
> >
> > +
> > buf.write("\2\2\u013d\3\2\2\2\2\u013f\3\2\2\2\2\u0141\3\2\2\2\2\u0143")
> >
> > +
> buf.write("\3\2\2\2\2\u0145\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u014b\3\2\2\2\2\u014d\3\2\2\2\2\u014f\3\2\2\2\2\u0151")
> >
> > +
> buf.write("\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0159\3\2\2\2\2\u015b\3\2\2\2\2\u015d\3\2\2\2\2\u015f")
> >
> > +
> buf.write("\3\2\2\2\2\u0161\3\2\2\2\2\u0163\3\2\2\2\2\u0165\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0167\3\2\2\2\2\u0169\3\2\2\2\2\u016b\3\2\2\2\2\u016d")
> >
> > +
> buf.write("\3\2\2\2\2\u016f\3\2\2\2\2\u0171\3\2\2\2\2\u0173\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0175\3\2\2\2\2\u0177\3\2\2\2\2\u0179\3\2\2\2\2\u017b")
> >
> > +
> buf.write("\3\2\2\2\2\u017d\3\2\2\2\2\u017f\3\2\2\2\2\u0181\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0183\3\2\2\2\2\u0185\3\2\2\2\2\u0187\3\2\2\2\2\u0189")
> >
> > +
> buf.write("\3\2\2\2\2\u018b\3\2\2\2\2\u018d\3\2\2\2\2\u018f\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0191\3\2\2\2\2\u0193\3\2\2\2\2\u0195\3\2\2\2\2\u0197")
> >
> > +
> buf.write("\3\2\2\2\2\u0199\3\2\2\2\2\u019b\3\2\2\2\2\u019d\3\2\2")
> >
> > +
> > buf.write("\2\2\u019f\3\2\2\2\2\u01a1\3\2\2\2\2\u01a3\3\2\2\2\2\u01a5")
> >
> > +
> buf.write("\3\2\2\2\2\u01a7\3\2\2\2\2\u01a9\3\2\2\2\2\u01ab\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u01ad\3\2\2\2\2\u01af\3\2\2\2\2\u01b1\3\2\2\2\2\u01b3")
> >
> > +
> buf.write("\3\2\2\2\2\u01b5\3\2\2\2\2\u01b7\3\2\2\2\2\u01b9\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u01bb\3\2\2\2\2\u01bd\3\2\2\2\2\u01bf\3\2\2\2\2\u01c1")
> >
> > +
> buf.write("\3\2\2\2\2\u01c3\3\2\2\2\2\u01c5\3\2\2\2\2\u01c7\3\2\2")
> >
> > +
> > buf.write("\2\2\u01c9\3\2\2\2\2\u01cb\3\2\2\2\2\u01cd\3\2\2\2\2\u01cf")
> >
> > +
> buf.write("\3\2\2\2\2\u01d1\3\2\2\2\2\u01d3\3\2\2\2\2\u01d5\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u01d7\3\2\2\2\2\u01d9\3\2\2\2\2\u01db\3\2\2\2\2\u01dd")
> >
> > +
> buf.write("\3\2\2\2\2\u01df\3\2\2\2\2\u01e1\3\2\2\2\2\u01e3\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u01e5\3\2\2\2\2\u01e7\3\2\2\2\2\u01e9\3\2\2\2\2\u01eb")
> >
> > +
> buf.write("\3\2\2\2\2\u01ed\3\2\2\2\2\u01ef\3\2\2\2\2\u01f1\3\2\2")
> >
> > +
> > buf.write("\2\2\u01f3\3\2\2\2\2\u01f5\3\2\2\2\2\u01f7\3\2\2\2\2\u01f9")
> >
> > + buf.write("\3\2\2\2\2\u01fb\3\2\2\2\2\u01fd\3\2\2\2\2\u01ff\3\2\2")
> >
> > +
> >
> buf.write("\2\2\u0201\3\2\2\2\3\u0203\3\2\2\2\5\u0208\3\2\2\2\7\u020d")
> >
> > + buf.write("\3\2\2\2\t\u0211\3\2\2\2\13\u0219\3\2\2\2\r\u021e\3\2")
> >
> > +
> buf.write("\2\2\17\u0220\3\2\2\2\21\u022c\3\2\2\2\23\u0237\3\2\2")
> >
> > +
> buf.write("\2\25\u0242\3\2\2\2\27\u0245\3\2\2\2\31\u0248\3\2\2\2")
> >
> > +
> >
> buf.write("\33\u024a\3\2\2\2\35\u024c\3\2\2\2\37\u024e\3\2\2\2!\u0255")
> >
> > +
> buf.write("\3\2\2\2#\u0257\3\2\2\2%\u025f\3\2\2\2\'\u0268\3\2\2\2")
> >
> > + buf.write(")\u0274\3\2\2\2+\u0276\3\2\2\2-
> \u0278\3\2\2\2/\u027a\3")
> >
> > +
> buf.write("\2\2\2\61\u027c\3\2\2\2\63\u027e\3\2\2\2\65\u0280\3\2")
> >
> > +
> >
> buf.write("\2\2\67\u0282\3\2\2\29\u0284\3\2\2\2;\u0286\3\2\2\2=\u0288")
> >
> > + buf.write("\3\2\2\2?\u028a\3\2\2\2A\u028c\3\2\2\2C\u028f\3\2\2\2")
> >
> > +
> > buf.write("E\u0292\3\2\2\2G\u0295\3\2\2\2I\u0297\3\2\2\2K\u029a\3")
> >
> > +
> >
> buf.write("\2\2\2M\u029c\3\2\2\2O\u029e\3\2\2\2Q\u02a0\3\2\2\2S\u02ab"
> > )
> >
> > +
> > buf.write("\3\2\2\2U\u02b3\3\2\2\2W\u02bd\3\2\2\2Y\u02c8\3\2\2\2")
> >
> > +
> buf.write("[\u02ce\3\2\2\2]\u02d5\3\2\2\2_\u02db\3\2\2\2a\u02e4\3")
> >
> > +
> > buf.write("\2\2\2c\u02eb\3\2\2\2e\u02f7\3\2\2\2g\u0305\3\2\2\2i\u030d")
> >
> > +
> buf.write("\3\2\2\2k\u0315\3\2\2\2m\u031a\3\2\2\2o\u0322\3\2\2\2")
> >
> > +
> > buf.write("q\u032b\3\2\2\2s\u0333\3\2\2\2u\u033c\3\2\2\2w\u0348\3")
> >
> > +
> > buf.write("\2\2\2y\u034d\3\2\2\2{\u0352\3\2\2\2}\u0359\3\2\2\2\177")
> >
> > +
> > buf.write("\u035f\3\2\2\2\u0081\u0364\3\2\2\2\u0083\u036c\3\2\2\2")
> >
> > +
> > buf.write("\u0085\u0371\3\2\2\2\u0087\u0377\3\2\2\2\u0089\u037b\3")
> >
> > +
> >
> buf.write("\2\2\2\u008b\u0380\3\2\2\2\u008d\u0388\3\2\2\2\u008f\u038d")
> >
> > +
> > buf.write("\3\2\2\2\u0091\u0394\3\2\2\2\u0093\u039b\3\2\2\2\u0095")
> >
> > +
> > buf.write("\u03a5\3\2\2\2\u0097\u03ab\3\2\2\2\u0099\u03b3\3\2\2\2")
> >
> > +
> > buf.write("\u009b\u03bd\3\2\2\2\u009d\u03ce\3\2\2\2\u009f\u03d5\3")
> >
> > +
> >
> buf.write("\2\2\2\u00a1\u03db\3\2\2\2\u00a3\u03e3\3\2\2\2\u00a5\u03ea"
> > )
> >
> > +
> buf.write("\3\2\2\2\u00a7\u03f1\3\2\2\2\u00a9\u03f8\3\2\2\2\u00ab")
> >
> > +
> buf.write("\u03fe\3\2\2\2\u00ad\u040c\3\2\2\2\u00af\u0419\3\2\2\2")
> >
> > +
> > buf.write("\u00b1\u0426\3\2\2\2\u00b3\u0432\3\2\2\2\u00b5\u0437\3")
> >
> > +
> >
> buf.write("\2\2\2\u00b7\u0440\3\2\2\2\u00b9\u044c\3\2\2\2\u00bb\u0454"
> > )
> >
> > +
> buf.write("\3\2\2\2\u00bd\u045f\3\2\2\2\u00bf\u0467\3\2\2\2\u00c1")
> >
> > +
> buf.write("\u046f\3\2\2\2\u00c3\u0474\3\2\2\2\u00c5\u047c\3\2\2\2")
> >
> > +
> > buf.write("\u00c7\u0485\3\2\2\2\u00c9\u0491\3\2\2\2\u00cb\u0498\3")
> >
> > +
> >
> buf.write("\2\2\2\u00cd\u04a2\3\2\2\2\u00cf\u04aa\3\2\2\2\u00d1\u04b2")
> >
> > +
> > buf.write("\3\2\2\2\u00d3\u04bb\3\2\2\2\u00d5\u04c6\3\2\2\2\u00d7")
> >
> > +
> > buf.write("\u04d0\3\2\2\2\u00d9\u04d7\3\2\2\2\u00db\u04dc\3\2\2\2")
> >
> > +
> > buf.write("\u00dd\u04e8\3\2\2\2\u00df\u04f7\3\2\2\2\u00e1\u0501\3")
> >
> > +
> >
> buf.write("\2\2\2\u00e3\u050c\3\2\2\2\u00e5\u0512\3\2\2\2\u00e7\u0516")
> >
> > +
> > buf.write("\3\2\2\2\u00e9\u051e\3\2\2\2\u00eb\u052c\3\2\2\2\u00ed")
> >
> > +
> buf.write("\u053d\3\2\2\2\u00ef\u0552\3\2\2\2\u00f1\u055e\3\2\2\2")
> >
> > +
> > buf.write("\u00f3\u0568\3\2\2\2\u00f5\u0577\3\2\2\2\u00f7\u058a\3")
> >
> > +
> > buf.write("\2\2\2\u00f9\u0595\3\2\2\2\u00fb\u059f\3\2\2\2\u00fd\u05ac")
> >
> > +
> > buf.write("\3\2\2\2\u00ff\u05b7\3\2\2\2\u0101\u05bd\3\2\2\2\u0103")
> >
> > +
> > buf.write("\u05c6\3\2\2\2\u0105\u05d0\3\2\2\2\u0107\u05d8\3\2\2\2")
> >
> > +
> > buf.write("\u0109\u05e0\3\2\2\2\u010b\u05e5\3\2\2\2\u010d\u05ee\3")
> >
> > +
> >
> buf.write("\2\2\2\u010f\u05f5\3\2\2\2\u0111\u05fb\3\2\2\2\u0113\u0600")
> >
> > +
> > buf.write("\3\2\2\2\u0115\u0606\3\2\2\2\u0117\u060d\3\2\2\2\u0119")
> >
> > +
> > buf.write("\u0612\3\2\2\2\u011b\u0617\3\2\2\2\u011d\u061d\3\2\2\2")
> >
> > +
> > buf.write("\u011f\u0626\3\2\2\2\u0121\u0631\3\2\2\2\u0123\u0637\3")
> >
> > +
> >
> buf.write("\2\2\2\u0125\u063e\3\2\2\2\u0127\u0643\3\2\2\2\u0129\u064b"
> > )
> >
> > +
> > buf.write("\3\2\2\2\u012b\u0651\3\2\2\2\u012d\u0656\3\2\2\2\u012f")
> >
> > +
> > buf.write("\u065c\3\2\2\2\u0131\u0668\3\2\2\2\u0133\u0677\3\2\2\2")
> >
> > +
> > buf.write("\u0135\u0684\3\2\2\2\u0137\u068e\3\2\2\2\u0139\u0697\3")
> >
> > +
> >
> buf.write("\2\2\2\u013b\u06a3\3\2\2\2\u013d\u06ab\3\2\2\2\u013f\u06bd"
> > )
> >
> > +
> > buf.write("\3\2\2\2\u0141\u06c4\3\2\2\2\u0143\u06cb\3\2\2\2\u0145")
> >
> > +
> > buf.write("\u06d5\3\2\2\2\u0147\u06dd\3\2\2\2\u0149\u06e6\3\2\2\2")
> >
> > +
> > buf.write("\u014b\u06f5\3\2\2\2\u014d\u06fc\3\2\2\2\u014f\u0706\3")
> >
> > +
> >
> buf.write("\2\2\2\u0151\u070f\3\2\2\2\u0153\u0714\3\2\2\2\u0155\u071a")
> >
> > +
> > buf.write("\3\2\2\2\u0157\u0725\3\2\2\2\u0159\u0731\3\2\2\2\u015b")
> >
> > +
> > buf.write("\u073e\3\2\2\2\u015d\u074d\3\2\2\2\u015f\u075a\3\2\2\2")
> >
> > +
> > buf.write("\u0161\u0769\3\2\2\2\u0163\u0776\3\2\2\2\u0165\u0788\3")
> >
> > +
> >
> buf.write("\2\2\2\u0167\u079c\3\2\2\2\u0169\u07a7\3\2\2\2\u016b\u07b2"
> > )
> >
> > +
> buf.write("\3\2\2\2\u016d\u07c0\3\2\2\2\u016f\u07cf\3\2\2\2\u0171")
> >
> > +
> > buf.write("\u07dc\3\2\2\2\u0173\u07ea\3\2\2\2\u0175\u07fa\3\2\2\2")
> >
> > +
> > buf.write("\u0177\u080a\3\2\2\2\u0179\u0819\3\2\2\2\u017b\u0826\3")
> >
> > +
> >
> buf.write("\2\2\2\u017d\u0835\3\2\2\2\u017f\u083c\3\2\2\2\u0181\u0844")
> >
> > +
> > buf.write("\3\2\2\2\u0183\u0849\3\2\2\2\u0185\u084e\3\2\2\2\u0187")
> >
> > +
> > buf.write("\u0852\3\2\2\2\u0189\u0858\3\2\2\2\u018b\u085d\3\2\2\2")
> >
> > +
> > buf.write("\u018d\u0861\3\2\2\2\u018f\u086a\3\2\2\2\u0191\u086e\3")
> >
> > +
> >
> buf.write("\2\2\2\u0193\u0876\3\2\2\2\u0195\u087d\3\2\2\2\u0197\u0889"
> > )
> >
> > +
> > buf.write("\3\2\2\2\u0199\u0895\3\2\2\2\u019b\u089d\3\2\2\2\u019d")
> >
> > +
> > buf.write("\u08a7\3\2\2\2\u019f\u08b0\3\2\2\2\u01a1\u08b9\3\2\2\2")
> >
> > +
> > buf.write("\u01a3\u08bd\3\2\2\2\u01a5\u08c2\3\2\2\2\u01a7\u08c8\3")
> >
> > +
> >
> buf.write("\2\2\2\u01a9\u08cc\3\2\2\2\u01ab\u08d1\3\2\2\2\u01ad\u08d6"
> > )
> >
> > +
> > buf.write("\3\2\2\2\u01af\u08e0\3\2\2\2\u01b1\u08e8\3\2\2\2\u01b3")
> >
> > +
> buf.write("\u08ef\3\2\2\2\u01b5\u08f3\3\2\2\2\u01b7\u08f6\3\2\2\2")
> >
> > +
> > buf.write("\u01b9\u08fa\3\2\2\2\u01bb\u08fe\3\2\2\2\u01bd\u0900\3")
> >
> > +
> >
> buf.write("\2\2\2\u01bf\u0908\3\2\2\2\u01c1\u0912\3\2\2\2\u01c3\u091b")
> >
> > +
> > buf.write("\3\2\2\2\u01c5\u0923\3\2\2\2\u01c7\u092b\3\2\2\2\u01c9")
> >
> > +
> > buf.write("\u0931\3\2\2\2\u01cb\u0938\3\2\2\2\u01cd\u0941\3\2\2\2")
> >
> > +
> > buf.write("\u01cf\u0950\3\2\2\2\u01d1\u095d\3\2\2\2\u01d3\u0961\3")
> >
> > +
> >
> buf.write("\2\2\2\u01d5\u096d\3\2\2\2\u01d7\u097a\3\2\2\2\u01d9\u0989"
> > )
> >
> > +
> > buf.write("\3\2\2\2\u01db\u099c\3\2\2\2\u01dd\u09ab\3\2\2\2\u01df")
> >
> > +
> > buf.write("\u09ba\3\2\2\2\u01e1\u09c9\3\2\2\2\u01e3\u09d8\3\2\2\2")
> >
> > +
> > buf.write("\u01e5\u09e8\3\2\2\2\u01e7\u09f9\3\2\2\2\u01e9\u0a0a\3")
> >
> > +
> >
> buf.write("\2\2\2\u01eb\u0a16\3\2\2\2\u01ed\u0a20\3\2\2\2\u01ef\u0a2f")
> >
> > +
> buf.write("\3\2\2\2\u01f1\u0a4c\3\2\2\2\u01f3\u0a4e\3\2\2\2\u01f5")
> >
> > +
> buf.write("\u0a55\3\2\2\2\u01f7\u0a68\3\2\2\2\u01f9\u0a79\3\2\2\2")
> >
> > +
> buf.write("\u01fb\u0a8e\3\2\2\2\u01fd\u0a99\3\2\2\2\u01ff\u0a9d\3")
> >
> > +
> >
> buf.write("\2\2\2\u0201\u0aa8\3\2\2\2\u0203\u0204\7u\2\2\u0204\u0205")
> >
> > +
> buf.write("\7j\2\2\u0205\u0206\7q\2\2\u0206\u0207\7y\2\2\u0207\4")
> >
> > +
> >
> buf.write("\3\2\2\2\u0208\u0209\7r\2\2\u0209\u020a\7w\2\2\u020a\u020b"
> > )
> >
> > +
> > buf.write("\7u\2\2\u020b\u020c\7j\2\2\u020c\6\3\2\2\2\u020d\u020e")
> >
> > +
> buf.write("\7r\2\2\u020e\u020f\7q\2\2\u020f\u0210\7r\2\2\u0210\b")
> >
> > +
> >
> buf.write("\3\2\2\2\u0211\u0212\7%\2\2\u0212\u0213\7r\2\2\u0213\u0214"
> > )
> >
> > +
> > buf.write("\7t\2\2\u0214\u0215\7c\2\2\u0215\u0216\7i\2\2\u0216\u0217")
> >
> > +
> > buf.write("\7o\2\2\u0217\u0218\7c\2\2\u0218\n\3\2\2\2\u0219\u021a")
> >
> > +
> >
> buf.write("\7r\2\2\u021a\u021b\7c\2\2\u021b\u021c\7e\2\2\u021c\u021d")
> >
> > +
> buf.write("\7m\2\2\u021d\f\3\2\2\2\u021e\u021f\7?\2\2\u021f\16\3")
> >
> > +
> >
> buf.write("\2\2\2\u0220\u0221\7K\2\2\u0221\u0222\7O\2\2\u0222\u0223")
> >
> > +
> >
> buf.write("\7C\2\2\u0223\u0224\7I\2\2\u0224\u0225\7G\2\2\u0225\u0226")
> >
> > +
> >
> buf.write("\7a\2\2\u0226\u0227\7V\2\2\u0227\u0228\7Q\2\2\u0228\u0229"
> > )
> >
> > +
> > buf.write("\7M\2\2\u0229\u022a\7G\2\2\u022a\u022b\7P\2\2\u022b\20")
> >
> > +
> >
> buf.write("\3\2\2\2\u022c\u022d\7J\2\2\u022d\u022e\7Q\2\2\u022e\u022f")
> >
> > +
> >
> buf.write("\7T\2\2\u022f\u0230\7K\2\2\u0230\u0231\7\\\2\2\u0231\u0232")
> >
> > +
> >
> buf.write("\7Q\2\2\u0232\u0233\7P\2\2\u0233\u0234\7V\2\2\u0234\u0235"
> > )
> >
> > +
> > buf.write("\7C\2\2\u0235\u0236\7N\2\2\u0236\22\3\2\2\2\u0237\u0238")
> >
> > +
> >
> buf.write("\7O\2\2\u0238\u0239\7W\2\2\u0239\u023a\7N\2\2\u023a\u023b
> > ")
> >
> > +
> >
> buf.write("\7V\2\2\u023b\u023c\7K\2\2\u023c\u023d\7a\2\2\u023d\u023e")
> >
> > +
> >
> buf.write("\7N\2\2\u023e\u023f\7K\2\2\u023f\u0240\7P\2\2\u0240\u0241")
> >
> > +
> > buf.write("\7G\2\2\u0241\24\3\2\2\2\u0242\u0243\7>\2\2\u0243\u0244")
> >
> > +
> > buf.write("\7>\2\2\u0244\26\3\2\2\2\u0245\u0246\7@\2\2\u0246\u0247")
> >
> > + buf.write("\7@\2\2\u0247\30\3\2\2\2\u0248\u0249\7-
> > \2\2\u0249\32\3")
> >
> > +
> > buf.write("\2\2\2\u024a\u024b\7,\2\2\u024b\34\3\2\2\2\u024c\u024d")
> >
> > +
> > buf.write("\7\'\2\2\u024d\36\3\2\2\2\u024e\u024f\7h\2\2\u024f\u0250")
> >
> > +
> >
> buf.write("\7q\2\2\u0250\u0251\7t\2\2\u0251\u0252\7o\2\2\u0252\u0253")
> >
> > + buf.write("\7c\2\2\u0253\u0254\7v\2\2\u0254
> \3\2\2\2\u0255\u0256")
> >
> > +
> > buf.write("\7A\2\2\u0256\"\3\2\2\2\u0257\u0258\7%\2\2\u0258\u0259")
> >
> > +
> >
> buf.write("\7f\2\2\u0259\u025a\7g\2\2\u025a\u025b\7h\2\2\u025b\u025c")
> >
> > +
> > buf.write("\7k\2\2\u025c\u025d\7p\2\2\u025d\u025e\7g\2\2\u025e$\3")
> >
> > +
> >
> buf.write("\2\2\2\u025f\u0260\7%\2\2\u0260\u0261\7k\2\2\u0261\u0262")
> >
> > +
> >
> buf.write("\7p\2\2\u0262\u0263\7e\2\2\u0263\u0264\7n\2\2\u0264\u0265")
> >
> > +
> > buf.write("\7w\2\2\u0265\u0266\7f\2\2\u0266\u0267\7g\2\2\u0267&\3")
> >
> > +
> >
> buf.write("\2\2\2\u0268\u0269\7h\2\2\u0269\u026a\7q\2\2\u026a\u026b")
> >
> > +
> >
> buf.write("\7t\2\2\u026b\u026c\7o\2\2\u026c\u026d\7r\2\2\u026d\u026e")
> >
> > +
> >
> buf.write("\7m\2\2\u026e\u026f\7i\2\2\u026f\u0270\7v\2\2\u0270\u0271")
> >
> > +
> > buf.write("\7{\2\2\u0271\u0272\7r\2\2\u0272\u0273\7g\2\2\u0273(\3")
> >
> > +
> > buf.write("\2\2\2\u0274\u0275\7}\2\2\u0275*\3\2\2\2\u0276\u0277\7")
> >
> > +
> buf.write("\177\2\2\u0277,\3\2\2\2\u0278\u0279\7*\2\2\u0279.\3\2")
> >
> > +
> > buf.write("\2\2\u027a\u027b\7+\2\2\u027b\60\3\2\2\2\u027c\u027d\7")
> >
> > +
> buf.write("]\2\2\u027d\62\3\2\2\2\u027e\u027f\7_\2\2\u027f\64\3\2")
> >
> > +
> > buf.write("\2\2\u0280\u0281\7\60\2\2\u0281\66\3\2\2\2\u0282\u0283")
> >
> > +
> buf.write("\7/\2\2\u02838\3\2\2\2\u0284\u0285\7<\2\2\u0285:\3\2\2")
> >
> > +
> > buf.write("\2\u0286\u0287\7\61\2\2\u0287<\3\2\2\2\u0288\u0289\7=")
> >
> > +
> > buf.write("\2\2\u0289>\3\2\2\2\u028a\u028b\7.\2\2\u028b@\3\2\2\2")
> >
> > +
> > buf.write("\u028c\u028d\7?\2\2\u028d\u028e\7?\2\2\u028eB\3\2\2\2")
> >
> > +
> buf.write("\u028f\u0290\7#\2\2\u0290\u0291\7?\2\2\u0291D\3\2\2\2")
> >
> > +
> buf.write("\u0292\u0293\7>\2\2\u0293\u0294\7?\2\2\u0294F\3\2\2\2")
> >
> > +
> > buf.write("\u0295\u0296\7>\2\2\u0296H\3\2\2\2\u0297\u0298\7@\2\2")
> >
> > +
> > buf.write("\u0298\u0299\7?\2\2\u0299J\3\2\2\2\u029a\u029b\7@\2\2")
> >
> > +
> > buf.write("\u029bL\3\2\2\2\u029c\u029d\7~\2\2\u029dN\3\2\2\2\u029e")
> >
> > +
> buf.write("\u029f\7(\2\2\u029fP\3\2\2\2\u02a0\u02a1\7f\2\2\u02a1")
> >
> > +
> >
> buf.write("\u02a2\7g\2\2\u02a2\u02a3\7x\2\2\u02a3\u02a4\7k\2\2\u02a4")
> >
> > +
> >
> buf.write("\u02a5\7e\2\2\u02a5\u02a6\7g\2\2\u02a6\u02a7\7r\2\2\u02a7")
> >
> > +
> >
> buf.write("\u02a8\7c\2\2\u02a8\u02a9\7v\2\2\u02a9\u02aa\7j\2\2\u02aa")
> >
> > +
> > buf.write("R\3\2\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7q\2\2\u02ad")
> >
> > +
> >
> buf.write("\u02ae\7t\2\2\u02ae\u02af\7o\2\2\u02af\u02b0\7u\2\2\u02b0")
> >
> > +
> > buf.write("\u02b1\7g\2\2\u02b1\u02b2\7v\2\2\u02b2T\3\2\2\2\u02b3")
> >
> > +
> >
> buf.write("\u02b4\7h\2\2\u02b4\u02b5\7q\2\2\u02b5\u02b6\7t\2\2\u02b6")
> >
> > +
> >
> buf.write("\u02b7\7o\2\2\u02b7\u02b8\7u\2\2\u02b8\u02b9\7g\2\2\u02b9"
> > )
> >
> > +
> >
> buf.write("\u02ba\7v\2\2\u02ba\u02bb\7k\2\2\u02bb\u02bc\7f\2\2\u02bc")
> >
> > +
> buf.write("V\3\2\2\2\u02bd\u02be\7g\2\2\u02be\u02bf\7p\2\2\u02bf")
> >
> > +
> > buf.write("\u02c0\7f\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2\7q\2\2\u02c2")
> >
> > +
> > buf.write("\u02c3\7t\2\2\u02c3\u02c4\7o\2\2\u02c4\u02c5\7u\2\2\u02c5")
> >
> > +
> buf.write("\u02c6\7g\2\2\u02c6\u02c7\7v\2\2\u02c7X\3\2\2\2\u02c8")
> >
> > +
> > buf.write("\u02c9\7v\2\2\u02c9\u02ca\7k\2\2\u02ca\u02cb\7v\2\2\u02cb")
> >
> > +
> buf.write("\u02cc\7n\2\2\u02cc\u02cd\7g\2\2\u02cdZ\3\2\2\2\u02ce")
> >
> > +
> >
> buf.write("\u02cf\7h\2\2\u02cf\u02d0\7q\2\2\u02d0\u02d1\7t\2\2\u02d1")
> >
> > +
> >
> buf.write("\u02d2\7o\2\2\u02d2\u02d3\7k\2\2\u02d3\u02d4\7f\2\2\u02d4")
> >
> > +
> > buf.write("\\\3\2\2\2\u02d5\u02d6\7q\2\2\u02d6\u02d7\7p\2\2\u02d7")
> >
> > +
> >
> buf.write("\u02d8\7g\2\2\u02d8\u02d9\7q\2\2\u02d9\u02da\7h\2\2\u02da"
> > )
> >
> > +
> > buf.write("^\3\2\2\2\u02db\u02dc\7g\2\2\u02dc\u02dd\7p\2\2\u02dd")
> >
> > +
> >
> buf.write("\u02de\7f\2\2\u02de\u02df\7q\2\2\u02df\u02e0\7p\2\2\u02e0")
> >
> > +
> >
> buf.write("\u02e1\7g\2\2\u02e1\u02e2\7q\2\2\u02e2\u02e3\7h\2\2\u02e3")
> >
> > +
> buf.write("`\3\2\2\2\u02e4\u02e5\7r\2\2\u02e5\u02e6\7t\2\2\u02e6")
> >
> > +
> >
> buf.write("\u02e7\7q\2\2\u02e7\u02e8\7o\2\2\u02e8\u02e9\7r\2\2\u02e9")
> >
> > +
> buf.write("\u02ea\7v\2\2\u02eab\3\2\2\2\u02eb\u02ec\7q\2\2\u02ec")
> >
> > +
> > buf.write("\u02ed\7t\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef\7g\2\2\u02ef")
> >
> > +
> > buf.write("\u02f0\7t\2\2\u02f0\u02f1\7g\2\2\u02f1\u02f2\7f\2\2\u02f2")
> >
> > +
> > buf.write("\u02f3\7n\2\2\u02f3\u02f4\7k\2\2\u02f4\u02f5\7u\2\2\u02f5")
> >
> > + buf.write("\u02f6\7v\2\2\u02f6d\3\2\2\2\u02f7\u02f8\7o\2\2\u02f8")
> >
> > +
> > buf.write("\u02f9\7c\2\2\u02f9\u02fa\7z\2\2\u02fa\u02fb\7e\2\2\u02fb")
> >
> > +
> > buf.write("\u02fc\7q\2\2\u02fc\u02fd\7p\2\2\u02fd\u02fe\7v\2\2\u02fe")
> >
> > +
> > buf.write("\u02ff\7c\2\2\u02ff\u0300\7k\2\2\u0300\u0301\7p\2\2\u0301")
> >
> > +
> >
> buf.write("\u0302\7g\2\2\u0302\u0303\7t\2\2\u0303\u0304\7u\2\2\u0304")
> >
> > +
> buf.write("f\3\2\2\2\u0305\u0306\7g\2\2\u0306\u0307\7p\2\2\u0307")
> >
> > +
> >
> buf.write("\u0308\7f\2\2\u0308\u0309\7n\2\2\u0309\u030a\7k\2\2\u030a")
> >
> > +
> > buf.write("\u030b\7u\2\2\u030b\u030c\7v\2\2\u030ch\3\2\2\2\u030d")
> >
> > +
> > buf.write("\u030e\7g\2\2\u030e\u030f\7p\2\2\u030f\u0310\7f\2\2\u0310")
> >
> > +
> >
> buf.write("\u0311\7h\2\2\u0311\u0312\7q\2\2\u0312\u0313\7t\2\2\u0313")
> >
> > +
> buf.write("\u0314\7o\2\2\u0314j\3\2\2\2\u0315\u0316\7h\2\2\u0316")
> >
> > +
> >
> buf.write("\u0317\7q\2\2\u0317\u0318\7t\2\2\u0318\u0319\7o\2\2\u0319")
> >
> > +
> buf.write("l\3\2\2\2\u031a\u031b\7h\2\2\u031b\u031c\7q\2\2\u031c")
> >
> > +
> >
> buf.write("\u031d\7t\2\2\u031d\u031e\7o\2\2\u031e\u031f\7o\2\2\u031f")
> >
> > +
> buf.write("\u0320\7c\2\2\u0320\u0321\7r\2\2\u0321n\3\2\2\2\u0322")
> >
> > +
> >
> buf.write("\u0323\7o\2\2\u0323\u0324\7c\2\2\u0324\u0325\7r\2\2\u0325")
> >
> > +
> >
> buf.write("\u0326\7v\2\2\u0326\u0327\7k\2\2\u0327\u0328\7v\2\2\u0328")
> >
> > +
> > buf.write("\u0329\7n\2\2\u0329\u032a\7g\2\2\u032ap\3\2\2\2\u032b")
> >
> > +
> >
> buf.write("\u032c\7o\2\2\u032c\u032d\7c\2\2\u032d\u032e\7r\2\2\u032e")
> >
> > +
> >
> buf.write("\u032f\7i\2\2\u032f\u0330\7w\2\2\u0330\u0331\7k\2\2\u0331")
> >
> > +
> buf.write("\u0332\7f\2\2\u0332r\3\2\2\2\u0333\u0334\7u\2\2\u0334")
> >
> > +
> >
> buf.write("\u0335\7w\2\2\u0335\u0336\7d\2\2\u0336\u0337\7v\2\2\u0337"
> > )
> >
> > +
> >
> buf.write("\u0338\7k\2\2\u0338\u0339\7v\2\2\u0339\u033a\7n\2\2\u033a")
> >
> > +
> buf.write("\u033b\7g\2\2\u033bt\3\2\2\2\u033c\u033d\7g\2\2\u033d")
> >
> > +
> >
> buf.write("\u033e\7p\2\2\u033e\u033f\7f\2\2\u033f\u0340\7u\2\2\u0340")
> >
> > +
> >
> buf.write("\u0341\7w\2\2\u0341\u0342\7d\2\2\u0342\u0343\7v\2\2\u0343"
> > )
> >
> > +
> >
> buf.write("\u0344\7k\2\2\u0344\u0345\7v\2\2\u0345\u0346\7n\2\2\u0346")
> >
> > +
> buf.write("\u0347\7g\2\2\u0347v\3\2\2\2\u0348\u0349\7j\2\2\u0349")
> >
> > +
> >
> buf.write("\u034a\7g\2\2\u034a\u034b\7n\2\2\u034b\u034c\7r\2\2\u034c")
> >
> > +
> buf.write("x\3\2\2\2\u034d\u034e\7v\2\2\u034e\u034f\7g\2\2\u034f")
> >
> > +
> buf.write("\u0350\7z\2\2\u0350\u0351\7v\2\2\u0351z\3\2\2\2\u0352")
> >
> > +
> >
> buf.write("\u0353\7q\2\2\u0353\u0354\7r\2\2\u0354\u0355\7v\2\2\u0355")
> >
> > +
> >
> buf.write("\u0356\7k\2\2\u0356\u0357\7q\2\2\u0357\u0358\7p\2\2\u0358")
> >
> > +
> > buf.write("|\3\2\2\2\u0359\u035a\7h\2\2\u035a\u035b\7n\2\2\u035b")
> >
> > +
> >
> buf.write("\u035c\7c\2\2\u035c\u035d\7i\2\2\u035d\u035e\7u\2\2\u035e")
> >
> > +
> buf.write("~\3\2\2\2\u035f\u0360\7f\2\2\u0360\u0361\7c\2\2\u0361")
> >
> > +
> >
> buf.write("\u0362\7v\2\2\u0362\u0363\7g\2\2\u0363\u0080\3\2\2\2\u0364"
> > )
> >
> > +
> >
> buf.write("\u0365\7g\2\2\u0365\u0366\7p\2\2\u0366\u0367\7f\2\2\u0367")
> >
> > +
> >
> buf.write("\u0368\7f\2\2\u0368\u0369\7c\2\2\u0369\u036a\7v\2\2\u036a")
> >
> > +
> >
> buf.write("\u036b\7g\2\2\u036b\u0082\3\2\2\2\u036c\u036d\7{\2\2\u036d"
> > )
> >
> > +
> > buf.write("\u036e\7g\2\2\u036e\u036f\7c\2\2\u036f\u0370\7t\2\2\u0370")
> >
> > +
> >
> buf.write("\u0084\3\2\2\2\u0371\u0372\7o\2\2\u0372\u0373\7q\2\2\u0373"
> > )
> >
> > +
> >
> buf.write("\u0374\7p\2\2\u0374\u0375\7v\2\2\u0375\u0376\7j\2\2\u0376")
> >
> > +
> >
> buf.write("\u0086\3\2\2\2\u0377\u0378\7f\2\2\u0378\u0379\7c\2\2\u0379")
> >
> > +
> >
> buf.write("\u037a\7{\2\2\u037a\u0088\3\2\2\2\u037b\u037c\7v\2\2\u037c")
> >
> > +
> >
> buf.write("\u037d\7k\2\2\u037d\u037e\7o\2\2\u037e\u037f\7g\2\2\u037f")
> >
> > +
> >
> buf.write("\u008a\3\2\2\2\u0380\u0381\7g\2\2\u0381\u0382\7p\2\2\u0382"
> > )
> >
> > +
> >
> buf.write("\u0383\7f\2\2\u0383\u0384\7v\2\2\u0384\u0385\7k\2\2\u0385")
> >
> > +
> >
> buf.write("\u0386\7o\2\2\u0386\u0387\7g\2\2\u0387\u008c\3\2\2\2\u0388"
> > )
> >
> > +
> >
> buf.write("\u0389\7j\2\2\u0389\u038a\7q\2\2\u038a\u038b\7w\2\2\u038b")
> >
> > +
> >
> buf.write("\u038c\7t\2\2\u038c\u008e\3\2\2\2\u038d\u038e\7o\2\2\u038e")
> >
> > +
> >
> buf.write("\u038f\7k\2\2\u038f\u0390\7p\2\2\u0390\u0391\7w\2\2\u0391")
> >
> > +
> >
> buf.write("\u0392\7v\2\2\u0392\u0393\7g\2\2\u0393\u0090\3\2\2\2\u0394"
> > )
> >
> > +
> >
> buf.write("\u0395\7u\2\2\u0395\u0396\7g\2\2\u0396\u0397\7e\2\2\u0397")
> >
> > +
> >
> buf.write("\u0398\7q\2\2\u0398\u0399\7p\2\2\u0399\u039a\7f\2\2\u039a")
> >
> > +
> >
> buf.write("\u0092\3\2\2\2\u039b\u039c\7i\2\2\u039c\u039d\7t\2\2\u039d")
> >
> > +
> > buf.write("\u039e\7c\2\2\u039e\u039f\7{\2\2\u039f\u03a0\7q\2\2\u03a0")
> >
> > +
> >
> buf.write("\u03a1\7w\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7k\2\2\u03a3")
> >
> > +
> >
> buf.write("\u03a4\7h\2\2\u03a4\u0094\3\2\2\2\u03a5\u03a6\7n\2\2\u03a6"
> > )
> >
> > +
> >
> buf.write("\u03a7\7c\2\2\u03a7\u03a8\7d\2\2\u03a8\u03a9\7g\2\2\u03a9")
> >
> > +
> >
> buf.write("\u03aa\7n\2\2\u03aa\u0096\3\2\2\2\u03ab\u03ac\7v\2\2\u03ac"
> > )
> >
> > +
> >
> buf.write("\u03ad\7k\2\2\u03ad\u03ae\7o\2\2\u03ae\u03af\7g\2\2\u03af")
> >
> > +
> >
> buf.write("\u03b0\7q\2\2\u03b0\u03b1\7w\2\2\u03b1\u03b2\7v\2\2\u03b2"
> > )
> >
> > +
> >
> buf.write("\u0098\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7p\2\2\u03b5
> > ")
> >
> > +
> >
> buf.write("\u03b6\7x\2\2\u03b6\u03b7\7g\2\2\u03b7\u03b8\7p\2\2\u03b8"
> > )
> >
> > +
> >
> buf.write("\u03b9\7v\2\2\u03b9\u03ba\7q\2\2\u03ba\u03bb\7t\2\2\u03bb")
> >
> > +
> >
> buf.write("\u03bc\7{\2\2\u03bc\u009a\3\2\2\2\u03bd\u03be\7a\2\2\u03be"
> > )
> >
> > +
> > buf.write("\u03bf\7P\2\2\u03bf\u03c0\7Q\2\2\u03c0\u03c1\7P\2\2\u03c1")
> >
> > +
> > buf.write("\u03c2\7a\2\2\u03c2\u03c3\7P\2\2\u03c3\u03c4\7X\2\2\u03c4")
> >
> > +
> > buf.write("\u03c5\7a\2\2\u03c5\u03c6\7F\2\2\u03c6\u03c7\7C\2\2\u03c7")
> >
> > +
> >
> buf.write("\u03c8\7V\2\2\u03c8\u03c9\7C\2\2\u03c9\u03ca\7a\2\2\u03ca")
> >
> > +
> >
> buf.write("\u03cb\7O\2\2\u03cb\u03cc\7C\2\2\u03cc\u03cd\7R\2\2\u03cd")
> >
> > +
> >
> buf.write("\u009c\3\2\2\2\u03ce\u03cf\7u\2\2\u03cf\u03d0\7v\2\2\u03d0")
> >
> > +
> >
> buf.write("\u03d1\7t\2\2\u03d1\u03d2\7w\2\2\u03d2\u03d3\7e\2\2\u03d3"
> > )
> >
> > +
> >
> buf.write("\u03d4\7v\2\2\u03d4\u009e\3\2\2\2\u03d5\u03d6\7w\2\2\u03d6
> > ")
> >
> > +
> >
> buf.write("\u03d7\7p\2\2\u03d7\u03d8\7k\2\2\u03d8\u03d9\7q\2\2\u03d9"
> > )
> >
> > +
> >
> buf.write("\u03da\7p\2\2\u03da\u00a0\3\2\2\2\u03db\u03dc\7D\2\2\u03dc
> > ")
> >
> > +
> >
> buf.write("\u03dd\7Q\2\2\u03dd\u03de\7Q\2\2\u03de\u03df\7N\2\2\u03df"
> > )
> >
> > +
> >
> buf.write("\u03e0\7G\2\2\u03e0\u03e1\7C\2\2\u03e1\u03e2\7P\2\2\u03e2")
> >
> > +
> >
> buf.write("\u00a2\3\2\2\2\u03e3\u03e4\7W\2\2\u03e4\u03e5\7K\2\2\u03e5
> > ")
> >
> > +
> >
> buf.write("\u03e6\7P\2\2\u03e6\u03e7\7V\2\2\u03e7\u03e8\78\2\2\u03e8")
> >
> > +
> > buf.write("\u03e9\7\66\2\2\u03e9\u00a4\3\2\2\2\u03ea\u03eb\7W\2\2")
> >
> > +
> > buf.write("\u03eb\u03ec\7K\2\2\u03ec\u03ed\7P\2\2\u03ed\u03ee\7V")
> >
> > +
> >
> buf.write("\2\2\u03ee\u03ef\7\65\2\2\u03ef\u03f0\7\64\2\2\u03f0\u00a6")
> >
> > +
> >
> buf.write("\3\2\2\2\u03f1\u03f2\7W\2\2\u03f2\u03f3\7K\2\2\u03f3\u03f4")
> >
> > + buf.write("\7P\2\2\u03f4\u03f5\7V\2\2\u03f5\u03f6\7\63\2\2\u03f6")
> >
> > +
> >
> buf.write("\u03f7\78\2\2\u03f7\u00a8\3\2\2\2\u03f8\u03f9\7W\2\2\u03f9")
> >
> > +
> > buf.write("\u03fa\7K\2\2\u03fa\u03fb\7P\2\2\u03fb\u03fc\7V\2\2\u03fc")
> >
> > +
> > buf.write("\u03fd\7:\2\2\u03fd\u00aa\3\2\2\2\u03fe\u03ff\7G\2\2\u03ff")
> >
> > +
> >
> buf.write("\u0400\7H\2\2\u0400\u0401\7K\2\2\u0401\u0402\7a\2\2\u0402")
> >
> > +
> >
> buf.write("\u0403\7U\2\2\u0403\u0404\7V\2\2\u0404\u0405\7T\2\2\u0405")
> >
> > +
> >
> buf.write("\u0406\7K\2\2\u0406\u0407\7P\2\2\u0407\u0408\7I\2\2\u0408")
> >
> > +
> >
> buf.write("\u0409\7a\2\2\u0409\u040a\7K\2\2\u040a\u040b\7F\2\2\u040b")
> >
> > +
> >
> buf.write("\u00ac\3\2\2\2\u040c\u040d\7G\2\2\u040d\u040e\7H\2\2\u040e
> > ")
> >
> > +
> > buf.write("\u040f\7K\2\2\u040f\u0410\7a\2\2\u0410\u0411\7J\2\2\u0411")
> >
> > +
> >
> buf.write("\u0412\7K\2\2\u0412\u0413\7K\2\2\u0413\u0414\7a\2\2\u0414")
> >
> > +
> >
> buf.write("\u0415\7F\2\2\u0415\u0416\7C\2\2\u0416\u0417\7V\2\2\u0417")
> >
> > +
> >
> buf.write("\u0418\7G\2\2\u0418\u00ae\3\2\2\2\u0419\u041a\7G\2\2\u041a
> > ")
> >
> > +
> >
> buf.write("\u041b\7H\2\2\u041b\u041c\7K\2\2\u041c\u041d\7a\2\2\u041d")
> >
> > +
> > buf.write("\u041e\7J\2\2\u041e\u041f\7K\2\2\u041f\u0420\7K\2\2\u0420")
> >
> > +
> >
> buf.write("\u0421\7a\2\2\u0421\u0422\7V\2\2\u0422\u0423\7K\2\2\u0423")
> >
> > +
> >
> buf.write("\u0424\7O\2\2\u0424\u0425\7G\2\2\u0425\u00b0\3\2\2\2\u0426
> > ")
> >
> > +
> >
> buf.write("\u0427\7G\2\2\u0427\u0428\7H\2\2\u0428\u0429\7K\2\2\u0429"
> > )
> >
> > +
> >
> buf.write("\u042a\7a\2\2\u042a\u042b\7J\2\2\u042b\u042c\7K\2\2\u042c")
> >
> > +
> >
> buf.write("\u042d\7K\2\2\u042d\u042e\7a\2\2\u042e\u042f\7T\2\2\u042f")
> >
> > +
> >
> buf.write("\u0430\7G\2\2\u0430\u0431\7H\2\2\u0431\u00b2\3\2\2\2\u0432
> > ")
> >
> > +
> >
> buf.write("\u0433\7i\2\2\u0433\u0434\7w\2\2\u0434\u0435\7k\2\2\u0435")
> >
> > +
> >
> buf.write("\u0436\7f\2\2\u0436\u00b4\3\2\2\2\u0437\u0438\7e\2\2\u0438"
> > )
> >
> > +
> >
> buf.write("\u0439\7j\2\2\u0439\u043a\7g\2\2\u043a\u043b\7e\2\2\u043b")
> >
> > +
> >
> buf.write("\u043c\7m\2\2\u043c\u043d\7d\2\2\u043d\u043e\7q\2\2\u043e"
> > )
> >
> > +
> >
> buf.write("\u043f\7z\2\2\u043f\u00b6\3\2\2\2\u0440\u0441\7g\2\2\u0441")
> >
> > +
> >
> buf.write("\u0442\7p\2\2\u0442\u0443\7f\2\2\u0443\u0444\7e\2\2\u0444")
> >
> > +
> >
> buf.write("\u0445\7j\2\2\u0445\u0446\7g\2\2\u0446\u0447\7e\2\2\u0447")
> >
> > +
> >
> buf.write("\u0448\7m\2\2\u0448\u0449\7d\2\2\u0449\u044a\7q\2\2\u044a"
> > )
> >
> > +
> >
> buf.write("\u044b\7z\2\2\u044b\u00b8\3\2\2\2\u044c\u044d\7p\2\2\u044d"
> > )
> >
> > +
> >
> buf.write("\u044e\7w\2\2\u044e\u044f\7o\2\2\u044f\u0450\7g\2\2\u0450")
> >
> > +
> >
> buf.write("\u0451\7t\2\2\u0451\u0452\7k\2\2\u0452\u0453\7e\2\2\u0453")
> >
> > +
> >
> buf.write("\u00ba\3\2\2\2\u0454\u0455\7g\2\2\u0455\u0456\7p\2\2\u0456"
> > )
> >
> > +
> >
> buf.write("\u0457\7f\2\2\u0457\u0458\7p\2\2\u0458\u0459\7w\2\2\u0459")
> >
> > +
> >
> buf.write("\u045a\7o\2\2\u045a\u045b\7g\2\2\u045b\u045c\7t\2\2\u045c")
> >
> > +
> >
> buf.write("\u045d\7k\2\2\u045d\u045e\7e\2\2\u045e\u00bc\3\2\2\2\u045f")
> >
> > +
> >
> buf.write("\u0460\7o\2\2\u0460\u0461\7k\2\2\u0461\u0462\7p\2\2\u0462")
> >
> > +
> >
> buf.write("\u0463\7k\2\2\u0463\u0464\7o\2\2\u0464\u0465\7w\2\2\u0465"
> > )
> >
> > +
> >
> buf.write("\u0466\7o\2\2\u0466\u00be\3\2\2\2\u0467\u0468\7o\2\2\u0468"
> > )
> >
> > +
> >
> buf.write("\u0469\7c\2\2\u0469\u046a\7z\2\2\u046a\u046b\7k\2\2\u046b")
> >
> > +
> >
> buf.write("\u046c\7o\2\2\u046c\u046d\7w\2\2\u046d\u046e\7o\2\2\u046e"
> > )
> >
> > +
> >
> buf.write("\u00c0\3\2\2\2\u046f\u0470\7u\2\2\u0470\u0471\7v\2\2\u0471")
> >
> > +
> >
> buf.write("\u0472\7g\2\2\u0472\u0473\7r\2\2\u0473\u00c2\3\2\2\2\u0474")
> >
> > +
> >
> buf.write("\u0475\7f\2\2\u0475\u0476\7g\2\2\u0476\u0477\7h\2\2\u0477")
> >
> > +
> >
> buf.write("\u0478\7c\2\2\u0478\u0479\7w\2\2\u0479\u047a\7n\2\2\u047a")
> >
> > +
> >
> buf.write("\u047b\7v\2\2\u047b\u00c4\3\2\2\2\u047c\u047d\7r\2\2\u047d")
> >
> > +
> >
> buf.write("\u047e\7c\2\2\u047e\u047f\7u\2\2\u047f\u0480\7u\2\2\u0480")
> >
> > +
> >
> buf.write("\u0481\7y\2\2\u0481\u0482\7q\2\2\u0482\u0483\7t\2\2\u0483")
> >
> > +
> >
> buf.write("\u0484\7f\2\2\u0484\u00c6\3\2\2\2\u0485\u0486\7g\2\2\u0486")
> >
> > +
> >
> buf.write("\u0487\7p\2\2\u0487\u0488\7f\2\2\u0488\u0489\7r\2\2\u0489")
> >
> > +
> >
> buf.write("\u048a\7c\2\2\u048a\u048b\7u\2\2\u048b\u048c\7u\2\2\u048c")
> >
> > +
> >
> buf.write("\u048d\7y\2\2\u048d\u048e\7q\2\2\u048e\u048f\7t\2\2\u048f")
> >
> > +
> >
> buf.write("\u0490\7f\2\2\u0490\u00c8\3\2\2\2\u0491\u0492\7u\2\2\u0492")
> >
> > +
> >
> buf.write("\u0493\7v\2\2\u0493\u0494\7t\2\2\u0494\u0495\7k\2\2\u0495")
> >
> > +
> >
> buf.write("\u0496\7p\2\2\u0496\u0497\7i\2\2\u0497\u00ca\3\2\2\2\u0498")
> >
> > +
> >
> buf.write("\u0499\7g\2\2\u0499\u049a\7p\2\2\u049a\u049b\7f\2\2\u049b")
> >
> > +
> >
> buf.write("\u049c\7u\2\2\u049c\u049d\7v\2\2\u049d\u049e\7t\2\2\u049e")
> >
> > +
> > buf.write("\u049f\7k\2\2\u049f\u04a0\7p\2\2\u04a0\u04a1\7i\2\2\u04a1")
> >
> > +
> >
> buf.write("\u00cc\3\2\2\2\u04a2\u04a3\7o\2\2\u04a3\u04a4\7k\2\2\u04a4")
> >
> > +
> >
> buf.write("\u04a5\7p\2\2\u04a5\u04a6\7u\2\2\u04a6\u04a7\7k\2\2\u04a7")
> >
> > +
> >
> buf.write("\u04a8\7|\2\2\u04a8\u04a9\7g\2\2\u04a9\u00ce\3\2\2\2\u04aa")
> >
> > +
> >
> buf.write("\u04ab\7o\2\2\u04ab\u04ac\7c\2\2\u04ac\u04ad\7z\2\2\u04ad")
> >
> > +
> >
> buf.write("\u04ae\7u\2\2\u04ae\u04af\7k\2\2\u04af\u04b0\7|\2\2\u04b0")
> >
> > +
> >
> buf.write("\u04b1\7g\2\2\u04b1\u00d0\3\2\2\2\u04b2\u04b3\7g\2\2\u04b3
> > ")
> >
> > +
> >
> buf.write("\u04b4\7p\2\2\u04b4\u04b5\7e\2\2\u04b5\u04b6\7q\2\2\u04b6"
> > )
> >
> > +
> >
> buf.write("\u04b7\7f\2\2\u04b7\u04b8\7k\2\2\u04b8\u04b9\7p\2\2\u04b9")
> >
> > +
> >
> buf.write("\u04ba\7i\2\2\u04ba\u00d2\3\2\2\2\u04bb\u04bc\7u\2\2\u04bc"
> > )
> >
> > +
> >
> buf.write("\u04bd\7w\2\2\u04bd\u04be\7r\2\2\u04be\u04bf\7r\2\2\u04bf")
> >
> > +
> > buf.write("\u04c0\7t\2\2\u04c0\u04c1\7g\2\2\u04c1\u04c2\7u\2\2\u04c2")
> >
> > +
> >
> buf.write("\u04c3\7u\2\2\u04c3\u04c4\7k\2\2\u04c4\u04c5\7h\2\2\u04c5")
> >
> > +
> >
> buf.write("\u00d4\3\2\2\2\u04c6\u04c7\7f\2\2\u04c7\u04c8\7k\2\2\u04c8")
> >
> > +
> >
> buf.write("\u04c9\7u\2\2\u04c9\u04ca\7c\2\2\u04ca\u04cb\7d\2\2\u04cb")
> >
> > +
> > buf.write("\u04cc\7n\2\2\u04cc\u04cd\7g\2\2\u04cd\u04ce\7k\2\2\u04ce")
> >
> > +
> >
> buf.write("\u04cf\7h\2\2\u04cf\u00d6\3\2\2\2\u04d0\u04d1\7j\2\2\u04d1")
> >
> > +
> >
> buf.write("\u04d2\7k\2\2\u04d2\u04d3\7f\2\2\u04d3\u04d4\7f\2\2\u04d4")
> >
> > +
> >
> buf.write("\u04d5\7g\2\2\u04d5\u04d6\7p\2\2\u04d6\u00d8\3\2\2\2\u04d7
> > ")
> >
> > +
> >
> buf.write("\u04d8\7i\2\2\u04d8\u04d9\7q\2\2\u04d9\u04da\7v\2\2\u04da")
> >
> > +
> >
> buf.write("\u04db\7q\2\2\u04db\u00da\3\2\2\2\u04dc\u04dd\7h\2\2\u04dd
> > ")
> >
> > +
> >
> buf.write("\u04de\7q\2\2\u04de\u04df\7t\2\2\u04df\u04e0\7o\2\2\u04e0")
> >
> > +
> >
> buf.write("\u04e1\7u\2\2\u04e1\u04e2\7g\2\2\u04e2\u04e3\7v\2\2\u04e3")
> >
> > +
> >
> buf.write("\u04e4\7i\2\2\u04e4\u04e5\7w\2\2\u04e5\u04e6\7k\2\2\u04e6")
> >
> > +
> >
> buf.write("\u04e7\7f\2\2\u04e7\u00dc\3\2\2\2\u04e8\u04e9\7k\2\2\u04e9")
> >
> > +
> >
> buf.write("\u04ea\7p\2\2\u04ea\u04eb\7e\2\2\u04eb\u04ec\7q\2\2\u04ec")
> >
> > +
> >
> buf.write("\u04ed\7p\2\2\u04ed\u04ee\7u\2\2\u04ee\u04ef\7k\2\2\u04ef")
> >
> > +
> > buf.write("\u04f0\7u\2\2\u04f0\u04f1\7v\2\2\u04f1\u04f2\7g\2\2\u04f2")
> >
> > +
> > buf.write("\u04f3\7p\2\2\u04f3\u04f4\7v\2\2\u04f4\u04f5\7k\2\2\u04f5")
> >
> > +
> >
> buf.write("\u04f6\7h\2\2\u04f6\u00de\3\2\2\2\u04f7\u04f8\7y\2\2\u04f8")
> >
> > +
> > buf.write("\u04f9\7c\2\2\u04f9\u04fa\7t\2\2\u04fa\u04fb\7p\2\2\u04fb")
> >
> > +
> > buf.write("\u04fc\7k\2\2\u04fc\u04fd\7p\2\2\u04fd\u04fe\7i\2\2\u04fe")
> >
> > +
> >
> buf.write("\u04ff\7k\2\2\u04ff\u0500\7h\2\2\u0500\u00e0\3\2\2\2\u0501")
> >
> > +
> >
> buf.write("\u0502\7p\2\2\u0502\u0503\7q\2\2\u0503\u0504\7u\2\2\u0504")
> >
> > +
> >
> buf.write("\u0505\7w\2\2\u0505\u0506\7d\2\2\u0506\u0507\7o\2\2\u0507"
> > )
> >
> > +
> >
> buf.write("\u0508\7k\2\2\u0508\u0509\7v\2\2\u0509\u050a\7k\2\2\u050a")
> >
> > +
> >
> buf.write("\u050b\7h\2\2\u050b\u00e2\3\2\2\2\u050c\u050d\7g\2\2\u050d"
> > )
> >
> > +
> > buf.write("\u050e\7p\2\2\u050e\u050f\7f\2\2\u050f\u0510\7k\2\2\u0510")
> >
> > +
> >
> buf.write("\u0511\7h\2\2\u0511\u00e4\3\2\2\2\u0512\u0513\7m\2\2\u0513
> > ")
> >
> > +
> >
> buf.write("\u0514\7g\2\2\u0514\u0515\7{\2\2\u0515\u00e6\3\2\2\2\u0516")
> >
> > +
> >
> buf.write("\u0517\7F\2\2\u0517\u0518\7G\2\2\u0518\u0519\7H\2\2\u0519"
> > )
> >
> > +
> >
> buf.write("\u051a\7C\2\2\u051a\u051b\7W\2\2\u051b\u051c\7N\2\2\u051c"
> > )
> >
> > +
> >
> buf.write("\u051d\7V\2\2\u051d\u00e8\3\2\2\2\u051e\u051f\7O\2\2\u051f"
> > )
> >
> > +
> >
> buf.write("\u0520\7C\2\2\u0520\u0521\7P\2\2\u0521\u0522\7W\2\2\u0522"
> > )
> >
> > +
> >
> buf.write("\u0523\7H\2\2\u0523\u0524\7C\2\2\u0524\u0525\7E\2\2\u0525")
> >
> > +
> >
> buf.write("\u0526\7V\2\2\u0526\u0527\7W\2\2\u0527\u0528\7T\2\2\u0528"
> > )
> >
> > +
> >
> buf.write("\u0529\7K\2\2\u0529\u052a\7P\2\2\u052a\u052b\7I\2\2\u052b")
> >
> > +
> >
> buf.write("\u00ea\3\2\2\2\u052c\u052d\7E\2\2\u052d\u052e\7J\2\2\u052e")
> >
> > +
> >
> buf.write("\u052f\7G\2\2\u052f\u0530\7E\2\2\u0530\u0531\7M\2\2\u0531")
> >
> > +
> >
> buf.write("\u0532\7D\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7Z\2\2\u0534"
> > )
> >
> > +
> >
> buf.write("\u0535\7a\2\2\u0535\u0536\7F\2\2\u0536\u0537\7G\2\2\u0537")
> >
> > +
> >
> buf.write("\u0538\7H\2\2\u0538\u0539\7C\2\2\u0539\u053a\7W\2\2\u053a
> > ")
> >
> > +
> >
> buf.write("\u053b\7N\2\2\u053b\u053c\7V\2\2\u053c\u00ec\3\2\2\2\u053d"
> > )
> >
> > +
> >
> buf.write("\u053e\7E\2\2\u053e\u053f\7J\2\2\u053f\u0540\7G\2\2\u0540")
> >
> > +
> >
> buf.write("\u0541\7E\2\2\u0541\u0542\7M\2\2\u0542\u0543\7D\2\2\u0543"
> > )
> >
> > +
> >
> buf.write("\u0544\7Q\2\2\u0544\u0545\7Z\2\2\u0545\u0546\7a\2\2\u0546")
> >
> > +
> >
> buf.write("\u0547\7F\2\2\u0547\u0548\7G\2\2\u0548\u0549\7H\2\2\u0549"
> > )
> >
> > +
> >
> buf.write("\u054a\7C\2\2\u054a\u054b\7W\2\2\u054b\u054c\7N\2\2\u054c"
> > )
> >
> > +
> >
> buf.write("\u054d\7V\2\2\u054d\u054e\7a\2\2\u054e\u054f\7O\2\2\u054f")
> >
> > +
> >
> buf.write("\u0550\7H\2\2\u0550\u0551\7I\2\2\u0551\u00ee\3\2\2\2\u0552"
> > )
> >
> > +
> >
> buf.write("\u0553\7K\2\2\u0553\u0554\7P\2\2\u0554\u0555\7V\2\2\u0555")
> >
> > +
> >
> buf.write("\u0556\7G\2\2\u0556\u0557\7T\2\2\u0557\u0558\7C\2\2\u0558")
> >
> > +
> >
> buf.write("\u0559\7E\2\2\u0559\u055a\7V\2\2\u055a\u055b\7K\2\2\u055b")
> >
> > +
> >
> buf.write("\u055c\7X\2\2\u055c\u055d\7G\2\2\u055d\u00f0\3\2\2\2\u055e"
> > )
> >
> > +
> >
> buf.write("\u055f\7P\2\2\u055f\u0560\7X\2\2\u0560\u0561\7a\2\2\u0561")
> >
> > +
> >
> buf.write("\u0562\7C\2\2\u0562\u0563\7E\2\2\u0563\u0564\7E\2\2\u0564")
> >
> > +
> >
> buf.write("\u0565\7G\2\2\u0565\u0566\7U\2\2\u0566\u0567\7U\2\2\u0567"
> > )
> >
> > +
> >
> buf.write("\u00f2\3\2\2\2\u0568\u0569\7T\2\2\u0569\u056a\7G\2\2\u056a"
> > )
> >
> > +
> >
> buf.write("\u056b\7U\2\2\u056b\u056c\7G\2\2\u056c\u056d\7V\2\2\u056d"
> > )
> >
> > +
> >
> buf.write("\u056e\7a\2\2\u056e\u056f\7T\2\2\u056f\u0570\7G\2\2\u0570")
> >
> > +
> >
> buf.write("\u0571\7S\2\2\u0571\u0572\7W\2\2\u0572\u0573\7K\2\2\u0573"
> > )
> >
> > +
> >
> buf.write("\u0574\7T\2\2\u0574\u0575\7G\2\2\u0575\u0576\7F\2\2\u0576")
> >
> > +
> >
> buf.write("\u00f4\3\2\2\2\u0577\u0578\7T\2\2\u0578\u0579\7G\2\2\u0579"
> > )
> >
> > +
> >
> buf.write("\u057a\7E\2\2\u057a\u057b\7Q\2\2\u057b\u057c\7P\2\2\u057c")
> >
> > +
> >
> buf.write("\u057d\7P\2\2\u057d\u057e\7G\2\2\u057e\u057f\7E\2\2\u057f")
> >
> > +
> >
> buf.write("\u0580\7V\2\2\u0580\u0581\7a\2\2\u0581\u0582\7T\2\2\u0582")
> >
> > +
> >
> buf.write("\u0583\7G\2\2\u0583\u0584\7S\2\2\u0584\u0585\7W\2\2\u0585"
> > )
> >
> > +
> >
> buf.write("\u0586\7K\2\2\u0586\u0587\7T\2\2\u0587\u0588\7G\2\2\u0588")
> >
> > +
> >
> buf.write("\u0589\7F\2\2\u0589\u00f6\3\2\2\2\u058a\u058b\7N\2\2\u058b"
> > )
> >
> > +
> >
> buf.write("\u058c\7C\2\2\u058c\u058d\7V\2\2\u058d\u058e\7G\2\2\u058e")
> >
> > +
> > buf.write("\u058f\7a\2\2\u058f\u0590\7E\2\2\u0590\u0591\7J\2\2\u0591")
> >
> > +
> >
> buf.write("\u0592\7G\2\2\u0592\u0593\7E\2\2\u0593\u0594\7M\2\2\u0594"
> > )
> >
> > +
> >
> buf.write("\u00f8\3\2\2\2\u0595\u0596\7T\2\2\u0596\u0597\7G\2\2\u0597"
> > )
> >
> > +
> >
> buf.write("\u0598\7C\2\2\u0598\u0599\7F\2\2\u0599\u059a\7a\2\2\u059a")
> >
> > +
> >
> buf.write("\u059b\7Q\2\2\u059b\u059c\7P\2\2\u059c\u059d\7N\2\2\u059d"
> > )
> >
> > +
> >
> buf.write("\u059e\7[\2\2\u059e\u00fa\3\2\2\2\u059f\u05a0\7Q\2\2\u05a0")
> >
> > +
> >
> buf.write("\u05a1\7R\2\2\u05a1\u05a2\7V\2\2\u05a2\u05a3\7K\2\2\u05a3")
> >
> > +
> >
> buf.write("\u05a4\7Q\2\2\u05a4\u05a5\7P\2\2\u05a5\u05a6\7U\2\2\u05a6"
> > )
> >
> > +
> >
> buf.write("\u05a7\7a\2\2\u05a7\u05a8\7Q\2\2\u05a8\u05a9\7P\2\2\u05a9")
> >
> > +
> >
> buf.write("\u05aa\7N\2\2\u05aa\u05ab\7[\2\2\u05ab\u00fc\3\2\2\2\u05ac")
> >
> > +
> >
> buf.write("\u05ad\7T\2\2\u05ad\u05ae\7G\2\2\u05ae\u05af\7U\2\2\u05af")
> >
> > +
> >
> buf.write("\u05b0\7V\2\2\u05b0\u05b1\7a\2\2\u05b1\u05b2\7U\2\2\u05b2"
> > )
> >
> > +
> >
> buf.write("\u05b3\7V\2\2\u05b3\u05b4\7[\2\2\u05b4\u05b5\7N\2\2\u05b5"
> > )
> >
> > +
> >
> buf.write("\u05b6\7G\2\2\u05b6\u00fe\3\2\2\2\u05b7\u05b8\7e\2\2\u05b8"
> > )
> >
> > +
> >
> buf.write("\u05b9\7n\2\2\u05b9\u05ba\7c\2\2\u05ba\u05bb\7u\2\2\u05bb"
> > )
> >
> > +
> >
> buf.write("\u05bc\7u\2\2\u05bc\u0100\3\2\2\2\u05bd\u05be\7u\2\2\u05be
> > ")
> >
> > +
> >
> buf.write("\u05bf\7w\2\2\u05bf\u05c0\7d\2\2\u05c0\u05c1\7e\2\2\u05c1")
> >
> > +
> > buf.write("\u05c2\7n\2\2\u05c2\u05c3\7c\2\2\u05c3\u05c4\7u\2\2\u05c4")
> >
> > +
> >
> buf.write("\u05c5\7u\2\2\u05c5\u0102\3\2\2\2\u05c6\u05c7\7e\2\2\u05c7")
> >
> > +
> > buf.write("\u05c8\7n\2\2\u05c8\u05c9\7c\2\2\u05c9\u05ca\7u\2\2\u05ca")
> >
> > +
> > buf.write("\u05cb\7u\2\2\u05cb\u05cc\7i\2\2\u05cc\u05cd\7w\2\2\u05cd")
> >
> > +
> > buf.write("\u05ce\7k\2\2\u05ce\u05cf\7f\2\2\u05cf\u0104\3\2\2\2\u05d0")
> >
> > +
> >
> buf.write("\u05d1\7v\2\2\u05d1\u05d2\7{\2\2\u05d2\u05d3\7r\2\2\u05d3")
> >
> > +
> >
> buf.write("\u05d4\7g\2\2\u05d4\u05d5\7f\2\2\u05d5\u05d6\7g\2\2\u05d6")
> >
> > +
> >
> buf.write("\u05d7\7h\2\2\u05d7\u0106\3\2\2\2\u05d8\u05d9\7t\2\2\u05d9"
> > )
> >
> > +
> >
> buf.write("\u05da\7g\2\2\u05da\u05db\7u\2\2\u05db\u05dc\7v\2\2\u05dc")
> >
> > +
> >
> buf.write("\u05dd\7q\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7g\2\2\u05df")
> >
> > +
> >
> buf.write("\u0108\3\2\2\2\u05e0\u05e1\7u\2\2\u05e1\u05e2\7c\2\2\u05e2"
> > )
> >
> > +
> >
> buf.write("\u05e3\7x\2\2\u05e3\u05e4\7g\2\2\u05e4\u010a\3\2\2\2\u05e5"
> > )
> >
> > +
> >
> buf.write("\u05e6\7f\2\2\u05e6\u05e7\7g\2\2\u05e7\u05e8\7h\2\2\u05e8")
> >
> > +
> >
> buf.write("\u05e9\7c\2\2\u05e9\u05ea\7w\2\2\u05ea\u05eb\7n\2\2\u05eb"
> > )
> >
> > +
> >
> buf.write("\u05ec\7v\2\2\u05ec\u05ed\7u\2\2\u05ed\u010c\3\2\2\2\u05ee")
> >
> > +
> > buf.write("\u05ef\7d\2\2\u05ef\u05f0\7c\2\2\u05f0\u05f1\7p\2\2\u05f1")
> >
> > +
> > buf.write("\u05f2\7p\2\2\u05f2\u05f3\7g\2\2\u05f3\u05f4\7t\2\2\u05f4")
> >
> > +
> > buf.write("\u010e\3\2\2\2\u05f5\u05f6\7c\2\2\u05f6\u05f7\7n\2\2\u05f7")
> >
> > +
> > buf.write("\u05f8\7k\2\2\u05f8\u05f9\7i\2\2\u05f9\u05fa\7p\2\2\u05fa")
> >
> > +
> > buf.write("\u0110\3\2\2\2\u05fb\u05fc\7n\2\2\u05fc\u05fd\7g\2\2\u05fd")
> >
> > +
> > buf.write("\u05fe\7h\2\2\u05fe\u05ff\7v\2\2\u05ff\u0112\3\2\2\2\u0600")
> >
> > +
> >
> buf.write("\u0601\7t\2\2\u0601\u0602\7k\2\2\u0602\u0603\7i\2\2\u0603")
> >
> > +
> >
> buf.write("\u0604\7j\2\2\u0604\u0605\7v\2\2\u0605\u0114\3\2\2\2\u0606")
> >
> > +
> >
> buf.write("\u0607\7e\2\2\u0607\u0608\7g\2\2\u0608\u0609\7p\2\2\u0609")
> >
> > +
> >
> buf.write("\u060a\7v\2\2\u060a\u060b\7g\2\2\u060b\u060c\7t\2\2\u060c")
> >
> > +
> >
> buf.write("\u0116\3\2\2\2\u060d\u060e\7n\2\2\u060e\u060f\7k\2\2\u060f")
> >
> > +
> >
> buf.write("\u0610\7p\2\2\u0610\u0611\7g\2\2\u0611\u0118\3\2\2\2\u0612"
> > )
> >
> > +
> >
> buf.write("\u0613\7p\2\2\u0613\u0614\7c\2\2\u0614\u0615\7o\2\2\u0615")
> >
> > +
> >
> buf.write("\u0616\7g\2\2\u0616\u011a\3\2\2\2\u0617\u0618\7x\2\2\u0618"
> > )
> >
> > +
> >
> buf.write("\u0619\7c\2\2\u0619\u061a\7t\2\2\u061a\u061b\7k\2\2\u061b")
> >
> > +
> >
> buf.write("\u061c\7f\2\2\u061c\u011c\3\2\2\2\u061d\u061e\7s\2\2\u061e")
> >
> > +
> >
> buf.write("\u061f\7w\2\2\u061f\u0620\7g\2\2\u0620\u0621\7u\2\2\u0621")
> >
> > +
> >
> buf.write("\u0622\7v\2\2\u0622\u0623\7k\2\2\u0623\u0624\7q\2\2\u0624")
> >
> > +
> >
> buf.write("\u0625\7p\2\2\u0625\u011e\3\2\2\2\u0626\u0627\7s\2\2\u0627"
> > )
> >
> > +
> >
> buf.write("\u0628\7w\2\2\u0628\u0629\7g\2\2\u0629\u062a\7u\2\2\u062a"
> > )
> >
> > +
> >
> buf.write("\u062b\7v\2\2\u062b\u062c\7k\2\2\u062c\u062d\7q\2\2\u062d")
> >
> > +
> > buf.write("\u062e\7p\2\2\u062e\u062f\7k\2\2\u062f\u0630\7f\2\2\u0630")
> >
> > +
> >
> buf.write("\u0120\3\2\2\2\u0631\u0632\7k\2\2\u0632\u0633\7o\2\2\u0633"
> > )
> >
> > +
> >
> buf.write("\u0634\7c\2\2\u0634\u0635\7i\2\2\u0635\u0636\7g\2\2\u0636")
> >
> > +
> >
> buf.write("\u0122\3\2\2\2\u0637\u0638\7n\2\2\u0638\u0639\7q\2\2\u0639"
> > )
> >
> > +
> >
> buf.write("\u063a\7e\2\2\u063a\u063b\7m\2\2\u063b\u063c\7g\2\2\u063c")
> >
> > +
> >
> buf.write("\u063d\7f\2\2\u063d\u0124\3\2\2\2\u063e\u063f\7t\2\2\u063f")
> >
> > +
> >
> buf.write("\u0640\7w\2\2\u0640\u0641\7n\2\2\u0641\u0642\7g\2\2\u0642"
> > )
> >
> > +
> >
> buf.write("\u0126\3\2\2\2\u0643\u0644\7g\2\2\u0644\u0645\7p\2\2\u0645"
> > )
> >
> > +
> >
> buf.write("\u0646\7f\2\2\u0646\u0647\7t\2\2\u0647\u0648\7w\2\2\u0648")
> >
> > +
> >
> buf.write("\u0649\7n\2\2\u0649\u064a\7g\2\2\u064a\u0128\3\2\2\2\u064b"
> > )
> >
> > +
> >
> buf.write("\u064c\7x\2\2\u064c\u064d\7c\2\2\u064d\u064e\7n\2\2\u064e")
> >
> > +
> >
> buf.write("\u064f\7w\2\2\u064f\u0650\7g\2\2\u0650\u012a\3\2\2\2\u0651")
> >
> > +
> >
> buf.write("\u0652\7t\2\2\u0652\u0653\7g\2\2\u0653\u0654\7c\2\2\u0654")
> >
> > +
> >
> buf.write("\u0655\7f\2\2\u0655\u012c\3\2\2\2\u0656\u0657\7y\2\2\u0657")
> >
> > +
> >
> buf.write("\u0658\7t\2\2\u0658\u0659\7k\2\2\u0659\u065a\7v\2\2\u065a")
> >
> > +
> >
> buf.write("\u065b\7g\2\2\u065b\u012e\3\2\2\2\u065c\u065d\7t\2\2\u065d"
> > )
> >
> > +
> >
> buf.write("\u065e\7g\2\2\u065e\u065f\7u\2\2\u065f\u0660\7g\2\2\u0660")
> >
> > +
> >
> buf.write("\u0661\7v\2\2\u0661\u0662\7d\2\2\u0662\u0663\7w\2\2\u0663"
> > )
> >
> > +
> >
> buf.write("\u0664\7v\2\2\u0664\u0665\7v\2\2\u0665\u0666\7q\2\2\u0666")
> >
> > +
> >
> buf.write("\u0667\7p\2\2\u0667\u0130\3\2\2\2\u0668\u0669\7g\2\2\u0669"
> > )
> >
> > +
> >
> buf.write("\u066a\7p\2\2\u066a\u066b\7f\2\2\u066b\u066c\7t\2\2\u066c")
> >
> > +
> >
> buf.write("\u066d\7g\2\2\u066d\u066e\7u\2\2\u066e\u066f\7g\2\2\u066f")
> >
> > +
> >
> buf.write("\u0670\7v\2\2\u0670\u0671\7d\2\2\u0671\u0672\7w\2\2\u0672"
> > )
> >
> > +
> >
> buf.write("\u0673\7v\2\2\u0673\u0674\7v\2\2\u0674\u0675\7q\2\2\u0675")
> >
> > +
> >
> buf.write("\u0676\7p\2\2\u0676\u0132\3\2\2\2\u0677\u0678\7f\2\2\u0678"
> > )
> >
> > +
> >
> buf.write("\u0679\7g\2\2\u0679\u067a\7h\2\2\u067a\u067b\7c\2\2\u067b")
> >
> > +
> >
> buf.write("\u067c\7w\2\2\u067c\u067d\7n\2\2\u067d\u067e\7v\2\2\u067e")
> >
> > +
> >
> buf.write("\u067f\7u\2\2\u067f\u0680\7v\2\2\u0680\u0681\7q\2\2\u0681")
> >
> > +
> >
> buf.write("\u0682\7t\2\2\u0682\u0683\7g\2\2\u0683\u0134\3\2\2\2\u0684")
> >
> > +
> >
> buf.write("\u0685\7c\2\2\u0685\u0686\7v\2\2\u0686\u0687\7v\2\2\u0687")
> >
> > +
> >
> buf.write("\u0688\7t\2\2\u0688\u0689\7k\2\2\u0689\u068a\7d\2\2\u068a")
> >
> > +
> >
> buf.write("\u068b\7w\2\2\u068b\u068c\7v\2\2\u068c\u068d\7g\2\2\u068d")
> >
> > +
> >
> buf.write("\u0136\3\2\2\2\u068e\u068f\7x\2\2\u068f\u0690\7c\2\2\u0690")
> >
> > +
> >
> buf.write("\u0691\7t\2\2\u0691\u0692\7u\2\2\u0692\u0693\7v\2\2\u0693")
> >
> > +
> >
> buf.write("\u0694\7q\2\2\u0694\u0695\7t\2\2\u0695\u0696\7g\2\2\u0696")
> >
> > +
> >
> buf.write("\u0138\3\2\2\2\u0697\u0698\7g\2\2\u0698\u0699\7h\2\2\u0699"
> > )
> >
> > +
> >
> buf.write("\u069a\7k\2\2\u069a\u069b\7x\2\2\u069b\u069c\7c\2\2\u069c")
> >
> > +
> >
> buf.write("\u069d\7t\2\2\u069d\u069e\7u\2\2\u069e\u069f\7v\2\2\u069f")
> >
> > +
> >
> buf.write("\u06a0\7q\2\2\u06a0\u06a1\7t\2\2\u06a1\u06a2\7g\2\2\u06a2")
> >
> > +
> >
> buf.write("\u013a\3\2\2\2\u06a3\u06a4\7x\2\2\u06a4\u06a5\7c\2\2\u06a5"
> > )
> >
> > +
> >
> buf.write("\u06a6\7t\2\2\u06a6\u06a7\7u\2\2\u06a7\u06a8\7k\2\2\u06a8")
> >
> > +
> >
> buf.write("\u06a9\7|\2\2\u06a9\u06aa\7g\2\2\u06aa\u013c\3\2\2\2\u06ab"
> > )
> >
> > +
> >
> buf.write("\u06ac\7p\2\2\u06ac\u06ad\7c\2\2\u06ad\u06ae\7o\2\2\u06ae")
> >
> > +
> >
> buf.write("\u06af\7g\2\2\u06af\u06b0\7x\2\2\u06b0\u06b1\7c\2\2\u06b1")
> >
> > +
> >
> buf.write("\u06b2\7n\2\2\u06b2\u06b3\7w\2\2\u06b3\u06b4\7g\2\2\u06b4"
> > )
> >
> > +
> >
> buf.write("\u06b5\7x\2\2\u06b5\u06b6\7c\2\2\u06b6\u06b7\7t\2\2\u06b7")
> >
> > +
> >
> buf.write("\u06b8\7u\2\2\u06b8\u06b9\7v\2\2\u06b9\u06ba\7q\2\2\u06ba"
> > )
> >
> > +
> >
> buf.write("\u06bb\7t\2\2\u06bb\u06bc\7g\2\2\u06bc\u013e\3\2\2\2\u06bd"
> > )
> >
> > +
> > buf.write("\u06be\7c\2\2\u06be\u06bf\7e\2\2\u06bf\u06c0\7v\2\2\u06c0")
> >
> > +
> >
> buf.write("\u06c1\7k\2\2\u06c1\u06c2\7q\2\2\u06c2\u06c3\7p\2\2\u06c3")
> >
> > +
> >
> buf.write("\u0140\3\2\2\2\u06c4\u06c5\7e\2\2\u06c5\u06c6\7q\2\2\u06c6")
> >
> > +
> >
> buf.write("\u06c7\7p\2\2\u06c7\u06c8\7h\2\2\u06c8\u06c9\7k\2\2\u06c9")
> >
> > +
> > buf.write("\u06ca\7i\2\2\u06ca\u0142\3\2\2\2\u06cb\u06cc\7g\2\2\u06cc")
> >
> > +
> > buf.write("\u06cd\7p\2\2\u06cd\u06ce\7f\2\2\u06ce\u06cf\7c\2\2\u06cf")
> >
> > +
> >
> buf.write("\u06d0\7e\2\2\u06d0\u06d1\7v\2\2\u06d1\u06d2\7k\2\2\u06d2")
> >
> > +
> >
> buf.write("\u06d3\7q\2\2\u06d3\u06d4\7p\2\2\u06d4\u0144\3\2\2\2\u06d5
> > ")
> >
> > +
> >
> buf.write("\u06d6\7t\2\2\u06d6\u06d7\7g\2\2\u06d7\u06d8\7h\2\2\u06d8")
> >
> > +
> >
> buf.write("\u06d9\7t\2\2\u06d9\u06da\7g\2\2\u06da\u06db\7u\2\2\u06db")
> >
> > +
> >
> buf.write("\u06dc\7j\2\2\u06dc\u0146\3\2\2\2\u06dd\u06de\7k\2\2\u06de")
> >
> > +
> >
> buf.write("\u06df\7p\2\2\u06df\u06e0\7v\2\2\u06e0\u06e1\7g\2\2\u06e1")
> >
> > +
> >
> buf.write("\u06e2\7t\2\2\u06e2\u06e3\7x\2\2\u06e3\u06e4\7c\2\2\u06e4")
> >
> > +
> >
> buf.write("\u06e5\7n\2\2\u06e5\u0148\3\2\2\2\u06e6\u06e7\7x\2\2\u06e7"
> > )
> >
> > +
> >
> buf.write("\u06e8\7c\2\2\u06e8\u06e9\7t\2\2\u06e9\u06ea\7u\2\2\u06ea")
> >
> > +
> >
> buf.write("\u06eb\7v\2\2\u06eb\u06ec\7q\2\2\u06ec\u06ed\7t\2\2\u06ed")
> >
> > +
> > buf.write("\u06ee\7g\2\2\u06ee\u06ef\7f\2\2\u06ef\u06f0\7g\2\2\u06f0")
> >
> > +
> > buf.write("\u06f1\7x\2\2\u06f1\u06f2\7k\2\2\u06f2\u06f3\7e\2\2\u06f3")
> >
> > +
> > buf.write("\u06f4\7g\2\2\u06f4\u014a\3\2\2\2\u06f5\u06f6\7i\2\2\u06f6")
> >
> > +
> > buf.write("\u06f7\7w\2\2\u06f7\u06f8\7k\2\2\u06f8\u06f9\7f\2\2\u06f9")
> >
> > +
> > buf.write("\u06fa\7q\2\2\u06fa\u06fb\7r\2\2\u06fb\u014c\3\2\2\2\u06fc")
> >
> > +
> > buf.write("\u06fd\7g\2\2\u06fd\u06fe\7p\2\2\u06fe\u06ff\7f\2\2\u06ff")
> >
> > +
> >
> buf.write("\u0700\7i\2\2\u0700\u0701\7w\2\2\u0701\u0702\7k\2\2\u0702")
> >
> > +
> >
> buf.write("\u0703\7f\2\2\u0703\u0704\7q\2\2\u0704\u0705\7r\2\2\u0705")
> >
> > +
> >
> buf.write("\u014e\3\2\2\2\u0706\u0707\7f\2\2\u0707\u0708\7c\2\2\u0708")
> >
> > +
> >
> buf.write("\u0709\7v\2\2\u0709\u070a\7c\2\2\u070a\u070b\7v\2\2\u070b")
> >
> > +
> >
> buf.write("\u070c\7{\2\2\u070c\u070d\7r\2\2\u070d\u070e\7g\2\2\u070e")
> >
> > +
> >
> buf.write("\u0150\3\2\2\2\u070f\u0710\7f\2\2\u0710\u0711\7c\2\2\u0711")
> >
> > +
> >
> buf.write("\u0712\7v\2\2\u0712\u0713\7c\2\2\u0713\u0152\3\2\2\2\u0714"
> > )
> >
> > +
> >
> buf.write("\u0715\7o\2\2\u0715\u0716\7q\2\2\u0716\u0717\7f\2\2\u0717")
> >
> > +
> >
> buf.write("\u0718\7c\2\2\u0718\u0719\7n\2\2\u0719\u0154\3\2\2\2\u071a"
> > )
> >
> > +
> >
> buf.write("\u071b\7P\2\2\u071b\u071c\7Q\2\2\u071c\u071d\7P\2\2\u071d")
> >
> > +
> >
> buf.write("\u071e\7a\2\2\u071e\u071f\7F\2\2\u071f\u0720\7G\2\2\u0720")
> >
> > +
> >
> buf.write("\u0721\7X\2\2\u0721\u0722\7K\2\2\u0722\u0723\7E\2\2\u0723")
> >
> > +
> >
> buf.write("\u0724\7G\2\2\u0724\u0156\3\2\2\2\u0725\u0726\7F\2\2\u0726"
> > )
> >
> > +
> >
> buf.write("\u0727\7K\2\2\u0727\u0728\7U\2\2\u0728\u0729\7M\2\2\u0729"
> > )
> >
> > +
> >
> buf.write("\u072a\7a\2\2\u072a\u072b\7F\2\2\u072b\u072c\7G\2\2\u072c")
> >
> > +
> >
> buf.write("\u072d\7X\2\2\u072d\u072e\7K\2\2\u072e\u072f\7E\2\2\u072f")
> >
> > +
> >
> buf.write("\u0730\7G\2\2\u0730\u0158\3\2\2\2\u0731\u0732\7X\2\2\u0732"
> > )
> >
> > +
> >
> buf.write("\u0733\7K\2\2\u0733\u0734\7F\2\2\u0734\u0735\7G\2\2\u0735")
> >
> > +
> >
> buf.write("\u0736\7Q\2\2\u0736\u0737\7a\2\2\u0737\u0738\7F\2\2\u0738")
> >
> > +
> >
> buf.write("\u0739\7G\2\2\u0739\u073a\7X\2\2\u073a\u073b\7K\2\2\u073b"
> > )
> >
> > +
> >
> buf.write("\u073c\7E\2\2\u073c\u073d\7G\2\2\u073d\u015a\3\2\2\2\u073e"
> > )
> >
> > +
> >
> buf.write("\u073f\7P\2\2\u073f\u0740\7G\2\2\u0740\u0741\7V\2\2\u0741")
> >
> > +
> >
> buf.write("\u0742\7Y\2\2\u0742\u0743\7Q\2\2\u0743\u0744\7T\2\2\u0744")
> >
> > +
> >
> buf.write("\u0745\7M\2\2\u0745\u0746\7a\2\2\u0746\u0747\7F\2\2\u0747"
> > )
> >
> > +
> >
> buf.write("\u0748\7G\2\2\u0748\u0749\7X\2\2\u0749\u074a\7K\2\2\u074a")
> >
> > +
> >
> buf.write("\u074b\7E\2\2\u074b\u074c\7G\2\2\u074c\u015c\3\2\2\2\u074d"
> > )
> >
> > +
> >
> buf.write("\u074e\7K\2\2\u074e\u074f\7P\2\2\u074f\u0750\7R\2\2\u0750")
> >
> > +
> >
> buf.write("\u0751\7W\2\2\u0751\u0752\7V\2\2\u0752\u0753\7a\2\2\u0753"
> > )
> >
> > +
> >
> buf.write("\u0754\7F\2\2\u0754\u0755\7G\2\2\u0755\u0756\7X\2\2\u0756")
> >
> > +
> >
> buf.write("\u0757\7K\2\2\u0757\u0758\7E\2\2\u0758\u0759\7G\2\2\u0759")
> >
> > +
> >
> buf.write("\u015e\3\2\2\2\u075a\u075b\7Q\2\2\u075b\u075c\7P\2\2\u075c"
> > )
> >
> > +
> >
> buf.write("\u075d\7D\2\2\u075d\u075e\7Q\2\2\u075e\u075f\7C\2\2\u075f")
> >
> > +
> >
> buf.write("\u0760\7T\2\2\u0760\u0761\7F\2\2\u0761\u0762\7a\2\2\u0762")
> >
> > +
> >
> buf.write("\u0763\7F\2\2\u0763\u0764\7G\2\2\u0764\u0765\7X\2\2\u0765")
> >
> > +
> >
> buf.write("\u0766\7K\2\2\u0766\u0767\7E\2\2\u0767\u0768\7G\2\2\u0768")
> >
> > +
> >
> buf.write("\u0160\3\2\2\2\u0769\u076a\7Q\2\2\u076a\u076b\7V\2\2\u076b
> > ")
> >
> > +
> >
> buf.write("\u076c\7J\2\2\u076c\u076d\7G\2\2\u076d\u076e\7T\2\2\u076e")
> >
> > +
> >
> buf.write("\u076f\7a\2\2\u076f\u0770\7F\2\2\u0770\u0771\7G\2\2\u0771")
> >
> > +
> >
> buf.write("\u0772\7X\2\2\u0772\u0773\7K\2\2\u0773\u0774\7E\2\2\u0774")
> >
> > +
> >
> buf.write("\u0775\7G\2\2\u0775\u0162\3\2\2\2\u0776\u0777\7U\2\2\u0777
> > ")
> >
> > +
> >
> buf.write("\u0778\7G\2\2\u0778\u0779\7V\2\2\u0779\u077a\7W\2\2\u077a
> > ")
> >
> > +
> >
> buf.write("\u077b\7R\2\2\u077b\u077c\7a\2\2\u077c\u077d\7C\2\2\u077d")
> >
> > +
> >
> buf.write("\u077e\7R\2\2\u077e\u077f\7R\2\2\u077f\u0780\7N\2\2\u0780")
> >
> > +
> >
> buf.write("\u0781\7K\2\2\u0781\u0782\7E\2\2\u0782\u0783\7C\2\2\u0783")
> >
> > +
> >
> buf.write("\u0784\7V\2\2\u0784\u0785\7K\2\2\u0785\u0786\7Q\2\2\u0786"
> > )
> >
> > +
> >
> buf.write("\u0787\7P\2\2\u0787\u0164\3\2\2\2\u0788\u0789\7I\2\2\u0789")
> >
> > +
> >
> buf.write("\u078a\7G\2\2\u078a\u078b\7P\2\2\u078b\u078c\7G\2\2\u078c")
> >
> > +
> >
> buf.write("\u078d\7T\2\2\u078d\u078e\7C\2\2\u078e\u078f\7N\2\2\u078f")
> >
> > +
> >
> buf.write("\u0790\7a\2\2\u0790\u0791\7C\2\2\u0791\u0792\7R\2\2\u0792")
> >
> > +
> >
> buf.write("\u0793\7R\2\2\u0793\u0794\7N\2\2\u0794\u0795\7K\2\2\u0795")
> >
> > +
> >
> buf.write("\u0796\7E\2\2\u0796\u0797\7C\2\2\u0797\u0798\7V\2\2\u0798")
> >
> > +
> >
> buf.write("\u0799\7K\2\2\u0799\u079a\7Q\2\2\u079a\u079b\7P\2\2\u079b"
> > )
> >
> > +
> >
> buf.write("\u0166\3\2\2\2\u079c\u079d\7H\2\2\u079d\u079e\7T\2\2\u079e"
> > )
> >
> > +
> >
> buf.write("\u079f\7Q\2\2\u079f\u07a0\7P\2\2\u07a0\u07a1\7V\2\2\u07a1")
> >
> > +
> >
> buf.write("\u07a2\7a\2\2\u07a2\u07a3\7R\2\2\u07a3\u07a4\7C\2\2\u07a4")
> >
> > +
> >
> buf.write("\u07a5\7I\2\2\u07a5\u07a6\7G\2\2\u07a6\u0168\3\2\2\2\u07a7"
> > )
> >
> > +
> >
> buf.write("\u07a8\7U\2\2\u07a8\u07a9\7K\2\2\u07a9\u07aa\7P\2\2\u07aa")
> >
> > +
> >
> buf.write("\u07ab\7I\2\2\u07ab\u07ac\7N\2\2\u07ac\u07ad\7G\2\2\u07ad")
> >
> > +
> >
> buf.write("\u07ae\7a\2\2\u07ae\u07af\7W\2\2\u07af\u07b0\7U\2\2\u07b0")
> >
> > +
> >
> buf.write("\u07b1\7G\2\2\u07b1\u016a\3\2\2\2\u07b2\u07b3\7[\2\2\u07b3
> > ")
> >
> > +
> >
> buf.write("\u07b4\7G\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7T\2\2\u07b6"
> > )
> >
> > +
> >
> buf.write("\u07b7\7a\2\2\u07b7\u07b8\7U\2\2\u07b8\u07b9\7W\2\2\u07b9
> > ")
> >
> > +
> >
> buf.write("\u07ba\7R\2\2\u07ba\u07bb\7R\2\2\u07bb\u07bc\7T\2\2\u07bc"
> > )
> >
> > +
> >
> buf.write("\u07bd\7G\2\2\u07bd\u07be\7U\2\2\u07be\u07bf\7U\2\2\u07bf"
> > )
> >
> > +
> >
> buf.write("\u016c\3\2\2\2\u07c0\u07c1\7O\2\2\u07c1\u07c2\7Q\2\2\u07c2")
> >
> > +
> > buf.write("\u07c3\7P\2\2\u07c3\u07c4\7V\2\2\u07c4\u07c5\7J\2\2\u07c5")
> >
> > +
> >
> buf.write("\u07c6\7a\2\2\u07c6\u07c7\7U\2\2\u07c7\u07c8\7W\2\2\u07c8")
> >
> > +
> >
> buf.write("\u07c9\7R\2\2\u07c9\u07ca\7R\2\2\u07ca\u07cb\7T\2\2\u07cb")
> >
> > +
> >
> buf.write("\u07cc\7G\2\2\u07cc\u07cd\7U\2\2\u07cd\u07ce\7U\2\2\u07ce")
> >
> > +
> >
> buf.write("\u016e\3\2\2\2\u07cf\u07d0\7F\2\2\u07d0\u07d1\7C\2\2\u07d1"
> > )
> >
> > +
> >
> buf.write("\u07d2\7[\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d4\7U\2\2\u07d4"
> > )
> >
> > +
> >
> buf.write("\u07d5\7W\2\2\u07d5\u07d6\7R\2\2\u07d6\u07d7\7R\2\2\u07d7
> > ")
> >
> > +
> >
> buf.write("\u07d8\7T\2\2\u07d8\u07d9\7G\2\2\u07d9\u07da\7U\2\2\u07da
> > ")
> >
> > +
> >
> buf.write("\u07db\7U\2\2\u07db\u0170\3\2\2\2\u07dc\u07dd\7J\2\2\u07dd
> > ")
> >
> > +
> >
> buf.write("\u07de\7Q\2\2\u07de\u07df\7W\2\2\u07df\u07e0\7T\2\2\u07e0"
> > )
> >
> > +
> >
> buf.write("\u07e1\7a\2\2\u07e1\u07e2\7U\2\2\u07e2\u07e3\7W\2\2\u07e3
> > ")
> >
> > +
> >
> buf.write("\u07e4\7R\2\2\u07e4\u07e5\7R\2\2\u07e5\u07e6\7T\2\2\u07e6")
> >
> > +
> >
> buf.write("\u07e7\7G\2\2\u07e7\u07e8\7U\2\2\u07e8\u07e9\7U\2\2\u07e9"
> > )
> >
> > +
> >
> buf.write("\u0172\3\2\2\2\u07ea\u07eb\7O\2\2\u07eb\u07ec\7K\2\2\u07ec"
> > )
> >
> > +
> >
> buf.write("\u07ed\7P\2\2\u07ed\u07ee\7W\2\2\u07ee\u07ef\7V\2\2\u07ef")
> >
> > +
> > buf.write("\u07f0\7G\2\2\u07f0\u07f1\7a\2\2\u07f1\u07f2\7U\2\2\u07f2")
> >
> > +
> > buf.write("\u07f3\7W\2\2\u07f3\u07f4\7R\2\2\u07f4\u07f5\7R\2\2\u07f5")
> >
> > +
> > buf.write("\u07f6\7T\2\2\u07f6\u07f7\7G\2\2\u07f7\u07f8\7U\2\2\u07f8")
> >
> > +
> >
> buf.write("\u07f9\7U\2\2\u07f9\u0174\3\2\2\2\u07fa\u07fb\7U\2\2\u07fb")
> >
> > +
> > buf.write("\u07fc\7G\2\2\u07fc\u07fd\7E\2\2\u07fd\u07fe\7Q\2\2\u07fe")
> >
> > +
> > buf.write("\u07ff\7P\2\2\u07ff\u0800\7F\2\2\u0800\u0801\7a\2\2\u0801")
> >
> > +
> >
> buf.write("\u0802\7U\2\2\u0802\u0803\7W\2\2\u0803\u0804\7R\2\2\u0804
> > ")
> >
> > +
> >
> buf.write("\u0805\7R\2\2\u0805\u0806\7T\2\2\u0806\u0807\7G\2\2\u0807")
> >
> > +
> >
> buf.write("\u0808\7U\2\2\u0808\u0809\7U\2\2\u0809\u0176\3\2\2\2\u080a
> > ")
> >
> > +
> >
> buf.write("\u080b\7U\2\2\u080b\u080c\7V\2\2\u080c\u080d\7Q\2\2\u080d"
> > )
> >
> > +
> > buf.write("\u080e\7T\2\2\u080e\u080f\7C\2\2\u080f\u0810\7I\2\2\u0810")
> >
> > +
> >
> buf.write("\u0811\7G\2\2\u0811\u0812\7a\2\2\u0812\u0813\7P\2\2\u0813")
> >
> > +
> >
> buf.write("\u0814\7Q\2\2\u0814\u0815\7T\2\2\u0815\u0816\7O\2\2\u0816"
> > )
> >
> > +
> >
> buf.write("\u0817\7C\2\2\u0817\u0818\7N\2\2\u0818\u0178\3\2\2\2\u0819
> > ")
> >
> > +
> >
> buf.write("\u081a\7U\2\2\u081a\u081b\7V\2\2\u081b\u081c\7Q\2\2\u081c"
> > )
> >
> > +
> >
> buf.write("\u081d\7T\2\2\u081d\u081e\7C\2\2\u081e\u081f\7I\2\2\u081f")
> >
> > +
> >
> buf.write("\u0820\7G\2\2\u0820\u0821\7a\2\2\u0821\u0822\7V\2\2\u0822")
> >
> > +
> >
> buf.write("\u0823\7K\2\2\u0823\u0824\7O\2\2\u0824\u0825\7G\2\2\u0825"
> > )
> >
> > +
> >
> buf.write("\u017a\3\2\2\2\u0826\u0827\7U\2\2\u0827\u0828\7V\2\2\u0828
> > ")
> >
> > +
> >
> buf.write("\u0829\7Q\2\2\u0829\u082a\7T\2\2\u082a\u082b\7C\2\2\u082b"
> > )
> >
> > +
> >
> buf.write("\u082c\7I\2\2\u082c\u082d\7G\2\2\u082d\u082e\7a\2\2\u082e")
> >
> > +
> >
> buf.write("\u082f\7Y\2\2\u082f\u0830\7C\2\2\u0830\u0831\7M\2\2\u0831")
> >
> > +
> >
> buf.write("\u0832\7G\2\2\u0832\u0833\7W\2\2\u0833\u0834\7R\2\2\u0834
> > ")
> >
> > +
> >
> buf.write("\u017c\3\2\2\2\u0835\u0836\7W\2\2\u0836\u0837\7P\2\2\u0837
> > ")
> >
> > +
> >
> buf.write("\u0838\7K\2\2\u0838\u0839\7S\2\2\u0839\u083a\7W\2\2\u083a"
> > )
> >
> > +
> >
> buf.write("\u083b\7G\2\2\u083b\u017e\3\2\2\2\u083c\u083d\7P\2\2\u083d
> > ")
> >
> > +
> >
> buf.write("\u083e\7Q\2\2\u083e\u083f\7G\2\2\u083f\u0840\7O\2\2\u0840")
> >
> > +
> >
> buf.write("\u0841\7R\2\2\u0841\u0842\7V\2\2\u0842\u0843\7[\2\2\u0843")
> >
> > +
> >
> buf.write("\u0180\3\2\2\2\u0844\u0845\7e\2\2\u0845\u0846\7q\2\2\u0846"
> > )
> >
> > +
> >
> buf.write("\u0847\7p\2\2\u0847\u0848\7f\2\2\u0848\u0182\3\2\2\2\u0849"
> > )
> >
> > +
> >
> buf.write("\u084a\7h\2\2\u084a\u084b\7k\2\2\u084b\u084c\7p\2\2\u084c")
> >
> > +
> >
> buf.write("\u084d\7f\2\2\u084d\u0184\3\2\2\2\u084e\u084f\7o\2\2\u084f")
> >
> > +
> >
> buf.write("\u0850\7k\2\2\u0850\u0851\7f\2\2\u0851\u0186\3\2\2\2\u0852")
> >
> > +
> >
> buf.write("\u0853\7v\2\2\u0853\u0854\7q\2\2\u0854\u0855\7m\2\2\u0855"
> > )
> >
> > +
> >
> buf.write("\u0856\7g\2\2\u0856\u0857\7p\2\2\u0857\u0188\3\2\2\2\u0858"
> > )
> >
> > +
> >
> buf.write("\u0859\7u\2\2\u0859\u085a\7r\2\2\u085a\u085b\7c\2\2\u085b")
> >
> > +
> >
> buf.write("\u085c\7p\2\2\u085c\u018a\3\2\2\2\u085d\u085e\7f\2\2\u085e")
> >
> > +
> >
> buf.write("\u085f\7w\2\2\u085f\u0860\7r\2\2\u0860\u018c\3\2\2\2\u0861")
> >
> > +
> >
> buf.write("\u0862\7x\2\2\u0862\u0863\7c\2\2\u0863\u0864\7t\2\2\u0864")
> >
> > +
> >
> buf.write("\u0865\7g\2\2\u0865\u0866\7s\2\2\u0866\u0867\7x\2\2\u0867")
> >
> > +
> >
> buf.write("\u0868\7c\2\2\u0868\u0869\7n\2\2\u0869\u018e\3\2\2\2\u086a"
> > )
> >
> > +
> >
> buf.write("\u086b\7x\2\2\u086b\u086c\7c\2\2\u086c\u086d\7t\2\2\u086d")
> >
> > +
> >
> buf.write("\u0190\3\2\2\2\u086e\u086f\7k\2\2\u086f\u0870\7f\2\2\u0870")
> >
> > +
> >
> buf.write("\u0871\7g\2\2\u0871\u0872\7s\2\2\u0872\u0873\7x\2\2\u0873")
> >
> > +
> >
> buf.write("\u0874\7c\2\2\u0874\u0875\7n\2\2\u0875\u0192\3\2\2\2\u0876"
> > )
> >
> > +
> >
> buf.write("\u0877\7k\2\2\u0877\u0878\7f\2\2\u0878\u0879\7g\2\2\u0879")
> >
> > +
> >
> buf.write("\u087a\7s\2\2\u087a\u087b\7k\2\2\u087b\u087c\7f\2\2\u087c")
> >
> > +
> >
> buf.write("\u0194\3\2\2\2\u087d\u087e\7k\2\2\u087e\u087f\7f\2\2\u087f")
> >
> > +
> >
> buf.write("\u0880\7g\2\2\u0880\u0881\7s\2\2\u0881\u0882\7x\2\2\u0882")
> >
> > +
> >
> buf.write("\u0883\7c\2\2\u0883\u0884\7n\2\2\u0884\u0885\7n\2\2\u0885")
> >
> > +
> >
> buf.write("\u0886\7k\2\2\u0886\u0887\7u\2\2\u0887\u0888\7v\2\2\u0888")
> >
> > +
> >
> buf.write("\u0196\3\2\2\2\u0889\u088a\7s\2\2\u088a\u088b\7w\2\2\u088b
> > ")
> >
> > +
> >
> buf.write("\u088c\7g\2\2\u088c\u088d\7u\2\2\u088d\u088e\7v\2\2\u088e")
> >
> > +
> >
> buf.write("\u088f\7k\2\2\u088f\u0890\7q\2\2\u0890\u0891\7p\2\2\u0891")
> >
> > +
> >
> buf.write("\u0892\7t\2\2\u0892\u0893\7g\2\2\u0893\u0894\7h\2\2\u0894")
> >
> > +
> >
> buf.write("\u0198\3\2\2\2\u0895\u0896\7t\2\2\u0896\u0897\7w\2\2\u0897"
> > )
> >
> > +
> >
> buf.write("\u0898\7n\2\2\u0898\u0899\7g\2\2\u0899\u089a\7t\2\2\u089a")
> >
> > +
> >
> buf.write("\u089b\7g\2\2\u089b\u089c\7h\2\2\u089c\u019a\3\2\2\2\u089d"
> > )
> >
> > +
> > buf.write("\u089e\7u\2\2\u089e\u089f\7v\2\2\u089f\u08a0\7t\2\2\u08a0")
> >
> > +
> >
> buf.write("\u08a1\7k\2\2\u08a1\u08a2\7p\2\2\u08a2\u08a3\7i\2\2\u08a3")
> >
> > +
> >
> buf.write("\u08a4\7t\2\2\u08a4\u08a5\7g\2\2\u08a5\u08a6\7h\2\2\u08a6")
> >
> > +
> >
> buf.write("\u019c\3\2\2\2\u08a7\u08a8\7r\2\2\u08a8\u08a9\7w\2\2\u08a9"
> > )
> >
> > +
> >
> buf.write("\u08aa\7u\2\2\u08aa\u08ab\7j\2\2\u08ab\u08ac\7v\2\2\u08ac")
> >
> > +
> > buf.write("\u08ad\7j\2\2\u08ad\u08ae\7k\2\2\u08ae\u08af\7u\2\2\u08af")
> >
> > +
> >
> buf.write("\u019e\3\2\2\2\u08b0\u08b1\7u\2\2\u08b1\u08b2\7g\2\2\u08b2
> > ")
> >
> > +
> >
> buf.write("\u08b3\7e\2\2\u08b3\u08b4\7w\2\2\u08b4\u08b5\7t\2\2\u08b5"
> > )
> >
> > +
> >
> buf.write("\u08b6\7k\2\2\u08b6\u08b7\7v\2\2\u08b7\u08b8\7{\2\2\u08b8")
> >
> > +
> >
> buf.write("\u01a0\3\2\2\2\u08b9\u08ba\7i\2\2\u08ba\u08bb\7g\2\2\u08bb"
> > )
> >
> > +
> >
> buf.write("\u08bc\7v\2\2\u08bc\u01a2\3\2\2\2\u08bd\u08be\7V\2\2\u08be"
> > )
> >
> > +
> >
> buf.write("\u08bf\7T\2\2\u08bf\u08c0\7W\2\2\u08c0\u08c1\7G\2\2\u08c1")
> >
> > +
> >
> buf.write("\u01a4\3\2\2\2\u08c2\u08c3\7H\2\2\u08c3\u08c4\7C\2\2\u08c4")
> >
> > +
> >
> buf.write("\u08c5\7N\2\2\u08c5\u08c6\7U\2\2\u08c6\u08c7\7G\2\2\u08c7")
> >
> > +
> >
> buf.write("\u01a6\3\2\2\2\u08c8\u08c9\7Q\2\2\u08c9\u08ca\7P\2\2\u08ca")
> >
> > +
> >
> buf.write("\u08cb\7G\2\2\u08cb\u01a8\3\2\2\2\u08cc\u08cd\7Q\2\2\u08cd"
> > )
> >
> > +
> >
> buf.write("\u08ce\7P\2\2\u08ce\u08cf\7G\2\2\u08cf\u08d0\7U\2\2\u08d0")
> >
> > +
> > buf.write("\u01aa\3\2\2\2\u08d1\u08d2\7\\\2\2\u08d2\u08d3\7G\2\2")
> >
> > +
> > buf.write("\u08d3\u08d4\7T\2\2\u08d4\u08d5\7Q\2\2\u08d5\u01ac\3\2")
> >
> > +
> > buf.write("\2\2\u08d6\u08d7\7W\2\2\u08d7\u08d8\7P\2\2\u08d8\u08d9")
> >
> > +
> >
> buf.write("\7F\2\2\u08d9\u08da\7G\2\2\u08da\u08db\7H\2\2\u08db\u08dc"
> > )
> >
> > +
> >
> buf.write("\7K\2\2\u08dc\u08dd\7P\2\2\u08dd\u08de\7G\2\2\u08de\u08df"
> > )
> >
> > +
> >
> buf.write("\7F\2\2\u08df\u01ae\3\2\2\2\u08e0\u08e1\7X\2\2\u08e1\u08e2")
> >
> > +
> >
> buf.write("\7G\2\2\u08e2\u08e3\7T\2\2\u08e3\u08e4\7U\2\2\u08e4\u08e5"
> > )
> >
> > +
> >
> buf.write("\7K\2\2\u08e5\u08e6\7Q\2\2\u08e6\u08e7\7P\2\2\u08e7\u01b0"
> > )
> >
> > +
> >
> buf.write("\3\2\2\2\u08e8\u08e9\7n\2\2\u08e9\u08ea\7g\2\2\u08ea\u08eb"
> > )
> >
> > +
> >
> buf.write("\7p\2\2\u08eb\u08ec\7i\2\2\u08ec\u08ed\7v\2\2\u08ed\u08ee")
> >
> > +
> > buf.write("\7j\2\2\u08ee\u01b2\3\2\2\2\u08ef\u08f0\7C\2\2\u08f0\u08f1")
> >
> > +
> > buf.write("\7P\2\2\u08f1\u08f2\7F\2\2\u08f2\u01b4\3\2\2\2\u08f3\u08f4")
> >
> > +
> >
> buf.write("\7Q\2\2\u08f4\u08f5\7T\2\2\u08f5\u01b6\3\2\2\2\u08f6\u08f7")
> >
> > +
> > buf.write("\7P\2\2\u08f7\u08f8\7Q\2\2\u08f8\u08f9\7V\2\2\u08f9\u01b8")
> >
> > +
> > buf.write("\3\2\2\2\u08fa\u08fb\7u\2\2\u08fb\u08fc\7g\2\2\u08fc\u08fd")
> >
> > +
> > buf.write("\7v\2\2\u08fd\u01ba\3\2\2\2\u08fe\u08ff\7\u0080\2\2\u08ff")
> >
> > +
> >
> buf.write("\u01bc\3\2\2\2\u0900\u0901\7d\2\2\u0901\u0902\7q\2\2\u0902"
> > )
> >
> > +
> >
> buf.write("\u0903\7q\2\2\u0903\u0904\7n\2\2\u0904\u0905\7x\2\2\u0905")
> >
> > +
> >
> buf.write("\u0906\7c\2\2\u0906\u0907\7n\2\2\u0907\u01be\3\2\2\2\u0908"
> > )
> >
> > +
> >
> buf.write("\u0909\7u\2\2\u0909\u090a\7v\2\2\u090a\u090b\7t\2\2\u090b")
> >
> > +
> >
> buf.write("\u090c\7k\2\2\u090c\u090d\7p\2\2\u090d\u090e\7i\2\2\u090e")
> >
> > +
> >
> buf.write("\u090f\7x\2\2\u090f\u0910\7c\2\2\u0910\u0911\7n\2\2\u0911")
> >
> > +
> >
> buf.write("\u01c0\3\2\2\2\u0912\u0913\7w\2\2\u0913\u0914\7p\2\2\u0914
> > ")
> >
> > +
> >
> buf.write("\u0915\7k\2\2\u0915\u0916\7p\2\2\u0916\u0917\7v\2\2\u0917")
> >
> > +
> >
> buf.write("\u0918\7x\2\2\u0918\u0919\7c\2\2\u0919\u091a\7n\2\2\u091a")
> >
> > +
> >
> buf.write("\u01c2\3\2\2\2\u091b\u091c\7v\2\2\u091c\u091d\7q\2\2\u091d"
> > )
> >
> > +
> >
> buf.write("\u091e\7w\2\2\u091e\u091f\7r\2\2\u091f\u0920\7r\2\2\u0920")
> >
> > +
> >
> buf.write("\u0921\7g\2\2\u0921\u0922\7t\2\2\u0922\u01c4\3\2\2\2\u0923")
> >
> > +
> >
> buf.write("\u0924\7v\2\2\u0924\u0925\7q\2\2\u0925\u0926\7n\2\2\u0926")
> >
> > +
> >
> buf.write("\u0927\7q\2\2\u0927\u0928\7y\2\2\u0928\u0929\7g\2\2\u0929")
> >
> > +
> >
> buf.write("\u092a\7t\2\2\u092a\u01c6\3\2\2\2\u092b\u092c\7o\2\2\u092c")
> >
> > +
> >
> buf.write("\u092d\7c\2\2\u092d\u092e\7v\2\2\u092e\u092f\7e\2\2\u092f")
> >
> > +
> >
> buf.write("\u0930\7j\2\2\u0930\u01c8\3\2\2\2\u0931\u0932\7o\2\2\u0932")
> >
> > +
> >
> buf.write("\u0933\7c\2\2\u0933\u0934\7v\2\2\u0934\u0935\7e\2\2\u0935")
> >
> > +
> > buf.write("\u0936\7j\2\2\u0936\u0937\7\64\2\2\u0937\u01ca\3\2\2\2")
> >
> > +
> > buf.write("\u0938\u0939\7e\2\2\u0939\u093a\7c\2\2\u093a\u093b\7v")
> >
> > +
> > buf.write("\2\2\u093b\u093c\7g\2\2\u093c\u093d\7p\2\2\u093d\u093e")
> >
> > +
> > buf.write("\7c\2\2\u093e\u093f\7v\2\2\u093f\u0940\7g\2\2\u0940\u01cc")
> >
> > +
> >
> buf.write("\3\2\2\2\u0941\u0942\7s\2\2\u0942\u0943\7w\2\2\u0943\u0944"
> > )
> >
> > +
> >
> buf.write("\7g\2\2\u0944\u0945\7u\2\2\u0945\u0946\7v\2\2\u0946\u0947")
> >
> > +
> >
> buf.write("\7k\2\2\u0947\u0948\7q\2\2\u0948\u0949\7p\2\2\u0949\u094a")
> >
> > +
> >
> buf.write("\7t\2\2\u094a\u094b\7g\2\2\u094b\u094c\7h\2\2\u094c\u094d")
> >
> > +
> >
> buf.write("\7x\2\2\u094d\u094e\7c\2\2\u094e\u094f\7n\2\2\u094f\u01ce")
> >
> > +
> >
> buf.write("\3\2\2\2\u0950\u0951\7u\2\2\u0951\u0952\7v\2\2\u0952\u0953"
> > )
> >
> > +
> >
> buf.write("\7t\2\2\u0953\u0954\7k\2\2\u0954\u0955\7p\2\2\u0955\u0956")
> >
> > +
> >
> buf.write("\7i\2\2\u0956\u0957\7t\2\2\u0957\u0958\7g\2\2\u0958\u0959")
> >
> > +
> >
> buf.write("\7h\2\2\u0959\u095a\7x\2\2\u095a\u095b\7c\2\2\u095b\u095c")
> >
> > +
> >
> buf.write("\7n\2\2\u095c\u01d0\3\2\2\2\u095d\u095e\7o\2\2\u095e\u095f"
> > )
> >
> > +
> >
> buf.write("\7c\2\2\u095f\u0960\7r\2\2\u0960\u01d2\3\2\2\2\u0961\u0962")
> >
> > +
> >
> buf.write("\7t\2\2\u0962\u0963\7g\2\2\u0963\u0964\7h\2\2\u0964\u0965")
> >
> > +
> >
> buf.write("\7t\2\2\u0965\u0966\7g\2\2\u0966\u0967\7u\2\2\u0967\u0968")
> >
> > +
> >
> buf.write("\7j\2\2\u0968\u0969\7i\2\2\u0969\u096a\7w\2\2\u096a\u096b")
> >
> > +
> >
> buf.write("\7k\2\2\u096b\u096c\7f\2\2\u096c\u01d4\3\2\2\2\u096d\u096e")
> >
> > +
> >
> buf.write("\7U\2\2\u096e\u096f\7V\2\2\u096f\u0970\7T\2\2\u0970\u0971")
> >
> > +
> >
> buf.write("\7K\2\2\u0971\u0972\7P\2\2\u0972\u0973\7I\2\2\u0973\u0974")
> >
> > +
> >
> buf.write("\7a\2\2\u0974\u0975\7V\2\2\u0975\u0976\7Q\2\2\u0976\u0977"
> > )
> >
> > +
> >
> buf.write("\7M\2\2\u0977\u0978\7G\2\2\u0978\u0979\7P\2\2\u0979\u01d6
> > ")
> >
> > +
> >
> buf.write("\3\2\2\2\u097a\u097b\7Q\2\2\u097b\u097c\7R\2\2\u097c\u097d
> > ")
> >
> > +
> >
> buf.write("\7V\2\2\u097d\u097e\7K\2\2\u097e\u097f\7Q\2\2\u097f\u0980")
> >
> > +
> >
> buf.write("\7P\2\2\u0980\u0981\7a\2\2\u0981\u0982\7F\2\2\u0982\u0983")
> >
> > +
> >
> buf.write("\7G\2\2\u0983\u0984\7H\2\2\u0984\u0985\7C\2\2\u0985\u0986"
> > )
> >
> > +
> >
> buf.write("\7W\2\2\u0986\u0987\7N\2\2\u0987\u0988\7V\2\2\u0988\u01d8
> > ")
> >
> > +
> >
> buf.write("\3\2\2\2\u0989\u098a\7Q\2\2\u098a\u098b\7R\2\2\u098b\u098c
> > ")
> >
> > +
> >
> buf.write("\7V\2\2\u098c\u098d\7K\2\2\u098d\u098e\7Q\2\2\u098e\u098f")
> >
> > +
> >
> buf.write("\7P\2\2\u098f\u0990\7a\2\2\u0990\u0991\7F\2\2\u0991\u0992")
> >
> > +
> >
> buf.write("\7G\2\2\u0992\u0993\7H\2\2\u0993\u0994\7C\2\2\u0994\u0995"
> > )
> >
> > +
> >
> buf.write("\7W\2\2\u0995\u0996\7N\2\2\u0996\u0997\7V\2\2\u0997\u0998
> > ")
> >
> > +
> >
> buf.write("\7a\2\2\u0998\u0999\7O\2\2\u0999\u099a\7H\2\2\u099a\u099b"
> > )
> >
> > +
> >
> buf.write("\7I\2\2\u099b\u01da\3\2\2\2\u099c\u099d\7P\2\2\u099d\u099e"
> > )
> >
> > +
> >
> buf.write("\7W\2\2\u099e\u099f\7O\2\2\u099f\u09a0\7G\2\2\u09a0\u09a1"
> > )
> >
> > +
> >
> buf.write("\7T\2\2\u09a1\u09a2\7K\2\2\u09a2\u09a3\7E\2\2\u09a3\u09a4")
> >
> > +
> >
> buf.write("\7a\2\2\u09a4\u09a5\7U\2\2\u09a5\u09a6\7K\2\2\u09a6\u09a7")
> >
> > +
> >
> buf.write("\7\\\2\2\u09a7\u09a8\7G\2\2\u09a8\u09a9\7a\2\2\u09a9\u09aa"
> > )
> >
> > +
> > buf.write("\7\63\2\2\u09aa\u01dc\3\2\2\2\u09ab\u09ac\7P\2\2\u09ac")
> >
> > +
> >
> buf.write("\u09ad\7W\2\2\u09ad\u09ae\7O\2\2\u09ae\u09af\7G\2\2\u09af"
> > )
> >
> > +
> >
> buf.write("\u09b0\7T\2\2\u09b0\u09b1\7K\2\2\u09b1\u09b2\7E\2\2\u09b2"
> > )
> >
> > +
> >
> buf.write("\u09b3\7a\2\2\u09b3\u09b4\7U\2\2\u09b4\u09b5\7K\2\2\u09b5"
> > )
> >
> > +
> >
> buf.write("\u09b6\7\\\2\2\u09b6\u09b7\7G\2\2\u09b7\u09b8\7a\2\2\u09b8
> > ")
> >
> > +
> > buf.write("\u09b9\7\64\2\2\u09b9\u01de\3\2\2\2\u09ba\u09bb\7P\2\2")
> >
> > +
> > buf.write("\u09bb\u09bc\7W\2\2\u09bc\u09bd\7O\2\2\u09bd\u09be\7G")
> >
> > +
> > buf.write("\2\2\u09be\u09bf\7T\2\2\u09bf\u09c0\7K\2\2\u09c0\u09c1")
> >
> > +
> >
> buf.write("\7E\2\2\u09c1\u09c2\7a\2\2\u09c2\u09c3\7U\2\2\u09c3\u09c4")
> >
> > +
> >
> buf.write("\7K\2\2\u09c4\u09c5\7\\\2\2\u09c5\u09c6\7G\2\2\u09c6\u09c7")
> >
> > +
> > buf.write("\7a\2\2\u09c7\u09c8\7\66\2\2\u09c8\u01e0\3\2\2\2\u09c9")
> >
> > +
> >
> buf.write("\u09ca\7P\2\2\u09ca\u09cb\7W\2\2\u09cb\u09cc\7O\2\2\u09cc")
> >
> > +
> > buf.write("\u09cd\7G\2\2\u09cd\u09ce\7T\2\2\u09ce\u09cf\7K\2\2\u09cf")
> >
> > +
> >
> buf.write("\u09d0\7E\2\2\u09d0\u09d1\7a\2\2\u09d1\u09d2\7U\2\2\u09d2"
> > )
> >
> > +
> >
> buf.write("\u09d3\7K\2\2\u09d3\u09d4\7\\\2\2\u09d4\u09d5\7G\2\2\u09d5
> > ")
> >
> > +
> >
> buf.write("\u09d6\7a\2\2\u09d6\u09d7\7:\2\2\u09d7\u01e2\3\2\2\2\u09d8"
> > )
> >
> > +
> >
> buf.write("\u09d9\7F\2\2\u09d9\u09da\7K\2\2\u09da\u09db\7U\2\2\u09db"
> > )
> >
> > +
> >
> buf.write("\u09dc\7R\2\2\u09dc\u09dd\7N\2\2\u09dd\u09de\7C\2\2\u09de"
> > )
> >
> > +
> >
> buf.write("\u09df\7[\2\2\u09df\u09e0\7a\2\2\u09e0\u09e1\7K\2\2\u09e1")
> >
> > +
> >
> buf.write("\u09e2\7P\2\2\u09e2\u09e3\7V\2\2\u09e3\u09e4\7a\2\2\u09e4")
> >
> > +
> >
> buf.write("\u09e5\7F\2\2\u09e5\u09e6\7G\2\2\u09e6\u09e7\7E\2\2\u09e7")
> >
> > +
> >
> buf.write("\u01e4\3\2\2\2\u09e8\u09e9\7F\2\2\u09e9\u09ea\7K\2\2\u09ea"
> > )
> >
> > +
> >
> buf.write("\u09eb\7U\2\2\u09eb\u09ec\7R\2\2\u09ec\u09ed\7N\2\2\u09ed"
> > )
> >
> > +
> > buf.write("\u09ee\7C\2\2\u09ee\u09ef\7[\2\2\u09ef\u09f0\7a\2\2\u09f0")
> >
> > +
> > buf.write("\u09f1\7W\2\2\u09f1\u09f2\7K\2\2\u09f2\u09f3\7P\2\2\u09f3")
> >
> > +
> > buf.write("\u09f4\7V\2\2\u09f4\u09f5\7a\2\2\u09f5\u09f6\7F\2\2\u09f6")
> >
> > +
> >
> buf.write("\u09f7\7G\2\2\u09f7\u09f8\7E\2\2\u09f8\u01e6\3\2\2\2\u09f9")
> >
> > +
> > buf.write("\u09fa\7F\2\2\u09fa\u09fb\7K\2\2\u09fb\u09fc\7U\2\2\u09fc")
> >
> > +
> > buf.write("\u09fd\7R\2\2\u09fd\u09fe\7N\2\2\u09fe\u09ff\7C\2\2\u09ff")
> >
> > +
> >
> buf.write("\u0a00\7[\2\2\u0a00\u0a01\7a\2\2\u0a01\u0a02\7W\2\2\u0a02"
> > )
> >
> > +
> >
> buf.write("\u0a03\7K\2\2\u0a03\u0a04\7P\2\2\u0a04\u0a05\7V\2\2\u0a05")
> >
> > +
> >
> buf.write("\u0a06\7a\2\2\u0a06\u0a07\7J\2\2\u0a07\u0a08\7G\2\2\u0a08")
> >
> > +
> >
> buf.write("\u0a09\7Z\2\2\u0a09\u01e8\3\2\2\2\u0a0a\u0a0b\7K\2\2\u0a0b"
> > )
> >
> > +
> >
> buf.write("\u0a0c\7P\2\2\u0a0c\u0a0d\7U\2\2\u0a0d\u0a0e\7G\2\2\u0a0e")
> >
> > +
> >
> buf.write("\u0a0f\7P\2\2\u0a0f\u0a10\7U\2\2\u0a10\u0a11\7K\2\2\u0a11")
> >
> > +
> >
> buf.write("\u0a12\7V\2\2\u0a12\u0a13\7K\2\2\u0a13\u0a14\7X\2\2\u0a14")
> >
> > +
> >
> buf.write("\u0a15\7G\2\2\u0a15\u01ea\3\2\2\2\u0a16\u0a17\7U\2\2\u0a17
> > ")
> >
> > +
> >
> buf.write("\u0a18\7G\2\2\u0a18\u0a19\7P\2\2\u0a19\u0a1a\7U\2\2\u0a1a"
> > )
> >
> > +
> >
> buf.write("\u0a1b\7K\2\2\u0a1b\u0a1c\7V\2\2\u0a1c\u0a1d\7K\2\2\u0a1d")
> >
> > +
> >
> buf.write("\u0a1e\7X\2\2\u0a1e\u0a1f\7G\2\2\u0a1f\u01ec\3\2\2\2\u0a20")
> >
> > +
> >
> buf.write("\u0a21\7N\2\2\u0a21\u0a22\7C\2\2\u0a22\u0a23\7U\2\2\u0a23"
> > )
> >
> > +
> >
> buf.write("\u0a24\7V\2\2\u0a24\u0a25\7a\2\2\u0a25\u0a26\7P\2\2\u0a26")
> >
> > +
> >
> buf.write("\u0a27\7Q\2\2\u0a27\u0a28\7P\2\2\u0a28\u0a29\7a\2\2\u0a29")
> >
> > +
> >
> buf.write("\u0a2a\7O\2\2\u0a2a\u0a2b\7C\2\2\u0a2b\u0a2c\7V\2\2\u0a2c")
> >
> > +
> >
> buf.write("\u0a2d\7E\2\2\u0a2d\u0a2e\7J\2\2\u0a2e\u01ee\3\2\2\2\u0a2f")
> >
> > +
> >
> buf.write("\u0a30\7H\2\2\u0a30\u0a31\7K\2\2\u0a31\u0a32\7T\2\2\u0a32")
> >
> > +
> >
> buf.write("\u0a33\7U\2\2\u0a33\u0a34\7V\2\2\u0a34\u0a35\7a\2\2\u0a35")
> >
> > +
> >
> buf.write("\u0a36\7P\2\2\u0a36\u0a37\7Q\2\2\u0a37\u0a38\7P\2\2\u0a38")
> >
> > +
> >
> buf.write("\u0a39\7a\2\2\u0a39\u0a3a\7O\2\2\u0a3a\u0a3b\7C\2\2\u0a3b"
> > )
> >
> > +
> >
> buf.write("\u0a3c\7V\2\2\u0a3c\u0a3d\7E\2\2\u0a3d\u0a3e\7J\2\2\u0a3e")
> >
> > +
> buf.write("\u01f0\3\2\2\2\u0a3f\u0a40\7\62\2\2\u0a40\u0a41\7z\2\2")
> >
> > +
> > buf.write("\u0a41\u0a43\3\2\2\2\u0a42\u0a44\t\2\2\2\u0a43\u0a42\3")
> >
> > +
> >
> buf.write("\2\2\2\u0a44\u0a45\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46"
> > )
> >
> > +
> > buf.write("\3\2\2\2\u0a46\u0a4d\3\2\2\2\u0a47\u0a49\t\3\2\2\u0a48")
> >
> > +
> > buf.write("\u0a47\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a48\3\2\2\2")
> >
> > +
> > buf.write("\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4d\3\2\2\2\u0a4c\u0a3f\3")
> >
> > +
> >
> buf.write("\2\2\2\u0a4c\u0a48\3\2\2\2\u0a4d\u01f2\3\2\2\2\u0a4e\u0a52")
> >
> > +
> buf.write("\t\4\2\2\u0a4f\u0a51\t\5\2\2\u0a50\u0a4f\3\2\2\2\u0a51")
> >
> > +
> > buf.write("\u0a54\3\2\2\2\u0a52\u0a50\3\2\2\2\u0a52\u0a53\3\2\2\2")
> >
> > +
> > buf.write("\u0a53\u01f4\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a55\u0a57\7")
> >
> > +
> > buf.write("%\2\2\u0a56\u0a58\5\u01fb\u00fe\2\u0a57\u0a56\3\2\2\2")
> >
> > +
> > buf.write("\u0a57\u0a58\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\7")
> >
> > +
> > buf.write("f\2\2\u0a5a\u0a5b\7g\2\2\u0a5b\u0a5c\7h\2\2\u0a5c\u0a5d")
> >
> > +
> >
> buf.write("\7k\2\2\u0a5d\u0a5e\7p\2\2\u0a5e\u0a5f\7g\2\2\u0a5f\u0a63")
> >
> > +
> > buf.write("\3\2\2\2\u0a60\u0a62\n\6\2\2\u0a61\u0a60\3\2\2\2\u0a62")
> >
> > +
> > buf.write("\u0a65\3\2\2\2\u0a63\u0a61\3\2\2\2\u0a63\u0a64\3\2\2\2")
> >
> > +
> > buf.write("\u0a64\u0a66\3\2\2\2\u0a65\u0a63\3\2\2\2\u0a66\u0a67\b")
> >
> > +
> > buf.write("\u00fb\2\2\u0a67\u01f6\3\2\2\2\u0a68\u0a6a\7%\2\2\u0a69")
> >
> > +
> > buf.write("\u0a6b\5\u01fb\u00fe\2\u0a6a\u0a69\3\2\2\2\u0a6a\u0a6b")
> >
> > +
> buf.write("\3\2\2\2\u0a6b\u0a6c\3\2\2\2\u0a6c\u0a6d\7n\2\2\u0a6d")
> >
> > +
> >
> buf.write("\u0a6e\7k\2\2\u0a6e\u0a6f\7p\2\2\u0a6f\u0a70\7g\2\2\u0a70")
> >
> > +
> > buf.write("\u0a74\3\2\2\2\u0a71\u0a73\n\6\2\2\u0a72\u0a71\3\2\2\2")
> >
> > +
> > buf.write("\u0a73\u0a76\3\2\2\2\u0a74\u0a72\3\2\2\2\u0a74\u0a75\3")
> >
> > +
> >
> buf.write("\2\2\2\u0a75\u0a77\3\2\2\2\u0a76\u0a74\3\2\2\2\u0a77\u0a78"
> > )
> >
> > +
> >
> buf.write("\b\u00fc\2\2\u0a78\u01f8\3\2\2\2\u0a79\u0a7b\7%\2\2\u0a7a")
> >
> > +
> > buf.write("\u0a7c\5\u01fb\u00fe\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c")
> >
> > +
> buf.write("\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7e\7k\2\2\u0a7e")
> >
> > +
> >
> buf.write("\u0a7f\7p\2\2\u0a7f\u0a80\7e\2\2\u0a80\u0a81\7n\2\2\u0a81")
> >
> > +
> >
> buf.write("\u0a82\7w\2\2\u0a82\u0a83\7f\2\2\u0a83\u0a84\7g\2\2\u0a84")
> >
> > +
> > buf.write("\u0a88\3\2\2\2\u0a85\u0a87\n\6\2\2\u0a86\u0a85\3\2\2\2")
> >
> > +
> > buf.write("\u0a87\u0a8a\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a88\u0a89\3")
> >
> > +
> >
> buf.write("\2\2\2\u0a89\u0a8b\3\2\2\2\u0a8a\u0a88\3\2\2\2\u0a8b\u0a8c"
> > )
> >
> > +
> > buf.write("\b\u00fd\2\2\u0a8c\u01fa\3\2\2\2\u0a8d\u0a8f\t\7\2\2\u0a8e")
> >
> > +
> > buf.write("\u0a8d\3\2\2\2\u0a8f\u0a90\3\2\2\2\u0a90\u0a8e\3\2\2\2")
> >
> > +
> > buf.write("\u0a90\u0a91\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a93\b")
> >
> > +
> > buf.write("\u00fe\2\2\u0a93\u01fc\3\2\2\2\u0a94\u0a96\7\17\2\2\u0a95")
> >
> > +
> > buf.write("\u0a97\7\f\2\2\u0a96\u0a95\3\2\2\2\u0a96\u0a97\3\2\2\2")
> >
> > +
> > buf.write("\u0a97\u0a9a\3\2\2\2\u0a98\u0a9a\7\f\2\2\u0a99\u0a94\3")
> >
> > +
> >
> buf.write("\2\2\2\u0a99\u0a98\3\2\2\2\u0a9a\u0a9b\3\2\2\2\u0a9b\u0a9c"
> > )
> >
> > +
> buf.write("\b\u00ff\2\2\u0a9c\u01fe\3\2\2\2\u0a9d\u0a9e\7\61\2\2")
> >
> > +
> buf.write("\u0a9e\u0a9f\7\61\2\2\u0a9f\u0aa3\3\2\2\2\u0aa0\u0aa2")
> >
> > +
> > buf.write("\n\b\2\2\u0aa1\u0aa0\3\2\2\2\u0aa2\u0aa5\3\2\2\2\u0aa3")
> >
> > +
> > buf.write("\u0aa1\3\2\2\2\u0aa3\u0aa4\3\2\2\2\u0aa4\u0aa6\3\2\2\2")
> >
> > +
> >
> buf.write("\u0aa5\u0aa3\3\2\2\2\u0aa6\u0aa7\b\u0100\2\2\u0aa7\u0200")
> >
> > +
> >
> buf.write("\3\2\2\2\u0aa8\u0aa9\7g\2\2\u0aa9\u0aaa\7z\2\2\u0aaa\u0aab"
> > )
> >
> > +
> >
> buf.write("\7v\2\2\u0aab\u0aac\7g\2\2\u0aac\u0aad\7t\2\2\u0aad\u0aae")
> >
> > +
> buf.write("\7p\2\2\u0aae\u0ab2\3\2\2\2\u0aaf\u0ab1\n\6\2\2\u0ab0")
> >
> > +
> > buf.write("\u0aaf\3\2\2\2\u0ab1\u0ab4\3\2\2\2\u0ab2\u0ab0\3\2\2\2")
> >
> > +
> > buf.write("\u0ab2\u0ab3\3\2\2\2\u0ab3\u0ab5\3\2\2\2\u0ab4\u0ab2\3")
> >
> > +
> > buf.write("\2\2\2\u0ab5\u0ab6\b\u0101\2\2\u0ab6\u0202\3\2\2\2\22")
> >
> > +
> >
> buf.write("\2\u0a45\u0a4a\u0a4c\u0a52\u0a57\u0a63\u0a6a\u0a74\u0a7b"
> > )
> >
> > + buf.write("\u0a88\u0a90\u0a96\u0a99\u0aa3\u0ab2\3\b\2\2")
> >
> > + return buf.getvalue()
> >
> > +
> >
> > +
> >
> > +class VfrSyntaxLexer(Lexer):
> >
> > +
> >
> > + atn = ATNDeserializer().deserialize(serializedATN())
> >
> > +
> >
> > + decisionsToDFA = [ DFA(ds, i) for i, ds in
> enumerate(atn.decisionToState) ]
> >
> > +
> >
> > + T__0 = 1
> >
> > + T__1 = 2
> >
> > + T__2 = 3
> >
> > + T__3 = 4
> >
> > + T__4 = 5
> >
> > + T__5 = 6
> >
> > + T__6 = 7
> >
> > + T__7 = 8
> >
> > + T__8 = 9
> >
> > + T__9 = 10
> >
> > + T__10 = 11
> >
> > + T__11 = 12
> >
> > + T__12 = 13
> >
> > + T__13 = 14
> >
> > + T__14 = 15
> >
> > + T__15 = 16
> >
> > + Define = 17
> >
> > + Include = 18
> >
> > + FormPkgType = 19
> >
> > + OpenBrace = 20
> >
> > + CloseBrace = 21
> >
> > + OpenParen = 22
> >
> > + CloseParen = 23
> >
> > + OpenBracket = 24
> >
> > + CloseBracket = 25
> >
> > + Dot = 26
> >
> > + Negative = 27
> >
> > + Colon = 28
> >
> > + Slash = 29
> >
> > + Semicolon = 30
> >
> > + Comma = 31
> >
> > + Equal = 32
> >
> > + NotEqual = 33
> >
> > + LessEqual = 34
> >
> > + Less = 35
> >
> > + GreaterEqual = 36
> >
> > + Greater = 37
> >
> > + BitWiseOr = 38
> >
> > + BitWiseAnd = 39
> >
> > + DevicePath = 40
> >
> > + FormSet = 41
> >
> > + FormSetId = 42
> >
> > + EndFormSet = 43
> >
> > + Title = 44
> >
> > + FormId = 45
> >
> > + OneOf = 46
> >
> > + EndOneOf = 47
> >
> > + Prompt = 48
> >
> > + OrderedList = 49
> >
> > + MaxContainers = 50
> >
> > + EndList = 51
> >
> > + EndForm = 52
> >
> > + Form = 53
> >
> > + FormMap = 54
> >
> > + MapTitle = 55
> >
> > + MapGuid = 56
> >
> > + Subtitle = 57
> >
> > + EndSubtitle = 58
> >
> > + Help = 59
> >
> > + Text = 60
> >
> > + Option = 61
> >
> > + FLAGS = 62
> >
> > + Date = 63
> >
> > + EndDate = 64
> >
> > + Year = 65
> >
> > + Month = 66
> >
> > + Day = 67
> >
> > + Time = 68
> >
> > + EndTime = 69
> >
> > + Hour = 70
> >
> > + Minute = 71
> >
> > + Second = 72
> >
> > + GrayOutIf = 73
> >
> > + Label = 74
> >
> > + Timeout = 75
> >
> > + Inventory = 76
> >
> > + NonNvDataMap = 77
> >
> > + Struct = 78
> >
> > + Union = 79
> >
> > + Boolean = 80
> >
> > + Uint64 = 81
> >
> > + Uint32 = 82
> >
> > + Uint16 = 83
> >
> > + Uint8 = 84
> >
> > + EFI_STRING_ID = 85
> >
> > + EFI_HII_DATE = 86
> >
> > + EFI_HII_TIME = 87
> >
> > + EFI_HII_REF = 88
> >
> > + Uuid = 89
> >
> > + CheckBox = 90
> >
> > + EndCheckBox = 91
> >
> > + Numeric = 92
> >
> > + EndNumeric = 93
> >
> > + Minimum = 94
> >
> > + Maximum = 95
> >
> > + Step = 96
> >
> > + Default = 97
> >
> > + Password = 98
> >
> > + EndPassword = 99
> >
> > + String = 100
> >
> > + EndString = 101
> >
> > + MinSize = 102
> >
> > + MaxSize = 103
> >
> > + Encoding = 104
> >
> > + SuppressIf = 105
> >
> > + DisableIf = 106
> >
> > + Hidden = 107
> >
> > + Goto = 108
> >
> > + FormSetGuid = 109
> >
> > + InconsistentIf = 110
> >
> > + WarningIf = 111
> >
> > + NoSubmitIf = 112
> >
> > + EndIf = 113
> >
> > + Key = 114
> >
> > + DefaultFlag = 115
> >
> > + ManufacturingFlag = 116
> >
> > + CheckBoxDefaultFlag = 117
> >
> > + CheckBoxDefaultMfgFlag = 118
> >
> > + InteractiveFlag = 119
> >
> > + NVAccessFlag = 120
> >
> > + ResetRequiredFlag = 121
> >
> > + ReconnectRequiredFlag = 122
> >
> > + LateCheckFlag = 123
> >
> > + ReadOnlyFlag = 124
> >
> > + OptionOnlyFlag = 125
> >
> > + RestStyleFlag = 126
> >
> > + Class = 127
> >
> > + Subclass = 128
> >
> > + ClassGuid = 129
> >
> > + TypeDef = 130
> >
> > + Restore = 131
> >
> > + Save = 132
> >
> > + Defaults = 133
> >
> > + Banner = 134
> >
> > + Align = 135
> >
> > + Left = 136
> >
> > + Right = 137
> >
> > + Center = 138
> >
> > + Line = 139
> >
> > + Name = 140
> >
> > + VarId = 141
> >
> > + Question = 142
> >
> > + QuestionId = 143
> >
> > + Image = 144
> >
> > + Locked = 145
> >
> > + Rule = 146
> >
> > + EndRule = 147
> >
> > + Value = 148
> >
> > + Read = 149
> >
> > + Write = 150
> >
> > + ResetButton = 151
> >
> > + EndResetButton = 152
> >
> > + DefaultStore = 153
> >
> > + Attribute = 154
> >
> > + Varstore = 155
> >
> > + Efivarstore = 156
> >
> > + VarSize = 157
> >
> > + NameValueVarStore = 158
> >
> > + Action = 159
> >
> > + Config = 160
> >
> > + EndAction = 161
> >
> > + Refresh = 162
> >
> > + Interval = 163
> >
> > + VarstoreDevice = 164
> >
> > + GuidOp = 165
> >
> > + EndGuidOp = 166
> >
> > + DataType = 167
> >
> > + Data = 168
> >
> > + Modal = 169
> >
> > + ClassNonDevice = 170
> >
> > + ClassDiskDevice = 171
> >
> > + ClassVideoDevice = 172
> >
> > + ClassNetworkDevice = 173
> >
> > + ClassInputDevice = 174
> >
> > + ClassOnBoardDevice = 175
> >
> > + ClassOtherDevice = 176
> >
> > + SubclassSetupApplication = 177
> >
> > + SubclassGeneralApplication = 178
> >
> > + SubclassFrontPage = 179
> >
> > + SubclassSingleUse = 180
> >
> > + YearSupppressFlag = 181
> >
> > + MonthSuppressFlag = 182
> >
> > + DaySuppressFlag = 183
> >
> > + HourSupppressFlag = 184
> >
> > + MinuteSuppressFlag = 185
> >
> > + SecondSuppressFlag = 186
> >
> > + StorageNormalFlag = 187
> >
> > + StorageTimeFlag = 188
> >
> > + StorageWakeUpFlag = 189
> >
> > + UniQueFlag = 190
> >
> > + NoEmptyFlag = 191
> >
> > + Cond = 192
> >
> > + Find = 193
> >
> > + Mid = 194
> >
> > + Tok = 195
> >
> > + Span = 196
> >
> > + Dup = 197
> >
> > + VarEqVal = 198
> >
> > + Var = 199
> >
> > + IdEqVal = 200
> >
> > + IdEqId = 201
> >
> > + IdEqValList = 202
> >
> > + QuestionRef = 203
> >
> > + RuleRef = 204
> >
> > + StringRef = 205
> >
> > + PushThis = 206
> >
> > + Security = 207
> >
> > + Get = 208
> >
> > + TrueSymbol = 209
> >
> > + FalseSymbol = 210
> >
> > + One = 211
> >
> > + Ones = 212
> >
> > + Zero = 213
> >
> > + Undefined = 214
> >
> > + Version = 215
> >
> > + Length = 216
> >
> > + AND = 217
> >
> > + OR = 218
> >
> > + NOT = 219
> >
> > + Set = 220
> >
> > + BitWiseNot = 221
> >
> > + BoolVal = 222
> >
> > + StringVal = 223
> >
> > + UnIntVal = 224
> >
> > + ToUpper = 225
> >
> > + ToLower = 226
> >
> > + Match = 227
> >
> > + Match2 = 228
> >
> > + Catenate = 229
> >
> > + QuestionRefVal = 230
> >
> > + StringRefVal = 231
> >
> > + Map = 232
> >
> > + RefreshGuid = 233
> >
> > + StringToken = 234
> >
> > + OptionDefault = 235
> >
> > + OptionDefaultMfg = 236
> >
> > + NumericSizeOne = 237
> >
> > + NumericSizeTwo = 238
> >
> > + NumericSizeFour = 239
> >
> > + NumericSizeEight = 240
> >
> > + DisPlayIntDec = 241
> >
> > + DisPlayUIntDec = 242
> >
> > + DisPlayUIntHex = 243
> >
> > + Insensitive = 244
> >
> > + Sensitive = 245
> >
> > + LastNonMatch = 246
> >
> > + FirstNonMatch = 247
> >
> > + Number = 248
> >
> > + StringIdentifier = 249
> >
> > + ComplexDefine = 250
> >
> > + LineDefinition = 251
> >
> > + IncludeDefinition = 252
> >
> > + Whitespace = 253
> >
> > + Newline = 254
> >
> > + LineComment = 255
> >
> > + Extern = 256
> >
> > +
> >
> > + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
> >
> > +
> >
> > + modeNames = [ "DEFAULT_MODE" ]
> >
> > +
> >
> > + literalNames = [ "<INVALID>",
> >
> > + "'show'", "'push'", "'pop'", "'#pragma'", "'pack'", "'='",
> > "'IMAGE_TOKEN'",
> >
> > + "'HORIZONTAL'", "'MULTI_LINE'", "'<<'", "'>>'", "'+'", "'*'",
> >
> > + "'%'", "'format'", "'?'", "'#define'", "'#include'", "'formpkgtype'",
> >
> > + "'{'", "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
> >
> > + "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'", "'>='",
> >
> > + "'>'", "'|'", "'&'", "'devicepath'", "'formset'", "'formsetid'",
> >
> > + "'endformset'", "'title'", "'formid'", "'oneof'", "'endoneof'",
> >
> > + "'prompt'", "'orderedlist'", "'maxcontainers'", "'endlist'",
> >
> > + "'endform'", "'form'", "'formmap'", "'maptitle'", "'mapguid'",
> >
> > + "'subtitle'", "'endsubtitle'", "'help'", "'text'", "'option'",
> >
> > + "'flags'", "'date'", "'enddate'", "'year'", "'month'", "'day'",
> >
> > + "'time'", "'endtime'", "'hour'", "'minute'", "'second'", "'grayoutif'",
> >
> > + "'label'", "'timeout'", "'inventory'", "'_NON_NV_DATA_MAP'",
> >
> > + "'struct'", "'union'", "'BOOLEAN'", "'UINT64'", "'UINT32'",
> >
> > + "'UINT16'", "'UINT8'", "'EFI_STRING_ID'", "'EFI_HII_DATE'",
> >
> > + "'EFI_HII_TIME'", "'EFI_HII_REF'", "'guid'", "'checkbox'",
> > "'endcheckbox'",
> >
> > + "'numeric'", "'endnumeric'", "'minimum'", "'maximum'", "'step'",
> >
> > + "'default'", "'password'", "'endpassword'", "'string'", "'endstring'",
> >
> > + "'minsize'", "'maxsize'", "'encoding'", "'suppressif'", "'disableif'",
> >
> > + "'hidden'", "'goto'", "'formsetguid'", "'inconsistentif'", "'warningif'",
> >
> > + "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'", "'MANUFACTURING'",
> >
> > + "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'",
> > "'INTERACTIVE'",
> >
> > + "'NV_ACCESS'", "'RESET_REQUIRED'", "'RECONNECT_REQUIRED'",
> > "'LATE_CHECK'",
> >
> > + "'READ_ONLY'", "'OPTIONS_ONLY'", "'REST_STYLE'", "'class'",
> >
> > + "'subclass'", "'classguid'", "'typedef'", "'restore'", "'save'",
> >
> > + "'defaults'", "'banner'", "'align'", "'left'", "'right'", "'center'",
> >
> > + "'line'", "'name'", "'varid'", "'question'", "'questionid'",
> >
> > + "'image'", "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
> >
> > + "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
> >
> > + "'attribute'", "'varstore'", "'efivarstore'", "'varsize'",
> > "'namevaluevarstore'",
> >
> > + "'action'", "'config'", "'endaction'", "'refresh'", "'interval'",
> >
> > + "'varstoredevice'", "'guidop'", "'endguidop'", "'datatype'",
> >
> > + "'data'", "'modal'", "'NON_DEVICE'", "'DISK_DEVICE'",
> > "'VIDEO_DEVICE'",
> >
> > + "'NETWORK_DEVICE'", "'INPUT_DEVICE'", "'ONBOARD_DEVICE'",
> > "'OTHER_DEVICE'",
> >
> > + "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'",
> "'FRONT_PAGE'",
> >
> > + "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'",
> > "'DAY_SUPPRESS'",
> >
> > + "'HOUR_SUPPRESS'", "'MINUTE_SUPPRESS'", "'SECOND_SUPPRESS'",
> >
> > + "'STORAGE_NORMAL'", "'STORAGE_TIME'", "'STORAGE_WAKEUP'",
> > "'UNIQUE'",
> >
> > + "'NOEMPTY'", "'cond'", "'find'", "'mid'", "'token'", "'span'",
> >
> > + "'dup'", "'vareqval'", "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
> >
> > + "'questionref'", "'ruleref'", "'stringref'", "'pushthis'", "'security'",
> >
> > + "'get'", "'TRUE'", "'FALSE'", "'ONE'", "'ONES'", "'ZERO'",
> > "'UNDEFINED'",
> >
> > + "'VERSION'", "'length'", "'AND'", "'OR'", "'NOT'", "'set'",
> >
> > + "'~'", "'boolval'", "'stringval'", "'unintval'", "'toupper'",
> >
> > + "'tolower'", "'match'", "'match2'", "'catenate'", "'questionrefval'",
> >
> > + "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
> >
> > + "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'",
> > "'NUMERIC_SIZE_1'",
> >
> > + "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'", "'NUMERIC_SIZE_8'",
> >
> > + "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'",
> "'DISPLAY_UINT_HEX'",
> >
> > + "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'",
> > "'FIRST_NON_MATCH'" ]
> >
> > +
> >
> > + symbolicNames = [ "<INVALID>",
> >
> > + "Define", "Include", "FormPkgType", "OpenBrace", "CloseBrace",
> >
> > + "OpenParen", "CloseParen", "OpenBracket", "CloseBracket", "Dot",
> >
> > + "Negative", "Colon", "Slash", "Semicolon", "Comma", "Equal",
> >
> > + "NotEqual", "LessEqual", "Less", "GreaterEqual", "Greater",
> >
> > + "BitWiseOr", "BitWiseAnd", "DevicePath", "FormSet", "FormSetId",
> >
> > + "EndFormSet", "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
> >
> > + "OrderedList", "MaxContainers", "EndList", "EndForm", "Form",
> >
> > + "FormMap", "MapTitle", "MapGuid", "Subtitle", "EndSubtitle",
> >
> > + "Help", "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
> >
> > + "Month", "Day", "Time", "EndTime", "Hour", "Minute", "Second",
> >
> > + "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
> >
> > + "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
> >
> > + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
> > "EFI_HII_REF",
> >
> > + "Uuid", "CheckBox", "EndCheckBox", "Numeric", "EndNumeric",
> >
> > + "Minimum", "Maximum", "Step", "Default", "Password",
> > "EndPassword",
> >
> > + "String", "EndString", "MinSize", "MaxSize", "Encoding",
> "SuppressIf",
> >
> > + "DisableIf", "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
> >
> > + "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
> > "ManufacturingFlag",
> >
> > + "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag",
> "InteractiveFlag",
> >
> > + "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
> >
> > + "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag", "RestStyleFlag",
> >
> > + "Class", "Subclass", "ClassGuid", "TypeDef", "Restore", "Save",
> >
> > + "Defaults", "Banner", "Align", "Left", "Right", "Center", "Line",
> >
> > + "Name", "VarId", "Question", "QuestionId", "Image", "Locked",
> >
> > + "Rule", "EndRule", "Value", "Read", "Write", "ResetButton",
> >
> > + "EndResetButton", "DefaultStore", "Attribute", "Varstore",
> > "Efivarstore",
> >
> > + "VarSize", "NameValueVarStore", "Action", "Config", "EndAction",
> >
> > + "Refresh", "Interval", "VarstoreDevice", "GuidOp", "EndGuidOp",
> >
> > + "DataType", "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
> >
> > + "ClassVideoDevice", "ClassNetworkDevice", "ClassInputDevice",
> >
> > + "ClassOnBoardDevice", "ClassOtherDevice",
> > "SubclassSetupApplication",
> >
> > + "SubclassGeneralApplication", "SubclassFrontPage",
> > "SubclassSingleUse",
> >
> > + "YearSupppressFlag", "MonthSuppressFlag", "DaySuppressFlag",
> >
> > + "HourSupppressFlag", "MinuteSuppressFlag",
> "SecondSuppressFlag",
> >
> > + "StorageNormalFlag", "StorageTimeFlag", "StorageWakeUpFlag",
> >
> > + "UniQueFlag", "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span",
> >
> > + "Dup", "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
> >
> > + "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
> >
> > + "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
> > "Undefined",
> >
> > + "Version", "Length", "AND", "OR", "NOT", "Set", "BitWiseNot",
> >
> > + "BoolVal", "StringVal", "UnIntVal", "ToUpper", "ToLower", "Match",
> >
> > + "Match2", "Catenate", "QuestionRefVal", "StringRefVal", "Map",
> >
> > + "RefreshGuid", "StringToken", "OptionDefault", "OptionDefaultMfg",
> >
> > + "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour",
> > "NumericSizeEight",
> >
> > + "DisPlayIntDec", "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive",
> >
> > + "Sensitive", "LastNonMatch", "FirstNonMatch", "Number",
> > "StringIdentifier",
> >
> > + "ComplexDefine", "LineDefinition", "IncludeDefinition",
> > "Whitespace",
> >
> > + "Newline", "LineComment", "Extern" ]
> >
> > +
> >
> > + ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
> >
> > + "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
> >
> > + "T__14", "T__15", "Define", "Include", "FormPkgType",
> >
> > + "OpenBrace", "CloseBrace", "OpenParen", "CloseParen",
> >
> > + "OpenBracket", "CloseBracket", "Dot", "Negative", "Colon",
> >
> > + "Slash", "Semicolon", "Comma", "Equal", "NotEqual",
> "LessEqual",
> >
> > + "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
> >
> > + "DevicePath", "FormSet", "FormSetId", "EndFormSet", "Title",
> >
> > + "FormId", "OneOf", "EndOneOf", "Prompt", "OrderedList",
> >
> > + "MaxContainers", "EndList", "EndForm", "Form", "FormMap",
> >
> > + "MapTitle", "MapGuid", "Subtitle", "EndSubtitle", "Help",
> >
> > + "Text", "Option", "FLAGS", "Date", "EndDate", "Year",
> >
> > + "Month", "Day", "Time", "EndTime", "Hour", "Minute",
> "Second",
> >
> > + "GrayOutIf", "Label", "Timeout", "Inventory", "NonNvDataMap",
> >
> > + "Struct", "Union", "Boolean", "Uint64", "Uint32", "Uint16",
> >
> > + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
> >
> > + "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox", "Numeric",
> >
> > + "EndNumeric", "Minimum", "Maximum", "Step", "Default",
> >
> > + "Password", "EndPassword", "String", "EndString", "MinSize",
> >
> > + "MaxSize", "Encoding", "SuppressIf", "DisableIf", "Hidden",
> >
> > + "Goto", "FormSetGuid", "InconsistentIf", "WarningIf",
> >
> > + "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
> "ManufacturingFlag",
> >
> > + "CheckBoxDefaultFlag", "CheckBoxDefaultMfgFlag",
> > "InteractiveFlag",
> >
> > + "NVAccessFlag", "ResetRequiredFlag", "ReconnectRequiredFlag",
> >
> > + "LateCheckFlag", "ReadOnlyFlag", "OptionOnlyFlag",
> > "RestStyleFlag",
> >
> > + "Class", "Subclass", "ClassGuid", "TypeDef", "Restore",
> >
> > + "Save", "Defaults", "Banner", "Align", "Left", "Right",
> >
> > + "Center", "Line", "Name", "VarId", "Question", "QuestionId",
> >
> > + "Image", "Locked", "Rule", "EndRule", "Value", "Read",
> >
> > + "Write", "ResetButton", "EndResetButton", "DefaultStore",
> >
> > + "Attribute", "Varstore", "Efivarstore", "VarSize",
> > "NameValueVarStore",
> >
> > + "Action", "Config", "EndAction", "Refresh", "Interval",
> >
> > + "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType", "Data",
> >
> > + "Modal", "ClassNonDevice", "ClassDiskDevice",
> > "ClassVideoDevice",
> >
> > + "ClassNetworkDevice", "ClassInputDevice",
> > "ClassOnBoardDevice",
> >
> > + "ClassOtherDevice", "SubclassSetupApplication",
> > "SubclassGeneralApplication",
> >
> > + "SubclassFrontPage", "SubclassSingleUse", "YearSupppressFlag",
> >
> > + "MonthSuppressFlag", "DaySuppressFlag", "HourSupppressFlag",
> >
> > + "MinuteSuppressFlag", "SecondSuppressFlag",
> > "StorageNormalFlag",
> >
> > + "StorageTimeFlag", "StorageWakeUpFlag", "UniQueFlag",
> >
> > + "NoEmptyFlag", "Cond", "Find", "Mid", "Tok", "Span", "Dup",
> >
> > + "VarEqVal", "Var", "IdEqVal", "IdEqId", "IdEqValList",
> >
> > + "QuestionRef", "RuleRef", "StringRef", "PushThis", "Security",
> >
> > + "Get", "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
> >
> > + "Undefined", "Version", "Length", "AND", "OR", "NOT",
> >
> > + "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
> >
> > + "ToUpper", "ToLower", "Match", "Match2", "Catenate",
> > "QuestionRefVal",
> >
> > + "StringRefVal", "Map", "RefreshGuid", "StringToken",
> > "OptionDefault",
> >
> > + "OptionDefaultMfg", "NumericSizeOne", "NumericSizeTwo",
> >
> > + "NumericSizeFour", "NumericSizeEight", "DisPlayIntDec",
> >
> > + "DisPlayUIntDec", "DisPlayUIntHex", "Insensitive", "Sensitive",
> >
> > + "LastNonMatch", "FirstNonMatch", "Number", "StringIdentifier",
> >
> > + "ComplexDefine", "LineDefinition", "IncludeDefinition",
> >
> > + "Whitespace", "Newline", "LineComment", "Extern" ]
> >
> > +
> >
> > + grammarFileName = "VfrSyntax.g4"
> >
> > +
> >
> > + def __init__(self, input=None, output:TextIO = sys.stdout):
> >
> > + super().__init__(input, output)
> >
> > + self.checkVersion("4.7.2")
> >
> > + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA,
> > PredictionContextCache())
> >
> > + self._actions = None
> >
> > + self._predicates = None
> >
> > diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> > b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> > new file mode 100644
> > index 0000000000..d5d61a26a9
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> > @@ -0,0 +1,20475 @@
> > +# 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
> >
> > +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("\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")
> >
> > + buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
> >
> > + buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
> >
> > + buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
> >
> > + buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
> >
> > + buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
> >
> > +
> buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
> >
> > + buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
> >
> > +
> buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
> >
> > + buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
> >
> > + buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
> >
> > + buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
> >
> > + buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
> >
> > + buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
> >
> > +
> > buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
> >
> > +
> > buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
> >
> > +
> > buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
> >
> > +
> > buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
> >
> > +
> > buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
> >
> > +
> > buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
> >
> > +
> > buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
> >
> > +
> > buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
> >
> > +
> > buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
> >
> > +
> > buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
> >
> > +
> > buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
> >
> > +
> > buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
> >
> > +
> > buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
> >
> > +
> > buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
> >
> > +
> > buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
> >
> > +
> > buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
> >
> > +
> > buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
> >
> > +
> > buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
> >
> > +
> > buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
> >
> > +
> > buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
> >
> > +
> > buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
> >
> > + buf.write("\t\u00ca\4\u00cb\t\u00cb\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\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\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\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\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("\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\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("\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\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\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\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\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()
> >
> > +
> >
> > +
> >
> > +class VfrSyntaxParser ( Parser ):
> >
> > +
> >
> > + grammarFileName = "VfrSyntax.g4"
> >
> > +
> >
> > + atn = ATNDeserializer().deserialize(serializedATN())
> >
> > +
> >
> > + decisionsToDFA = [ DFA(ds, i) for i, ds in
> enumerate(atn.decisionToState) ]
> >
> > +
> >
> > + sharedContextCache = PredictionContextCache()
> >
> > +
> >
> > + literalNames = [ "<INVALID>", "'show'", "'push'", "'pop'", "'#pragma'",
> >
> > + "'pack'", "'='", "'IMAGE_TOKEN'", "'HORIZONTAL'",
> > "'MULTI_LINE'",
> >
> > + "'<<'", "'>>'", "'+'", "'*'", "'%'", "'format'", "'?'",
> >
> > + "'#define'", "'#include'", "'formpkgtype'", "'{'",
> >
> > + "'}'", "'('", "')'", "'['", "']'", "'.'", "'-'", "':'",
> >
> > + "'/'", "';'", "','", "'=='", "'!='", "'<='", "'<'",
> >
> > + "'>='", "'>'", "'|'", "'&'", "'devicepath'", "'formset'",
> >
> > + "'formsetid'", "'endformset'", "'title'", "'formid'",
> >
> > + "'oneof'", "'endoneof'", "'prompt'", "'orderedlist'",
> >
> > + "'maxcontainers'", "'endlist'", "'endform'", "'form'",
> >
> > + "'formmap'", "'maptitle'", "'mapguid'", "'subtitle'",
> >
> > + "'endsubtitle'", "'help'", "'text'", "'option'", "'flags'",
> >
> > + "'date'", "'enddate'", "'year'", "'month'", "'day'",
> >
> > + "'time'", "'endtime'", "'hour'", "'minute'", "'second'",
> >
> > + "'grayoutif'", "'label'", "'timeout'", "'inventory'",
> >
> > + "'_NON_NV_DATA_MAP'", "'struct'", "'union'", "'BOOLEAN'",
> >
> > + "'UINT64'", "'UINT32'", "'UINT16'", "'UINT8'",
> "'EFI_STRING_ID'",
> >
> > + "'EFI_HII_DATE'", "'EFI_HII_TIME'", "'EFI_HII_REF'",
> >
> > + "'guid'", "'checkbox'", "'endcheckbox'", "'numeric'",
> >
> > + "'endnumeric'", "'minimum'", "'maximum'", "'step'",
> >
> > + "'default'", "'password'", "'endpassword'", "'string'",
> >
> > + "'endstring'", "'minsize'", "'maxsize'", "'encoding'",
> >
> > + "'suppressif'", "'disableif'", "'hidden'", "'goto'",
> >
> > + "'formsetguid'", "'inconsistentif'", "'warningif'",
> >
> > + "'nosubmitif'", "'endif'", "'key'", "'DEFAULT'",
> > "'MANUFACTURING'",
> >
> > + "'CHECKBOX_DEFAULT'", "'CHECKBOX_DEFAULT_MFG'",
> > "'INTERACTIVE'",
> >
> > + "'NV_ACCESS'", "'RESET_REQUIRED'",
> "'RECONNECT_REQUIRED'",
> >
> > + "'LATE_CHECK'", "'READ_ONLY'", "'OPTIONS_ONLY'",
> > "'REST_STYLE'",
> >
> > + "'class'", "'subclass'", "'classguid'", "'typedef'",
> >
> > + "'restore'", "'save'", "'defaults'", "'banner'", "'align'",
> >
> > + "'left'", "'right'", "'center'", "'line'", "'name'",
> >
> > + "'varid'", "'question'", "'questionid'", "'image'",
> >
> > + "'locked'", "'rule'", "'endrule'", "'value'", "'read'",
> >
> > + "'write'", "'resetbutton'", "'endresetbutton'", "'defaultstore'",
> >
> > + "'attribute'", "'varstore'", "'efivarstore'", "'varsize'",
> >
> > + "'namevaluevarstore'", "'action'", "'config'", "'endaction'",
> >
> > + "'refresh'", "'interval'", "'varstoredevice'", "'guidop'",
> >
> > + "'endguidop'", "'datatype'", "'data'", "'modal'",
> "'NON_DEVICE'",
> >
> > + "'DISK_DEVICE'", "'VIDEO_DEVICE'", "'NETWORK_DEVICE'",
> >
> > + "'INPUT_DEVICE'", "'ONBOARD_DEVICE'", "'OTHER_DEVICE'",
> >
> > + "'SETUP_APPLICATION'", "'GENERAL_APPLICATION'",
> > "'FRONT_PAGE'",
> >
> > + "'SINGLE_USE'", "'YEAR_SUPPRESS'", "'MONTH_SUPPRESS'",
> >
> > + "'DAY_SUPPRESS'", "'HOUR_SUPPRESS'",
> "'MINUTE_SUPPRESS'",
> >
> > + "'SECOND_SUPPRESS'", "'STORAGE_NORMAL'",
> > "'STORAGE_TIME'",
> >
> > + "'STORAGE_WAKEUP'", "'UNIQUE'", "'NOEMPTY'", "'cond'",
> >
> > + "'find'", "'mid'", "'token'", "'span'", "'dup'", "'vareqval'",
> >
> > + "'var'", "'ideqval'", "'ideqid'", "'ideqvallist'",
> >
> > + "'questionref'", "'ruleref'", "'stringref'", "'pushthis'",
> >
> > + "'security'", "'get'", "'TRUE'", "'FALSE'", "'ONE'",
> >
> > + "'ONES'", "'ZERO'", "'UNDEFINED'", "'VERSION'", "'length'",
> >
> > + "'AND'", "'OR'", "'NOT'", "'set'", "'~'", "'boolval'",
> >
> > + "'stringval'", "'unintval'", "'toupper'", "'tolower'",
> >
> > + "'match'", "'match2'", "'catenate'", "'questionrefval'",
> >
> > + "'stringrefval'", "'map'", "'refreshguid'", "'STRING_TOKEN'",
> >
> > + "'OPTION_DEFAULT'", "'OPTION_DEFAULT_MFG'",
> > "'NUMERIC_SIZE_1'",
> >
> > + "'NUMERIC_SIZE_2'", "'NUMERIC_SIZE_4'",
> "'NUMERIC_SIZE_8'",
> >
> > + "'DISPLAY_INT_DEC'", "'DISPLAY_UINT_DEC'",
> > "'DISPLAY_UINT_HEX'",
> >
> > + "'INSENSITIVE'", "'SENSITIVE'", "'LAST_NON_MATCH'",
> >
> > + "'FIRST_NON_MATCH'" ]
> >
> > +
> >
> > + symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>",
> "<INVALID>",
> >
> > + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
> >
> > + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
> >
> > + "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
> >
> > + "<INVALID>", "Define", "Include", "FormPkgType",
> "OpenBrace",
> >
> > + "CloseBrace", "OpenParen", "CloseParen", "OpenBracket",
> >
> > + "CloseBracket", "Dot", "Negative", "Colon", "Slash",
> >
> > + "Semicolon", "Comma", "Equal", "NotEqual", "LessEqual",
> >
> > + "Less", "GreaterEqual", "Greater", "BitWiseOr", "BitWiseAnd",
> >
> > + "DevicePath", "FormSet", "FormSetId", "EndFormSet",
> >
> > + "Title", "FormId", "OneOf", "EndOneOf", "Prompt",
> >
> > + "OrderedList", "MaxContainers", "EndList", "EndForm",
> >
> > + "Form", "FormMap", "MapTitle", "MapGuid", "Subtitle",
> >
> > + "EndSubtitle", "Help", "Text", "Option", "FLAGS",
> >
> > + "Date", "EndDate", "Year", "Month", "Day", "Time",
> >
> > + "EndTime", "Hour", "Minute", "Second", "GrayOutIf",
> >
> > + "Label", "Timeout", "Inventory", "NonNvDataMap", "Struct",
> >
> > + "Union", "Boolean", "Uint64", "Uint32", "Uint16",
> >
> > + "Uint8", "EFI_STRING_ID", "EFI_HII_DATE", "EFI_HII_TIME",
> >
> > + "EFI_HII_REF", "Uuid", "CheckBox", "EndCheckBox",
> >
> > + "Numeric", "EndNumeric", "Minimum", "Maximum", "Step",
> >
> > + "Default", "Password", "EndPassword", "String", "EndString",
> >
> > + "MinSize", "MaxSize", "Encoding", "SuppressIf", "DisableIf",
> >
> > + "Hidden", "Goto", "FormSetGuid", "InconsistentIf",
> >
> > + "WarningIf", "NoSubmitIf", "EndIf", "Key", "DefaultFlag",
> >
> > + "ManufacturingFlag", "CheckBoxDefaultFlag",
> > "CheckBoxDefaultMfgFlag",
> >
> > + "InteractiveFlag", "NVAccessFlag", "ResetRequiredFlag",
> >
> > + "ReconnectRequiredFlag", "LateCheckFlag", "ReadOnlyFlag",
> >
> > + "OptionOnlyFlag", "RestStyleFlag", "Class", "Subclass",
> >
> > + "ClassGuid", "TypeDef", "Restore", "Save", "Defaults",
> >
> > + "Banner", "Align", "Left", "Right", "Center", "Line",
> >
> > + "Name", "VarId", "Question", "QuestionId", "Image",
> >
> > + "Locked", "Rule", "EndRule", "Value", "Read", "Write",
> >
> > + "ResetButton", "EndResetButton", "DefaultStore", "Attribute",
> >
> > + "Varstore", "Efivarstore", "VarSize", "NameValueVarStore",
> >
> > + "Action", "Config", "EndAction", "Refresh", "Interval",
> >
> > + "VarstoreDevice", "GuidOp", "EndGuidOp", "DataType",
> >
> > + "Data", "Modal", "ClassNonDevice", "ClassDiskDevice",
> >
> > + "ClassVideoDevice", "ClassNetworkDevice",
> "ClassInputDevice",
> >
> > + "ClassOnBoardDevice", "ClassOtherDevice",
> > "SubclassSetupApplication",
> >
> > + "SubclassGeneralApplication", "SubclassFrontPage",
> >
> > + "SubclassSingleUse", "YearSupppressFlag",
> > "MonthSuppressFlag",
> >
> > + "DaySuppressFlag", "HourSupppressFlag",
> > "MinuteSuppressFlag",
> >
> > + "SecondSuppressFlag", "StorageNormalFlag",
> "StorageTimeFlag",
> >
> > + "StorageWakeUpFlag", "UniQueFlag", "NoEmptyFlag",
> >
> > + "Cond", "Find", "Mid", "Tok", "Span", "Dup", "VarEqVal",
> >
> > + "Var", "IdEqVal", "IdEqId", "IdEqValList", "QuestionRef",
> >
> > + "RuleRef", "StringRef", "PushThis", "Security", "Get",
> >
> > + "TrueSymbol", "FalseSymbol", "One", "Ones", "Zero",
> >
> > + "Undefined", "Version", "Length", "AND", "OR", "NOT",
> >
> > + "Set", "BitWiseNot", "BoolVal", "StringVal", "UnIntVal",
> >
> > + "ToUpper", "ToLower", "Match", "Match2", "Catenate",
> >
> > + "QuestionRefVal", "StringRefVal", "Map", "RefreshGuid",
> >
> > + "StringToken", "OptionDefault", "OptionDefaultMfg",
> >
> > + "NumericSizeOne", "NumericSizeTwo", "NumericSizeFour",
> >
> > + "NumericSizeEight", "DisPlayIntDec", "DisPlayUIntDec",
> >
> > + "DisPlayUIntHex", "Insensitive", "Sensitive", "LastNonMatch",
> >
> > + "FirstNonMatch", "Number", "StringIdentifier",
> > "ComplexDefine",
> >
> > + "LineDefinition", "IncludeDefinition", "Whitespace",
> >
> > + "Newline", "LineComment", "Extern" ]
> >
> > +
> >
> > + RULE_vfrProgram = 0
> >
> > + RULE_pragmaPackShowDef = 1
> >
> > + RULE_pragmaPackStackDef = 2
> >
> > + RULE_pragmaPackNumber = 3
> >
> > + RULE_vfrPragmaPackDefinition = 4
> >
> > + RULE_vfrDataStructDefinition = 5
> >
> > + RULE_vfrDataUnionDefinition = 6
> >
> > + RULE_vfrDataStructFields = 7
> >
> > + RULE_dataStructField64 = 8
> >
> > + RULE_dataStructField32 = 9
> >
> > + RULE_dataStructField16 = 10
> >
> > + RULE_dataStructField8 = 11
> >
> > + RULE_dataStructFieldBool = 12
> >
> > + RULE_dataStructFieldString = 13
> >
> > + RULE_dataStructFieldDate = 14
> >
> > + RULE_dataStructFieldTime = 15
> >
> > + RULE_dataStructFieldRef = 16
> >
> > + RULE_dataStructFieldUser = 17
> >
> > + RULE_dataStructBitField64 = 18
> >
> > + RULE_dataStructBitField32 = 19
> >
> > + RULE_dataStructBitField16 = 20
> >
> > + RULE_dataStructBitField8 = 21
> >
> > + RULE_vfrFormSetDefinition = 22
> >
> > + RULE_classguidDefinition = 23
> >
> > + RULE_classDefinition = 24
> >
> > + RULE_validClassNames = 25
> >
> > + RULE_subclassDefinition = 26
> >
> > + RULE_vfrFormSetList = 27
> >
> > + RULE_vfrFormSet = 28
> >
> > + RULE_vfrStatementDefaultStore = 29
> >
> > + RULE_vfrStatementVarStoreLinear = 30
> >
> > + RULE_vfrStatementVarStoreEfi = 31
> >
> > + RULE_vfrVarStoreEfiAttr = 32
> >
> > + RULE_vfrStatementVarStoreNameValue = 33
> >
> > + RULE_vfrStatementDisableIfFormSet = 34
> >
> > + RULE_vfrStatementSuppressIfFormSet = 35
> >
> > + RULE_guidSubDefinition = 36
> >
> > + RULE_guidDefinition = 37
> >
> > + RULE_getStringId = 38
> >
> > + RULE_vfrQuestionHeader = 39
> >
> > + RULE_vfrQuestionBaseInfo = 40
> >
> > + RULE_vfrStatementHeader = 41
> >
> > + RULE_questionheaderFlagsField = 42
> >
> > + RULE_vfrStorageVarId = 43
> >
> > + RULE_vfrConstantValueField = 44
> >
> > + RULE_vfrImageTag = 45
> >
> > + RULE_vfrLockedTag = 46
> >
> > + RULE_vfrStatementStatTag = 47
> >
> > + RULE_vfrStatementStatTagList = 48
> >
> > + RULE_vfrFormDefinition = 49
> >
> > + RULE_vfrForm = 50
> >
> > + RULE_vfrFormMapDefinition = 51
> >
> > + RULE_vfrStatementImage = 52
> >
> > + RULE_vfrStatementLocked = 53
> >
> > + RULE_vfrStatementRules = 54
> >
> > + RULE_vfrStatementStat = 55
> >
> > + RULE_vfrStatementSubTitle = 56
> >
> > + RULE_vfrStatementSubTitleComponent = 57
> >
> > + RULE_vfrSubtitleFlags = 58
> >
> > + RULE_subtitleFlagsField = 59
> >
> > + RULE_vfrStatementStaticText = 60
> >
> > + RULE_staticTextFlagsField = 61
> >
> > + RULE_vfrStatementCrossReference = 62
> >
> > + RULE_vfrStatementGoto = 63
> >
> > + RULE_vfrGotoFlags = 64
> >
> > + RULE_gotoFlagsField = 65
> >
> > + RULE_vfrStatementResetButton = 66
> >
> > + RULE_vfrStatementQuestions = 67
> >
> > + RULE_vfrStatementQuestionTag = 68
> >
> > + RULE_vfrStatementInconsistentIf = 69
> >
> > + RULE_vfrStatementNoSubmitIf = 70
> >
> > + RULE_vfrStatementDisableIfQuest = 71
> >
> > + RULE_vfrStatementRefresh = 72
> >
> > + RULE_vfrStatementVarstoreDevice = 73
> >
> > + RULE_vfrStatementRefreshEvent = 74
> >
> > + RULE_vfrStatementWarningIf = 75
> >
> > + RULE_vfrStatementQuestionTagList = 76
> >
> > + RULE_vfrStatementQuestionOptionTag = 77
> >
> > + RULE_flagsField = 78
> >
> > + RULE_vfrStatementSuppressIfQuest = 79
> >
> > + RULE_vfrStatementGrayOutIfQuest = 80
> >
> > + RULE_vfrStatementDefault = 81
> >
> > + RULE_vfrStatementValue = 82
> >
> > + RULE_vfrStatementOptions = 83
> >
> > + RULE_vfrStatementOneOfOption = 84
> >
> > + RULE_vfrOneOfOptionFlags = 85
> >
> > + RULE_oneofoptionFlagsField = 86
> >
> > + RULE_vfrStatementRead = 87
> >
> > + RULE_vfrStatementWrite = 88
> >
> > + RULE_vfrStatementQuestionOptionList = 89
> >
> > + RULE_vfrStatementQuestionOption = 90
> >
> > + RULE_vfrStatementBooleanType = 91
> >
> > + RULE_vfrStatementCheckBox = 92
> >
> > + RULE_vfrCheckBoxFlags = 93
> >
> > + RULE_checkboxFlagsField = 94
> >
> > + RULE_vfrStatementAction = 95
> >
> > + RULE_vfrActionFlags = 96
> >
> > + RULE_actionFlagsField = 97
> >
> > + RULE_vfrStatementNumericType = 98
> >
> > + RULE_vfrStatementNumeric = 99
> >
> > + RULE_vfrSetMinMaxStep = 100
> >
> > + RULE_vfrNumericFlags = 101
> >
> > + RULE_numericFlagsField = 102
> >
> > + RULE_vfrStatementOneOf = 103
> >
> > + RULE_vfrOneofFlagsField = 104
> >
> > + RULE_vfrStatementStringType = 105
> >
> > + RULE_vfrStatementString = 106
> >
> > + RULE_vfrStringFlagsField = 107
> >
> > + RULE_stringFlagsField = 108
> >
> > + RULE_vfrStatementPassword = 109
> >
> > + RULE_vfrPasswordFlagsField = 110
> >
> > + RULE_passwordFlagsField = 111
> >
> > + RULE_vfrStatementOrderedList = 112
> >
> > + RULE_vfrOrderedListFlags = 113
> >
> > + RULE_orderedlistFlagsField = 114
> >
> > + RULE_vfrStatementDate = 115
> >
> > + RULE_minMaxDateStepDefault = 116
> >
> > + RULE_vfrDateFlags = 117
> >
> > + RULE_dateFlagsField = 118
> >
> > + RULE_vfrStatementTime = 119
> >
> > + RULE_minMaxTimeStepDefault = 120
> >
> > + RULE_vfrTimeFlags = 121
> >
> > + RULE_timeFlagsField = 122
> >
> > + RULE_vfrStatementConditional = 123
> >
> > + RULE_vfrStatementConditionalNew = 124
> >
> > + RULE_vfrStatementSuppressIfStat = 125
> >
> > + RULE_vfrStatementGrayOutIfStat = 126
> >
> > + RULE_vfrStatementStatList = 127
> >
> > + RULE_vfrStatementStatListOld = 128
> >
> > + RULE_vfrStatementDisableIfStat = 129
> >
> > + RULE_vfrStatementgrayoutIfSuppressIf = 130
> >
> > + RULE_vfrStatementsuppressIfGrayOutIf = 131
> >
> > + RULE_vfrStatementSuppressIfStatNew = 132
> >
> > + RULE_vfrStatementGrayOutIfStatNew = 133
> >
> > + RULE_vfrStatementInconsistentIfStat = 134
> >
> > + RULE_vfrStatementInvalid = 135
> >
> > + RULE_vfrStatementInvalidHidden = 136
> >
> > + RULE_vfrStatementInvalidInventory = 137
> >
> > + RULE_vfrStatementInvalidSaveRestoreDefaults = 138
> >
> > + RULE_vfrStatementLabel = 139
> >
> > + RULE_vfrStatementBanner = 140
> >
> > + RULE_vfrStatementExtension = 141
> >
> > + RULE_vfrExtensionData = 142
> >
> > + RULE_vfrStatementModal = 143
> >
> > + RULE_vfrModalTag = 144
> >
> > + RULE_vfrStatementExpression = 145
> >
> > + RULE_vfrStatementExpressionSub = 146
> >
> > + RULE_andTerm = 147
> >
> > + RULE_bitwiseorTerm = 148
> >
> > + RULE_bitwiseandTerm = 149
> >
> > + RULE_equalTerm = 150
> >
> > + RULE_equalTermSupplementary = 151
> >
> > + RULE_compareTerm = 152
> >
> > + RULE_compareTermSupplementary = 153
> >
> > + RULE_shiftTerm = 154
> >
> > + RULE_shiftTermSupplementary = 155
> >
> > + RULE_addMinusTerm = 156
> >
> > + RULE_addMinusTermSupplementary = 157
> >
> > + RULE_multdivmodTerm = 158
> >
> > + RULE_multdivmodTermSupplementary = 159
> >
> > + RULE_castTerm = 160
> >
> > + RULE_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",
> >
> > + "vfrDataUnionDefinition", "vfrDataStructFields",
> > "dataStructField64",
> >
> > + "dataStructField32", "dataStructField16", "dataStructField8",
> >
> > + "dataStructFieldBool", "dataStructFieldString",
> > "dataStructFieldDate",
> >
> > + "dataStructFieldTime", "dataStructFieldRef",
> > "dataStructFieldUser",
> >
> > + "dataStructBitField64", "dataStructBitField32",
> > "dataStructBitField16",
> >
> > + "dataStructBitField8", "vfrFormSetDefinition",
> > "classguidDefinition",
> >
> > + "classDefinition", "validClassNames", "subclassDefinition",
> >
> > + "vfrFormSetList", "vfrFormSet", "vfrStatementDefaultStore",
> >
> > + "vfrStatementVarStoreLinear", "vfrStatementVarStoreEfi",
> >
> > + "vfrVarStoreEfiAttr", "vfrStatementVarStoreNameValue",
> >
> > + "vfrStatementDisableIfFormSet",
> > "vfrStatementSuppressIfFormSet",
> >
> > + "guidSubDefinition", "guidDefinition", "getStringId",
> >
> > + "vfrQuestionHeader", "vfrQuestionBaseInfo",
> > "vfrStatementHeader",
> >
> > + "questionheaderFlagsField", "vfrStorageVarId",
> > "vfrConstantValueField",
> >
> > + "vfrImageTag", "vfrLockedTag", "vfrStatementStatTag",
> >
> > + "vfrStatementStatTagList", "vfrFormDefinition", "vfrForm",
> >
> > + "vfrFormMapDefinition", "vfrStatementImage",
> > "vfrStatementLocked",
> >
> > + "vfrStatementRules", "vfrStatementStat",
> "vfrStatementSubTitle",
> >
> > + "vfrStatementSubTitleComponent", "vfrSubtitleFlags",
> >
> > + "subtitleFlagsField", "vfrStatementStaticText",
> > "staticTextFlagsField",
> >
> > + "vfrStatementCrossReference", "vfrStatementGoto",
> > "vfrGotoFlags",
> >
> > + "gotoFlagsField", "vfrStatementResetButton",
> > "vfrStatementQuestions",
> >
> > + "vfrStatementQuestionTag", "vfrStatementInconsistentIf",
> >
> > + "vfrStatementNoSubmitIf", "vfrStatementDisableIfQuest",
> >
> > + "vfrStatementRefresh", "vfrStatementVarstoreDevice",
> >
> > + "vfrStatementRefreshEvent", "vfrStatementWarningIf",
> >
> > + "vfrStatementQuestionTagList",
> > "vfrStatementQuestionOptionTag",
> >
> > + "flagsField", "vfrStatementSuppressIfQuest",
> > "vfrStatementGrayOutIfQuest",
> >
> > + "vfrStatementDefault", "vfrStatementValue",
> > "vfrStatementOptions",
> >
> > + "vfrStatementOneOfOption", "vfrOneOfOptionFlags",
> > "oneofoptionFlagsField",
> >
> > + "vfrStatementRead", "vfrStatementWrite",
> > "vfrStatementQuestionOptionList",
> >
> > + "vfrStatementQuestionOption", "vfrStatementBooleanType",
> >
> > + "vfrStatementCheckBox", "vfrCheckBoxFlags",
> > "checkboxFlagsField",
> >
> > + "vfrStatementAction", "vfrActionFlags", "actionFlagsField",
> >
> > + "vfrStatementNumericType", "vfrStatementNumeric",
> > "vfrSetMinMaxStep",
> >
> > + "vfrNumericFlags", "numericFlagsField", "vfrStatementOneOf",
> >
> > + "vfrOneofFlagsField", "vfrStatementStringType",
> > "vfrStatementString",
> >
> > + "vfrStringFlagsField", "stringFlagsField",
> "vfrStatementPassword",
> >
> > + "vfrPasswordFlagsField", "passwordFlagsField",
> > "vfrStatementOrderedList",
> >
> > + "vfrOrderedListFlags", "orderedlistFlagsField",
> "vfrStatementDate",
> >
> > + "minMaxDateStepDefault", "vfrDateFlags", "dateFlagsField",
> >
> > + "vfrStatementTime", "minMaxTimeStepDefault", "vfrTimeFlags",
> >
> > + "timeFlagsField", "vfrStatementConditional",
> > "vfrStatementConditionalNew",
> >
> > + "vfrStatementSuppressIfStat", "vfrStatementGrayOutIfStat",
> >
> > + "vfrStatementStatList", "vfrStatementStatListOld",
> > "vfrStatementDisableIfStat",
> >
> > + "vfrStatementgrayoutIfSuppressIf",
> > "vfrStatementsuppressIfGrayOutIf",
> >
> > + "vfrStatementSuppressIfStatNew",
> > "vfrStatementGrayOutIfStatNew",
> >
> > + "vfrStatementInconsistentIfStat", "vfrStatementInvalid",
> >
> > + "vfrStatementInvalidHidden", "vfrStatementInvalidInventory",
> >
> > + "vfrStatementInvalidSaveRestoreDefaults", "vfrStatementLabel",
> >
> > + "vfrStatementBanner", "vfrStatementExtension",
> > "vfrExtensionData",
> >
> > + "vfrStatementModal", "vfrModalTag",
> "vfrStatementExpression",
> >
> > + "vfrStatementExpressionSub", "andTerm", "bitwiseorTerm",
> >
> > + "bitwiseandTerm", "equalTerm", "equalTermSupplementary",
> >
> > + "compareTerm", "compareTermSupplementary", "shiftTerm",
> >
> > + "shiftTermSupplementary", "addMinusTerm",
> > "addMinusTermSupplementary",
> >
> > + "multdivmodTerm", "multdivmodTermSupplementary",
> > "castTerm",
> >
> > + "castTermSub", "atomTerm", "vfrExpressionCatenate",
> > "vfrExpressionMatch",
> >
> > + "vfrExpressionMatch2", "vfrExpressionParen",
> > "vfrExpressionBuildInFunction",
> >
> > + "dupExp", "vareqvalExp", "ideqvalExp", "ideqidExp",
> > "ideqvallistExp",
> >
> > + "vfrQuestionDataFieldName", "arrayName", "questionref1Exp",
> >
> > + "rulerefExp", "stringref1Exp", "pushthisExp", "securityExp",
> >
> > + "numericVarStoreType", "getExp", "vfrExpressionConstant",
> >
> > + "vfrExpressionUnaryOp", "lengthExp", "bitwisenotExp",
> >
> > + "question23refExp", "stringref2Exp", "toboolExp", "tostringExp",
> >
> > + "unintExp", "toupperExp", "tolwerExp", "setExp",
> > "vfrExpressionTernaryOp",
> >
> > + "conditionalExp", "findExp", "findFormat", "midExp",
> >
> > + "tokenExp", "spanExp", "spanFlags", "vfrExpressionMap" ]
> >
> > +
> >
> > + EOF = Token.EOF
> >
> > + T__0=1
> >
> > + T__1=2
> >
> > + T__2=3
> >
> > + T__3=4
> >
> > + T__4=5
> >
> > + T__5=6
> >
> > + T__6=7
> >
> > + T__7=8
> >
> > + T__8=9
> >
> > + T__9=10
> >
> > + T__10=11
> >
> > + T__11=12
> >
> > + T__12=13
> >
> > + T__13=14
> >
> > + T__14=15
> >
> > + T__15=16
> >
> > + Define=17
> >
> > + Include=18
> >
> > + FormPkgType=19
> >
> > + OpenBrace=20
> >
> > + CloseBrace=21
> >
> > + OpenParen=22
> >
> > + CloseParen=23
> >
> > + OpenBracket=24
> >
> > + CloseBracket=25
> >
> > + Dot=26
> >
> > + Negative=27
> >
> > + Colon=28
> >
> > + Slash=29
> >
> > + Semicolon=30
> >
> > + Comma=31
> >
> > + Equal=32
> >
> > + NotEqual=33
> >
> > + LessEqual=34
> >
> > + Less=35
> >
> > + GreaterEqual=36
> >
> > + Greater=37
> >
> > + BitWiseOr=38
> >
> > + BitWiseAnd=39
> >
> > + DevicePath=40
> >
> > + FormSet=41
> >
> > + FormSetId=42
> >
> > + EndFormSet=43
> >
> > + Title=44
> >
> > + FormId=45
> >
> > + OneOf=46
> >
> > + EndOneOf=47
> >
> > + Prompt=48
> >
> > + OrderedList=49
> >
> > + MaxContainers=50
> >
> > + EndList=51
> >
> > + EndForm=52
> >
> > + Form=53
> >
> > + FormMap=54
> >
> > + MapTitle=55
> >
> > + MapGuid=56
> >
> > + Subtitle=57
> >
> > + EndSubtitle=58
> >
> > + Help=59
> >
> > + Text=60
> >
> > + Option=61
> >
> > + FLAGS=62
> >
> > + Date=63
> >
> > + EndDate=64
> >
> > + Year=65
> >
> > + Month=66
> >
> > + Day=67
> >
> > + Time=68
> >
> > + EndTime=69
> >
> > + Hour=70
> >
> > + Minute=71
> >
> > + Second=72
> >
> > + GrayOutIf=73
> >
> > + Label=74
> >
> > + Timeout=75
> >
> > + Inventory=76
> >
> > + NonNvDataMap=77
> >
> > + Struct=78
> >
> > + Union=79
> >
> > + Boolean=80
> >
> > + Uint64=81
> >
> > + Uint32=82
> >
> > + Uint16=83
> >
> > + Uint8=84
> >
> > + EFI_STRING_ID=85
> >
> > + EFI_HII_DATE=86
> >
> > + EFI_HII_TIME=87
> >
> > + EFI_HII_REF=88
> >
> > + Uuid=89
> >
> > + CheckBox=90
> >
> > + EndCheckBox=91
> >
> > + Numeric=92
> >
> > + EndNumeric=93
> >
> > + Minimum=94
> >
> > + Maximum=95
> >
> > + Step=96
> >
> > + Default=97
> >
> > + Password=98
> >
> > + EndPassword=99
> >
> > + String=100
> >
> > + EndString=101
> >
> > + MinSize=102
> >
> > + MaxSize=103
> >
> > + Encoding=104
> >
> > + SuppressIf=105
> >
> > + DisableIf=106
> >
> > + Hidden=107
> >
> > + Goto=108
> >
> > + FormSetGuid=109
> >
> > + InconsistentIf=110
> >
> > + WarningIf=111
> >
> > + NoSubmitIf=112
> >
> > + EndIf=113
> >
> > + Key=114
> >
> > + DefaultFlag=115
> >
> > + ManufacturingFlag=116
> >
> > + CheckBoxDefaultFlag=117
> >
> > + CheckBoxDefaultMfgFlag=118
> >
> > + InteractiveFlag=119
> >
> > + NVAccessFlag=120
> >
> > + ResetRequiredFlag=121
> >
> > + ReconnectRequiredFlag=122
> >
> > + LateCheckFlag=123
> >
> > + ReadOnlyFlag=124
> >
> > + OptionOnlyFlag=125
> >
> > + RestStyleFlag=126
> >
> > + Class=127
> >
> > + Subclass=128
> >
> > + ClassGuid=129
> >
> > + TypeDef=130
> >
> > + Restore=131
> >
> > + Save=132
> >
> > + Defaults=133
> >
> > + Banner=134
> >
> > + Align=135
> >
> > + Left=136
> >
> > + Right=137
> >
> > + Center=138
> >
> > + Line=139
> >
> > + Name=140
> >
> > + VarId=141
> >
> > + Question=142
> >
> > + QuestionId=143
> >
> > + Image=144
> >
> > + Locked=145
> >
> > + Rule=146
> >
> > + EndRule=147
> >
> > + Value=148
> >
> > + Read=149
> >
> > + Write=150
> >
> > + ResetButton=151
> >
> > + EndResetButton=152
> >
> > + DefaultStore=153
> >
> > + Attribute=154
> >
> > + Varstore=155
> >
> > + Efivarstore=156
> >
> > + VarSize=157
> >
> > + NameValueVarStore=158
> >
> > + Action=159
> >
> > + Config=160
> >
> > + EndAction=161
> >
> > + Refresh=162
> >
> > + Interval=163
> >
> > + VarstoreDevice=164
> >
> > + GuidOp=165
> >
> > + EndGuidOp=166
> >
> > + DataType=167
> >
> > + Data=168
> >
> > + Modal=169
> >
> > + ClassNonDevice=170
> >
> > + ClassDiskDevice=171
> >
> > + ClassVideoDevice=172
> >
> > + ClassNetworkDevice=173
> >
> > + ClassInputDevice=174
> >
> > + ClassOnBoardDevice=175
> >
> > + ClassOtherDevice=176
> >
> > + SubclassSetupApplication=177
> >
> > + SubclassGeneralApplication=178
> >
> > + SubclassFrontPage=179
> >
> > + SubclassSingleUse=180
> >
> > + YearSupppressFlag=181
> >
> > + MonthSuppressFlag=182
> >
> > + DaySuppressFlag=183
> >
> > + HourSupppressFlag=184
> >
> > + MinuteSuppressFlag=185
> >
> > + SecondSuppressFlag=186
> >
> > + StorageNormalFlag=187
> >
> > + StorageTimeFlag=188
> >
> > + StorageWakeUpFlag=189
> >
> > + UniQueFlag=190
> >
> > + NoEmptyFlag=191
> >
> > + Cond=192
> >
> > + Find=193
> >
> > + Mid=194
> >
> > + Tok=195
> >
> > + Span=196
> >
> > + Dup=197
> >
> > + VarEqVal=198
> >
> > + Var=199
> >
> > + IdEqVal=200
> >
> > + IdEqId=201
> >
> > + IdEqValList=202
> >
> > + QuestionRef=203
> >
> > + RuleRef=204
> >
> > + StringRef=205
> >
> > + PushThis=206
> >
> > + Security=207
> >
> > + Get=208
> >
> > + TrueSymbol=209
> >
> > + FalseSymbol=210
> >
> > + One=211
> >
> > + Ones=212
> >
> > + Zero=213
> >
> > + Undefined=214
> >
> > + Version=215
> >
> > + Length=216
> >
> > + AND=217
> >
> > + OR=218
> >
> > + NOT=219
> >
> > + Set=220
> >
> > + BitWiseNot=221
> >
> > + BoolVal=222
> >
> > + StringVal=223
> >
> > + UnIntVal=224
> >
> > + ToUpper=225
> >
> > + ToLower=226
> >
> > + Match=227
> >
> > + Match2=228
> >
> > + Catenate=229
> >
> > + QuestionRefVal=230
> >
> > + StringRefVal=231
> >
> > + Map=232
> >
> > + RefreshGuid=233
> >
> > + StringToken=234
> >
> > + OptionDefault=235
> >
> > + OptionDefaultMfg=236
> >
> > + NumericSizeOne=237
> >
> > + NumericSizeTwo=238
> >
> > + NumericSizeFour=239
> >
> > + NumericSizeEight=240
> >
> > + DisPlayIntDec=241
> >
> > + DisPlayUIntDec=242
> >
> > + DisPlayUIntHex=243
> >
> > + Insensitive=244
> >
> > + Sensitive=245
> >
> > + LastNonMatch=246
> >
> > + FirstNonMatch=247
> >
> > + Number=248
> >
> > + StringIdentifier=249
> >
> > + ComplexDefine=250
> >
> > + LineDefinition=251
> >
> > + IncludeDefinition=252
> >
> > + Whitespace=253
> >
> > + Newline=254
> >
> > + LineComment=255
> >
> > + Extern=256
> >
> > +
> >
> > + def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
> >
> > + super().__init__(input, output)
> >
> > + self.checkVersion("4.7.2")
> >
> > + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA,
> > self.sharedContextCache)
> >
> > + self._predicates = None
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + class VfrProgramContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def vfrPragmaPackDefinition(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrPragmaPackDefinitionContext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrPragmaPackDefinitionContext,i)
> >
> > +
> >
> > +
> >
> > + def vfrDataStructDefinition(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrDataStructDefinitionContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructDefinitionContext,i)
> >
> > +
> >
> > +
> >
> > + def vfrDataUnionDefinition(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrDataUnionDefinitionContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrDataUnionDefinitionContext,i)
> >
> > +
> >
> > +
> >
> > + def vfrFormSetDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrProgram
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrProgram" ):
> >
> > + return visitor.visitVfrProgram(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrProgram(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrProgramContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 0, self.RULE_vfrProgram)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 409
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 406
> >
> > + self.vfrPragmaPackDefinition()
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + self.state = 407
> >
> > + self.vfrDataStructDefinition()
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 3:
> >
> > + self.state = 408
> >
> > + self.vfrDataUnionDefinition()
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + self.state = 413
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + 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)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class PragmaPackShowDefContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_pragmaPackShowDef
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitPragmaPackShowDef" ):
> >
> > + return visitor.visitPragmaPackShowDef(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def pragmaPackShowDef(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.PragmaPackShowDefContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 2, self.RULE_pragmaPackShowDef)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 417
> >
> > + self.match(VfrSyntaxParser.T__0)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class PragmaPackStackDefContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_pragmaPackStackDef
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitPragmaPackStackDef" ):
> >
> > + return visitor.visitPragmaPackStackDef(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def pragmaPackStackDef(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.PragmaPackStackDefContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 4, self.RULE_pragmaPackStackDef)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 422
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 420
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 421
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 426
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 424
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 425
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class PragmaPackNumberContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_pragmaPackNumber
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitPragmaPackNumber" ):
> >
> > + return visitor.visitPragmaPackNumber(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def pragmaPackNumber(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.PragmaPackNumberContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 6, self.RULE_pragmaPackNumber)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 429
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Number:
> >
> > + self.state = 428
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrPragmaPackDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def pragmaPackShowDef(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.PragmaPackShowDefContext,0)
> >
> > +
> >
> > +
> >
> > + def pragmaPackStackDef(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.PragmaPackStackDefContext,0)
> >
> > +
> >
> > +
> >
> > + def pragmaPackNumber(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.PragmaPackNumberContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrPragmaPackDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrPragmaPackDefinition" ):
> >
> > + return visitor.visitVfrPragmaPackDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrPragmaPackDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrPragmaPackDefinitionContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 8, self.RULE_vfrPragmaPackDefinition)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 431
> >
> > + self.match(VfrSyntaxParser.T__3)
> >
> > + self.state = 432
> >
> > + self.match(VfrSyntaxParser.T__4)
> >
> > + self.state = 433
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 437
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 434
> >
> > + self.pragmaPackShowDef()
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + self.state = 435
> >
> > + self.pragmaPackStackDef()
> >
> > +
> >
> > + elif la_ == 3:
> >
> > + self.state = 436
> >
> > + self.pragmaPackNumber()
> >
> > +
> >
> > +
> >
> > + self.state = 439
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrDataStructDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.N1 = None # Token
> >
> > + self.N2 = None # Token
> >
> > +
> >
> > + def Struct(self):
> >
> > + return self.getToken(VfrSyntaxParser.Struct, 0)
> >
> > +
> >
> > + def OpenBrace(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBrace, 0)
> >
> > +
> >
> > + def vfrDataStructFields(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
> >
> > +
> >
> > +
> >
> > + def CloseBrace(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBrace, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def TypeDef(self):
> >
> > + return self.getToken(VfrSyntaxParser.TypeDef, 0)
> >
> > +
> >
> > + def NonNvDataMap(self):
> >
> > + return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrDataStructDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrDataStructDefinition" ):
> >
> > + return visitor.visitVfrDataStructDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrDataStructDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrDataStructDefinitionContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 10, self.RULE_vfrDataStructDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 442
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.TypeDef:
> >
> > + self.state = 441
> >
> > + self.match(VfrSyntaxParser.TypeDef)
> >
> > +
> >
> > +
> >
> > + self.state = 444
> >
> > + self.match(VfrSyntaxParser.Struct)
> >
> > + self.state = 446
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.NonNvDataMap:
> >
> > + self.state = 445
> >
> > + self.match(VfrSyntaxParser.NonNvDataMap)
> >
> > +
> >
> > +
> >
> > + self.state = 449
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 448
> >
> > + localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 451
> >
> > + self.match(VfrSyntaxParser.OpenBrace)
> >
> > + self.state = 452
> >
> > + self.vfrDataStructFields(False)
> >
> > + self.state = 453
> >
> > + self.match(VfrSyntaxParser.CloseBrace)
> >
> > + self.state = 455
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 454
> >
> > + localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 457
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrDataUnionDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.N1 = None # Token
> >
> > + self.N2 = None # Token
> >
> > +
> >
> > + def Union(self):
> >
> > + return self.getToken(VfrSyntaxParser.Union, 0)
> >
> > +
> >
> > + def OpenBrace(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBrace, 0)
> >
> > +
> >
> > + def vfrDataStructFields(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrDataStructFieldsContext,0)
> >
> > +
> >
> > +
> >
> > + def CloseBrace(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBrace, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def TypeDef(self):
> >
> > + return self.getToken(VfrSyntaxParser.TypeDef, 0)
> >
> > +
> >
> > + def NonNvDataMap(self):
> >
> > + return self.getToken(VfrSyntaxParser.NonNvDataMap, 0)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrDataUnionDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrDataUnionDefinition" ):
> >
> > + return visitor.visitVfrDataUnionDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrDataUnionDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrDataUnionDefinitionContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 12, self.RULE_vfrDataUnionDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 460
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.TypeDef:
> >
> > + self.state = 459
> >
> > + self.match(VfrSyntaxParser.TypeDef)
> >
> > +
> >
> > +
> >
> > + self.state = 462
> >
> > + self.match(VfrSyntaxParser.Union)
> >
> > + self.state = 464
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.NonNvDataMap:
> >
> > + self.state = 463
> >
> > + self.match(VfrSyntaxParser.NonNvDataMap)
> >
> > +
> >
> > +
> >
> > + self.state = 467
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 466
> >
> > + localctx.N1 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 469
> >
> > + self.match(VfrSyntaxParser.OpenBrace)
> >
> > + self.state = 470
> >
> > + self.vfrDataStructFields(True)
> >
> > + self.state = 471
> >
> > + self.match(VfrSyntaxParser.CloseBrace)
> >
> > + self.state = 473
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 472
> >
> > + localctx.N2 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 475
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrDataStructFieldsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def dataStructField64(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructField64Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructField64Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructField32(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructField32Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructField32Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructField16(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructField16Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructField16Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructField8(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructField8Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructField8Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructFieldBool(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldBoolContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldBoolContext,i)
> >
> > +
> >
> > +
> >
> > + def dataStructFieldString(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldStringContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldStringContext,i)
> >
> > +
> >
> > +
> >
> > + def dataStructFieldDate(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldDateContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldDateContext,i)
> >
> > +
> >
> > +
> >
> > + def dataStructFieldTime(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldTimeContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldTimeContext,i)
> >
> > +
> >
> > +
> >
> > + def dataStructFieldRef(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldRefContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldRefContext,i)
> >
> > +
> >
> > +
> >
> > + def dataStructFieldUser(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructFieldUserContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructFieldUserContext,i)
> >
> > +
> >
> > +
> >
> > + def dataStructBitField64(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField64Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField64Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructBitField32(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField32Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField32Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructBitField16(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField16Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField16Context,i)
> >
> > +
> >
> > +
> >
> > + def dataStructBitField8(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DataStructBitField8Context)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DataStructBitField8Context,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrDataStructFields
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrDataStructFields" ):
> >
> > + return visitor.visitVfrDataStructFields(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrDataStructFields(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrDataStructFieldsContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 14, self.RULE_vfrDataStructFields)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 491
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 477
> >
> > + self.dataStructField64(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + self.state = 478
> >
> > + self.dataStructField32(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 3:
> >
> > + self.state = 479
> >
> > + self.dataStructField16(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 4:
> >
> > + self.state = 480
> >
> > + self.dataStructField8(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 5:
> >
> > + self.state = 481
> >
> > + self.dataStructFieldBool(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 6:
> >
> > + self.state = 482
> >
> > + self.dataStructFieldString(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 7:
> >
> > + self.state = 483
> >
> > + self.dataStructFieldDate(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 8:
> >
> > + self.state = 484
> >
> > + self.dataStructFieldTime(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 9:
> >
> > + self.state = 485
> >
> > + self.dataStructFieldRef(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 10:
> >
> > + self.state = 486
> >
> > + self.dataStructFieldUser(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 11:
> >
> > + self.state = 487
> >
> > + self.dataStructBitField64(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 12:
> >
> > + self.state = 488
> >
> > + self.dataStructBitField32(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 13:
> >
> > + self.state = 489
> >
> > + self.dataStructBitField16(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 14:
> >
> > + self.state = 490
> >
> > + self.dataStructBitField8(FieldInUnion)
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + self.state = 495
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructField64Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Uint64(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint64, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructField64
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructField64" ):
> >
> > + return visitor.visitDataStructField64(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructField64(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructField64Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 16, self.RULE_dataStructField64)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 496
> >
> > + self.match(VfrSyntaxParser.Uint64)
> >
> > + self.state = 497
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 501
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 498
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 499
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 500
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 503
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructField32Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Uint32(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint32, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructField32
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructField32" ):
> >
> > + return visitor.visitDataStructField32(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructField32(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructField32Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 18, self.RULE_dataStructField32)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 505
> >
> > + self.match(VfrSyntaxParser.Uint32)
> >
> > + self.state = 506
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 510
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 507
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 508
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 509
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 512
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructField16Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Uint16(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint16, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructField16
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructField16" ):
> >
> > + return visitor.visitDataStructField16(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructField16(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructField16Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 20, self.RULE_dataStructField16)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 514
> >
> > + self.match(VfrSyntaxParser.Uint16)
> >
> > + self.state = 515
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 519
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 516
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 517
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 518
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 521
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructField8Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Uint8(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint8, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructField8
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructField8" ):
> >
> > + return visitor.visitDataStructField8(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructField8(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructField8Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 22, self.RULE_dataStructField8)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 523
> >
> > + self.match(VfrSyntaxParser.Uint8)
> >
> > + self.state = 524
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 528
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 525
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 526
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 527
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 530
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructFieldBoolContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Boolean(self):
> >
> > + return self.getToken(VfrSyntaxParser.Boolean, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructFieldBool
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructFieldBool" ):
> >
> > + return visitor.visitDataStructFieldBool(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructFieldBool(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructFieldBoolContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 24, self.RULE_dataStructFieldBool)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 532
> >
> > + self.match(VfrSyntaxParser.Boolean)
> >
> > + self.state = 533
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 537
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 534
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 535
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 536
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 539
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructFieldStringContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def EFI_STRING_ID(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructFieldString
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructFieldString" ):
> >
> > + return visitor.visitDataStructFieldString(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructFieldString(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructFieldStringContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 26, self.RULE_dataStructFieldString)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 541
> >
> > + self.match(VfrSyntaxParser.EFI_STRING_ID)
> >
> > + self.state = 542
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 546
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 543
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 544
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 545
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 548
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructFieldDateContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def EFI_HII_DATE(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructFieldDate
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructFieldDate" ):
> >
> > + return visitor.visitDataStructFieldDate(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructFieldDate(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructFieldDateContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 28, self.RULE_dataStructFieldDate)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 550
> >
> > + self.match(VfrSyntaxParser.EFI_HII_DATE)
> >
> > + self.state = 551
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 555
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 552
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 553
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 554
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 557
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructFieldTimeContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def EFI_HII_TIME(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructFieldTime
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructFieldTime" ):
> >
> > + return visitor.visitDataStructFieldTime(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructFieldTime(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructFieldTimeContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 30, self.RULE_dataStructFieldTime)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 559
> >
> > + self.match(VfrSyntaxParser.EFI_HII_TIME)
> >
> > + self.state = 560
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 564
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 561
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 562
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 563
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 566
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructFieldRefContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def EFI_HII_REF(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructFieldRef
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructFieldRef" ):
> >
> > + return visitor.visitDataStructFieldRef(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructFieldRef(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructFieldRefContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 32, self.RULE_dataStructFieldRef)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 568
> >
> > + self.match(VfrSyntaxParser.EFI_HII_REF)
> >
> > + self.state = 569
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 573
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 570
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 571
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 572
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 575
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructFieldUserContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.T = None # Token
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructFieldUser
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructFieldUser" ):
> >
> > + return visitor.visitDataStructFieldUser(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructFieldUser(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructFieldUserContext(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 34, self.RULE_dataStructFieldUser)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 577
> >
> > + localctx.T = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 578
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 582
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 579
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 580
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 581
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 584
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructBitField64Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.D = None # Token
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Colon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Colon, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Uint64(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint64, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructBitField64
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructBitField64" ):
> >
> > + return visitor.visitDataStructBitField64(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructBitField64(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructBitField64Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 36, self.RULE_dataStructBitField64)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 586
> >
> > + localctx.D = self.match(VfrSyntaxParser.Uint64)
> >
> > + self.state = 588
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 587
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 590
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + self.state = 591
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 592
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructBitField32Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.D = None # Token
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Colon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Colon, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Uint32(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint32, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructBitField32
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructBitField32" ):
> >
> > + return visitor.visitDataStructBitField32(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructBitField32(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructBitField32Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 38, self.RULE_dataStructBitField32)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 594
> >
> > + localctx.D = self.match(VfrSyntaxParser.Uint32)
> >
> > + self.state = 596
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 595
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 598
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + self.state = 599
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 600
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructBitField16Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.D = None # Token
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Colon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Colon, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Uint16(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint16, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructBitField16
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructBitField16" ):
> >
> > + return visitor.visitDataStructBitField16(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructBitField16(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructBitField16Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 40, self.RULE_dataStructBitField16)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 602
> >
> > + localctx.D = self.match(VfrSyntaxParser.Uint16)
> >
> > + self.state = 604
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 603
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 606
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + self.state = 607
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 608
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DataStructBitField8Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, FieldInUnion=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.FieldInUnion = None
> >
> > + self.D = None # Token
> >
> > + self.N = None # Token
> >
> > + self.FieldInUnion = FieldInUnion
> >
> > +
> >
> > + def Colon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Colon, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Uint8(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint8, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dataStructBitField8
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDataStructBitField8" ):
> >
> > + return visitor.visitDataStructBitField8(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dataStructBitField8(self, FieldInUnion):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DataStructBitField8Context(self, self._ctx,
> > self.state, FieldInUnion)
> >
> > + self.enterRule(localctx, 42, self.RULE_dataStructBitField8)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 610
> >
> > + localctx.D = self.match(VfrSyntaxParser.Uint8)
> >
> > + self.state = 612
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.StringIdentifier:
> >
> > + self.state = 611
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > +
> >
> > +
> >
> > + self.state = 614
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + self.state = 615
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 616
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrFormSetDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_FORM_SET_OP)
> >
> > +
> >
> > + def FormSet(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormSet, 0)
> >
> > +
> >
> > + def Uuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Title(self):
> >
> > + return self.getToken(VfrSyntaxParser.Title, 0)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Help(self):
> >
> > + return self.getToken(VfrSyntaxParser.Help, 0)
> >
> > +
> >
> > + def vfrFormSetList(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
> >
> > +
> >
> > +
> >
> > + def EndFormSet(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndFormSet, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def ClassGuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassGuid, 0)
> >
> > +
> >
> > + def classguidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ClassguidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Class(self):
> >
> > + return self.getToken(VfrSyntaxParser.Class, 0)
> >
> > +
> >
> > + def classDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ClassDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Subclass(self):
> >
> > + return self.getToken(VfrSyntaxParser.Subclass, 0)
> >
> > +
> >
> > + def subclassDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.SubclassDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrFormSetDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrFormSetDefinition" ):
> >
> > + return visitor.visitVfrFormSetDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrFormSetDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrFormSetDefinitionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 44, self.RULE_vfrFormSetDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 618
> >
> > + self.match(VfrSyntaxParser.FormSet)
> >
> > + self.state = 619
> >
> > + self.match(VfrSyntaxParser.Uuid)
> >
> > + self.state = 620
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 621
> >
> > + self.guidDefinition()
> >
> > + self.state = 622
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 623
> >
> > + self.match(VfrSyntaxParser.Title)
> >
> > + self.state = 624
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 625
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 626
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 627
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 628
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 629
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 630
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 631
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 632
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 633
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 634
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 635
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 636
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 642
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.ClassGuid:
> >
> > + self.state = 637
> >
> > + self.match(VfrSyntaxParser.ClassGuid)
> >
> > + self.state = 638
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 639
> >
> > + self.classguidDefinition(localctx.Node)
> >
> > + self.state = 640
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 649
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Class:
> >
> > + self.state = 644
> >
> > + self.match(VfrSyntaxParser.Class)
> >
> > + self.state = 645
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 646
> >
> > + self.classDefinition()
> >
> > + self.state = 647
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 656
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Subclass:
> >
> > + self.state = 651
> >
> > + self.match(VfrSyntaxParser.Subclass)
> >
> > + self.state = 652
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 653
> >
> > + self.subclassDefinition()
> >
> > + self.state = 654
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 658
> >
> > + self.vfrFormSetList(localctx.Node)
> >
> > + self.state = 659
> >
> > + self.match(VfrSyntaxParser.EndFormSet)
> >
> > + self.state = 660
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ClassguidDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.GuidList = []
> >
> > + self.Node = Node
> >
> > +
> >
> > + def guidDefinition(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_classguidDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitClassguidDefinition" ):
> >
> > + return visitor.visitClassguidDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def classguidDefinition(self, Node):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ClassguidDefinitionContext(self, self._ctx,
> > self.state, Node)
> >
> > + self.enterRule(localctx, 46, self.RULE_classguidDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 662
> >
> > + self.guidDefinition()
> >
> > + self.state = 665
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 663
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 664
> >
> > + self.guidDefinition()
> >
> > +
> >
> > +
> >
> > + self.state = 669
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 667
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 668
> >
> > + self.guidDefinition()
> >
> > +
> >
> > +
> >
> > + self.state = 673
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 671
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 672
> >
> > + self.guidDefinition()
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ClassDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > +
> >
> > + def validClassNames(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.ValidClassNamesContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ValidClassNamesContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_classDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitClassDefinition" ):
> >
> > + return visitor.visitClassDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def classDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ClassDefinitionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 48, self.RULE_classDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 675
> >
> > + self.validClassNames()
> >
> > + self.state = 680
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 676
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 677
> >
> > + self.validClassNames()
> >
> > + self.state = 682
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ValidClassNamesContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ClassName = 0
> >
> > +
> >
> > + def ClassNonDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassNonDevice, 0)
> >
> > +
> >
> > + def ClassDiskDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassDiskDevice, 0)
> >
> > +
> >
> > + def ClassVideoDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassVideoDevice, 0)
> >
> > +
> >
> > + def ClassNetworkDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassNetworkDevice, 0)
> >
> > +
> >
> > + def ClassInputDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassInputDevice, 0)
> >
> > +
> >
> > + def ClassOnBoardDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassOnBoardDevice, 0)
> >
> > +
> >
> > + def ClassOtherDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.ClassOtherDevice, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_validClassNames
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitValidClassNames" ):
> >
> > + return visitor.visitValidClassNames(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def validClassNames(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ValidClassNamesContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 50, self.RULE_validClassNames)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class SubclassDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > +
> >
> > + def SubclassSetupApplication(self):
> >
> > + return self.getToken(VfrSyntaxParser.SubclassSetupApplication, 0)
> >
> > +
> >
> > + def SubclassGeneralApplication(self):
> >
> > + return self.getToken(VfrSyntaxParser.SubclassGeneralApplication, 0)
> >
> > +
> >
> > + def SubclassFrontPage(self):
> >
> > + return self.getToken(VfrSyntaxParser.SubclassFrontPage, 0)
> >
> > +
> >
> > + def SubclassSingleUse(self):
> >
> > + return self.getToken(VfrSyntaxParser.SubclassSingleUse, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_subclassDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitSubclassDefinition" ):
> >
> > + return visitor.visitSubclassDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def subclassDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.SubclassDefinitionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 52, self.RULE_subclassDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrFormSetListContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.Node = Node
> >
> > +
> >
> > + def vfrFormSet(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrFormSetContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrFormSetList
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrFormSetList" ):
> >
> > + return visitor.visitVfrFormSetList(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrFormSetList(self, Node):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrFormSetListContext(self, self._ctx,
> self.state,
> > Node)
> >
> > + self.enterRule(localctx, 54, self.RULE_vfrFormSetList)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 687
> >
> > + self.vfrFormSet()
> >
> > + self.state = 692
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrFormSetContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrFormDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrFormMapDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormMapDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementImage(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarStoreLinear(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreLinearContext
> > ,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarStoreEfi(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreEfiContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarStoreNameValue(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreNameValueCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementDefaultStore(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultStoreContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementDisableIfFormSet(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfFormSetCont
> > ext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfFormSet(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfFormSetCon
> > text,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementExtension(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrFormSet
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrFormSet" ):
> >
> > + return visitor.visitVfrFormSet(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrFormSet(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrFormSetContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 56, self.RULE_vfrFormSet)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 703
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Form]:
> >
> > + self.state = 693
> >
> > + self.vfrFormDefinition()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.FormMap]:
> >
> > + self.state = 694
> >
> > + self.vfrFormMapDefinition()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Image]:
> >
> > + self.state = 695
> >
> > + self.vfrStatementImage()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Varstore]:
> >
> > + self.state = 696
> >
> > + self.vfrStatementVarStoreLinear()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Efivarstore]:
> >
> > + self.state = 697
> >
> > + self.vfrStatementVarStoreEfi()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NameValueVarStore]:
> >
> > + self.state = 698
> >
> > + self.vfrStatementVarStoreNameValue()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DefaultStore]:
> >
> > + self.state = 699
> >
> > + self.vfrStatementDefaultStore()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DisableIf]:
> >
> > + self.state = 700
> >
> > + self.vfrStatementDisableIfFormSet()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.SuppressIf]:
> >
> > + self.state = 701
> >
> > + self.vfrStatementSuppressIfFormSet()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GuidOp]:
> >
> > + self.state = 702
> >
> > + self.vfrStatementExtension()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementDefaultStoreContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_DEFAULTSTORE_OP)
> >
> > + self.N = None # Token
> >
> > + self.S = None # Token
> >
> > + self.A = None # Token
> >
> > +
> >
> > + def DefaultStore(self):
> >
> > + return self.getToken(VfrSyntaxParser.DefaultStore, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Attribute(self):
> >
> > + return self.getToken(VfrSyntaxParser.Attribute, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementDefaultStore
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementDefaultStore" ):
> >
> > + return visitor.visitVfrStatementDefaultStore(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementDefaultStore(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementDefaultStoreContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 58, self.RULE_vfrStatementDefaultStore)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 705
> >
> > + self.match(VfrSyntaxParser.DefaultStore)
> >
> > + self.state = 706
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 707
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 708
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 709
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 710
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 711
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 712
> >
> > + localctx.S = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 713
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 718
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 714
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 715
> >
> > + self.match(VfrSyntaxParser.Attribute)
> >
> > + self.state = 716
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 717
> >
> > + localctx.A = self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + self.state = 720
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementVarStoreLinearContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_OP)
> >
> > + self.TN = None # Token
> >
> > + self.ID = None # Token
> >
> > + self.SN = None # Token
> >
> > +
> >
> > + def Varstore(self):
> >
> > + return self.getToken(VfrSyntaxParser.Varstore, 0)
> >
> > +
> >
> > + def Name(self):
> >
> > + return self.getToken(VfrSyntaxParser.Name, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Uuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def Uint8(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint8, 0)
> >
> > +
> >
> > + def Uint16(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint16, 0)
> >
> > +
> >
> > + def Uint32(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint32, 0)
> >
> > +
> >
> > + def Uint64(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint64, 0)
> >
> > +
> >
> > + def EFI_HII_DATE(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
> >
> > +
> >
> > + def EFI_HII_TIME(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
> >
> > +
> >
> > + def EFI_HII_REF(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
> >
> > +
> >
> > + def VarId(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarId, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementVarStoreLinear
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementVarStoreLinear" ):
> >
> > + return visitor.visitVfrStatementVarStoreLinear(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarStoreLinear(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementVarStoreLinearContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 60, self.RULE_vfrStatementVarStoreLinear)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 722
> >
> > + self.match(VfrSyntaxParser.Varstore)
> >
> > + self.state = 739
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.StringIdentifier]:
> >
> > + self.state = 723
> >
> > + localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 724
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint8]:
> >
> > + self.state = 725
> >
> > + self.match(VfrSyntaxParser.Uint8)
> >
> > + self.state = 726
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint16]:
> >
> > + self.state = 727
> >
> > + self.match(VfrSyntaxParser.Uint16)
> >
> > + self.state = 728
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint32]:
> >
> > + self.state = 729
> >
> > + self.match(VfrSyntaxParser.Uint32)
> >
> > + self.state = 730
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint64]:
> >
> > + self.state = 731
> >
> > + self.match(VfrSyntaxParser.Uint64)
> >
> > + self.state = 732
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_DATE]:
> >
> > + self.state = 733
> >
> > + self.match(VfrSyntaxParser.EFI_HII_DATE)
> >
> > + self.state = 734
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_TIME]:
> >
> > + self.state = 735
> >
> > + self.match(VfrSyntaxParser.EFI_HII_TIME)
> >
> > + self.state = 736
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_REF]:
> >
> > + self.state = 737
> >
> > + self.match(VfrSyntaxParser.EFI_HII_REF)
> >
> > + self.state = 738
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 745
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.VarId:
> >
> > + self.state = 741
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 742
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 743
> >
> > + localctx.ID = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 744
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 747
> >
> > + self.match(VfrSyntaxParser.Name)
> >
> > + self.state = 748
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 749
> >
> > + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 750
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 751
> >
> > + self.match(VfrSyntaxParser.Uuid)
> >
> > + self.state = 752
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 753
> >
> > + self.guidDefinition()
> >
> > + self.state = 754
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementVarStoreEfiContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_EFI_OP)
> >
> > + self.TN = None # Token
> >
> > + self.ID = None # Token
> >
> > + self.SN = None # Token
> >
> > + self.VN = None # Token
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Efivarstore(self):
> >
> > + return self.getToken(VfrSyntaxParser.Efivarstore, 0)
> >
> > +
> >
> > + def Attribute(self):
> >
> > + return self.getToken(VfrSyntaxParser.Attribute, 0)
> >
> > +
> >
> > + def vfrVarStoreEfiAttr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrVarStoreEfiAttrContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrVarStoreEfiAttrContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Uuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Uint8(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint8, 0)
> >
> > +
> >
> > + def Uint16(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint16, 0)
> >
> > +
> >
> > + def Uint32(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint32, 0)
> >
> > +
> >
> > + def Uint64(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint64, 0)
> >
> > +
> >
> > + def EFI_HII_DATE(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
> >
> > +
> >
> > + def EFI_HII_TIME(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
> >
> > +
> >
> > + def EFI_HII_REF(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
> >
> > +
> >
> > + def Name(self):
> >
> > + return self.getToken(VfrSyntaxParser.Name, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def VarSize(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarSize, 0)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def VarId(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarId, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementVarStoreEfi
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementVarStoreEfi" ):
> >
> > + return visitor.visitVfrStatementVarStoreEfi(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarStoreEfi(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementVarStoreEfiContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 62, self.RULE_vfrStatementVarStoreEfi)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 756
> >
> > + self.match(VfrSyntaxParser.Efivarstore)
> >
> > + self.state = 773
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.StringIdentifier]:
> >
> > + self.state = 757
> >
> > + localctx.TN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 758
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint8]:
> >
> > + self.state = 759
> >
> > + self.match(VfrSyntaxParser.Uint8)
> >
> > + self.state = 760
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint16]:
> >
> > + self.state = 761
> >
> > + self.match(VfrSyntaxParser.Uint16)
> >
> > + self.state = 762
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint32]:
> >
> > + self.state = 763
> >
> > + self.match(VfrSyntaxParser.Uint32)
> >
> > + self.state = 764
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint64]:
> >
> > + self.state = 765
> >
> > + self.match(VfrSyntaxParser.Uint64)
> >
> > + self.state = 766
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_DATE]:
> >
> > + self.state = 767
> >
> > + self.match(VfrSyntaxParser.EFI_HII_DATE)
> >
> > + self.state = 768
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_TIME]:
> >
> > + self.state = 769
> >
> > + self.match(VfrSyntaxParser.EFI_HII_TIME)
> >
> > + self.state = 770
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_REF]:
> >
> > + self.state = 771
> >
> > + self.match(VfrSyntaxParser.EFI_HII_REF)
> >
> > + self.state = 772
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 779
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.VarId:
> >
> > + self.state = 775
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 776
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 777
> >
> > + localctx.ID = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 778
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 781
> >
> > + self.match(VfrSyntaxParser.Attribute)
> >
> > + self.state = 782
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 783
> >
> > + self.vfrVarStoreEfiAttr()
> >
> > + self.state = 788
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 784
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 785
> >
> > + self.vfrVarStoreEfiAttr()
> >
> > + self.state = 790
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 791
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 807
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 792
> >
> > + self.match(VfrSyntaxParser.Name)
> >
> > + self.state = 793
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 794
> >
> > + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 795
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + self.state = 796
> >
> > + self.match(VfrSyntaxParser.Name)
> >
> > + self.state = 797
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 798
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 799
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 800
> >
> > + localctx.VN = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 801
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 802
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 803
> >
> > + self.match(VfrSyntaxParser.VarSize)
> >
> > + self.state = 804
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 805
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 806
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + self.state = 809
> >
> > + self.match(VfrSyntaxParser.Uuid)
> >
> > + self.state = 810
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 811
> >
> > + self.guidDefinition()
> >
> > + self.state = 812
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrVarStoreEfiAttrContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Attr = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrVarStoreEfiAttr
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrVarStoreEfiAttr" ):
> >
> > + return visitor.visitVfrVarStoreEfiAttr(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrVarStoreEfiAttr(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrVarStoreEfiAttrContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 64, self.RULE_vfrVarStoreEfiAttr)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 814
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementVarStoreNameValueContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_NAME_VALUE_OP)
> >
> > + self.SN = None # Token
> >
> > + self.ID = None # Token
> >
> > +
> >
> > + def NameValueVarStore(self):
> >
> > + return self.getToken(VfrSyntaxParser.NameValueVarStore, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Uuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def VarId(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarId, 0)
> >
> > +
> >
> > + def Name(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Name)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Name, i)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementVarStoreNameValue
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementVarStoreNameValue" ):
> >
> > + return visitor.visitVfrStatementVarStoreNameValue(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarStoreNameValue(self):
> >
> > +
> >
> > + localctx =
> VfrSyntaxParser.VfrStatementVarStoreNameValueContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 66,
> self.RULE_vfrStatementVarStoreNameValue)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 816
> >
> > + self.match(VfrSyntaxParser.NameValueVarStore)
> >
> > + self.state = 817
> >
> > + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 818
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 823
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.VarId:
> >
> > + self.state = 819
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 820
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 821
> >
> > + localctx.ID = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 822
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 832
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while True:
> >
> > + self.state = 825
> >
> > + self.match(VfrSyntaxParser.Name)
> >
> > + self.state = 826
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 827
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 828
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 829
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 830
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + 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 = 836
> >
> > + self.match(VfrSyntaxParser.Uuid)
> >
> > + self.state = 837
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 838
> >
> > + self.guidDefinition()
> >
> > + self.state = 839
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementDisableIfFormSetContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
> >
> > +
> >
> > + def DisableIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.DisableIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def vfrFormSetList(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementDisableIfFormSet
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementDisableIfFormSet" ):
> >
> > + return visitor.visitVfrStatementDisableIfFormSet(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementDisableIfFormSet(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementDisableIfFormSetContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 68, self.RULE_vfrStatementDisableIfFormSet)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 841
> >
> > + self.match(VfrSyntaxParser.DisableIf)
> >
> > + self.state = 842
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 843
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 844
> >
> > + self.vfrFormSetList(localctx.Node)
> >
> > + self.state = 845
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 846
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementSuppressIfFormSetContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
> >
> > +
> >
> > + def SuppressIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def vfrFormSetList(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrFormSetListContext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementSuppressIfFormSet
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementSuppressIfFormSet" ):
> >
> > + return visitor.visitVfrStatementSuppressIfFormSet(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfFormSet(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementSuppressIfFormSetContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 70, self.RULE_vfrStatementSuppressIfFormSet)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 848
> >
> > + self.match(VfrSyntaxParser.SuppressIf)
> >
> > + self.state = 849
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 850
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 851
> >
> > + self.vfrFormSetList(localctx.Node)
> >
> > + self.state = 852
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 853
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class GuidSubDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Guid=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Guid = None
> >
> > + self.Guid = Guid
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_guidSubDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitGuidSubDefinition" ):
> >
> > + return visitor.visitGuidSubDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def guidSubDefinition(self, Guid):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.GuidSubDefinitionContext(self, self._ctx,
> > self.state, Guid)
> >
> > + self.enterRule(localctx, 72, self.RULE_guidSubDefinition)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 855
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 856
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 857
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 858
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 859
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 860
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 861
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 862
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 863
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 864
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 865
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 866
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 867
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 868
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 869
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class GuidDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode()
> >
> > + self.Guid = EFI_GUID()
> >
> > +
> >
> > + def OpenBrace(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenBrace)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenBrace, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def CloseBrace(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseBrace)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseBrace, i)
> >
> > +
> >
> > + def guidSubDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidSubDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_guidDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitGuidDefinition" ):
> >
> > + return visitor.visitGuidDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.GuidDefinitionContext(self, self._ctx,
> self.state)
> >
> > + self.enterRule(localctx, 74, self.RULE_guidDefinition)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 871
> >
> > + self.match(VfrSyntaxParser.OpenBrace)
> >
> > + self.state = 872
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 873
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 874
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 875
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 876
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 877
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 883
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.OpenBrace]:
> >
> > + self.state = 878
> >
> > + self.match(VfrSyntaxParser.OpenBrace)
> >
> > + self.state = 879
> >
> > + self.guidSubDefinition(localctx.Guid)
> >
> > + self.state = 880
> >
> > + self.match(VfrSyntaxParser.CloseBrace)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Number]:
> >
> > + self.state = 882
> >
> > + self.guidSubDefinition(localctx.Guid)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 885
> >
> > + self.match(VfrSyntaxParser.CloseBrace)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class GetStringIdContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.StringId = ''
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_getStringId
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitGetStringId" ):
> >
> > + return visitor.visitGetStringId(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def getStringId(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.GetStringIdContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 76, self.RULE_getStringId)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 887
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 888
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 889
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 890
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrQuestionHeaderContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None, QType=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.QType = None
> >
> > + self.Node = Node
> >
> > + self.QType = QType
> >
> > +
> >
> > + def vfrQuestionBaseInfo(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrQuestionHeader
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrQuestionHeader" ):
> >
> > + return visitor.visitVfrQuestionHeader(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrQuestionHeader(self, Node, 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 = 892
> >
> > + self.vfrQuestionBaseInfo(Node, QType)
> >
> > + self.state = 893
> >
> > + self.vfrStatementHeader(Node)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrQuestionBaseInfoContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None, QType=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + 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.Node = Node
> >
> > + self.QType = QType
> >
> > +
> >
> > + def Name(self):
> >
> > + return self.getToken(VfrSyntaxParser.Name, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def VarId(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarId, 0)
> >
> > +
> >
> > + def vfrStorageVarId(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
> >
> > +
> >
> > +
> >
> > + def QuestionId(self):
> >
> > + return self.getToken(VfrSyntaxParser.QuestionId, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrQuestionBaseInfo
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrQuestionBaseInfo" ):
> >
> > + return visitor.visitVfrQuestionBaseInfo(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrQuestionBaseInfo(self, Node, 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 = 899
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Name:
> >
> > + self.state = 895
> >
> > + self.match(VfrSyntaxParser.Name)
> >
> > + self.state = 896
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 897
> >
> > + localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 898
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 906
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.VarId:
> >
> > + self.state = 901
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 902
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 903
> >
> > + self.vfrStorageVarId(localctx.BaseInfo, localctx.CheckFlag)
> >
> > + self.state = 904
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 912
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.QuestionId:
> >
> > + self.state = 908
> >
> > + self.match(VfrSyntaxParser.QuestionId)
> >
> > + self.state = 909
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 910
> >
> > + localctx.ID = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 911
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementHeaderContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.Node = Node
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def Help(self):
> >
> > + return self.getToken(VfrSyntaxParser.Help, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementHeader
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementHeader" ):
> >
> > + return visitor.visitVfrStatementHeader(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementHeader(self, Node):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementHeaderContext(self, self._ctx,
> > self.state, Node)
> >
> > + self.enterRule(localctx, 82, self.RULE_vfrStatementHeader)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 914
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 915
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 916
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 917
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 918
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 919
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 920
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 921
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 922
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 923
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 924
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 925
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 926
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class QuestionheaderFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.QHFlag = 0
> >
> > + self.O = None # Token
> >
> > + self.N = None # Token
> >
> > + self.L = None # Token
> >
> > +
> >
> > + def ReadOnlyFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ReadOnlyFlag, 0)
> >
> > +
> >
> > + def InteractiveFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
> >
> > +
> >
> > + def ResetRequiredFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
> >
> > +
> >
> > + def RestStyleFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
> >
> > +
> >
> > + def ReconnectRequiredFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
> >
> > +
> >
> > + def OptionOnlyFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.OptionOnlyFlag, 0)
> >
> > +
> >
> > + def NVAccessFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
> >
> > +
> >
> > + def LateCheckFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_questionheaderFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitQuestionheaderFlagsField" ):
> >
> > + return visitor.visitQuestionheaderFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.QuestionheaderFlagsFieldContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 84, self.RULE_questionheaderFlagsField)
> >
> > + try:
> >
> > + self.state = 936
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.ReadOnlyFlag]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 928
> >
> > + self.match(VfrSyntaxParser.ReadOnlyFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.InteractiveFlag]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 929
> >
> > + self.match(VfrSyntaxParser.InteractiveFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ResetRequiredFlag]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 930
> >
> > + self.match(VfrSyntaxParser.ResetRequiredFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.RestStyleFlag]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 931
> >
> > + self.match(VfrSyntaxParser.RestStyleFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 932
> >
> > + self.match(VfrSyntaxParser.ReconnectRequiredFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OptionOnlyFlag]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 933
> >
> > + localctx.O = self.match(VfrSyntaxParser.OptionOnlyFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NVAccessFlag]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 934
> >
> > + localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LateCheckFlag]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 935
> >
> > + localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStorageVarIdContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, BaseInfo=None, CheckFlag=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.BaseInfo = None
> >
> > + self.CheckFlag = None
> >
> > + self.VarIdStr = ''
> >
> > + self.BaseInfo = BaseInfo
> >
> > + self.CheckFlag = CheckFlag
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStorageVarId
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.BaseInfo = ctx.BaseInfo
> >
> > + self.CheckFlag = ctx.CheckFlag
> >
> > + self.VarIdStr = ctx.VarIdStr
> >
> > +
> >
> > +
> >
> > +
> >
> > + class VfrStorageVarIdRule1Context(VfrStorageVarIdContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.VfrStorageVarIdContext
> >
> > + super().__init__(parser)
> >
> > + self.SN1 = None # Token
> >
> > + self.I = None # Token
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStorageVarIdRule1" ):
> >
> > + return visitor.visitVfrStorageVarIdRule1(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class VfrStorageVarIdRule2Context(VfrStorageVarIdContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.VfrStorageVarIdContext
> >
> > + super().__init__(parser)
> >
> > + self.SN2 = None # Token
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > + def Dot(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Dot)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Dot, i)
> >
> > + def arrayName(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStorageVarIdRule2" ):
> >
> > + return visitor.visitVfrStorageVarIdRule2(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStorageVarId(self, BaseInfo, CheckFlag):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStorageVarIdContext(self, self._ctx,
> > self.state, BaseInfo, CheckFlag)
> >
> > + self.enterRule(localctx, 86, self.RULE_vfrStorageVarId)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.state = 950
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
> >
> > + if la_ == 1:
> >
> > + localctx = VfrSyntaxParser.VfrStorageVarIdRule1Context(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 938
> >
> > + localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 939
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 940
> >
> > + localctx.I = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 941
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + localctx = VfrSyntaxParser.VfrStorageVarIdRule2Context(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 942
> >
> > + localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 947
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.Dot:
> >
> > + self.state = 943
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 944
> >
> > + self.arrayName()
> >
> > + self.state = 949
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrConstantValueFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ValueList = []
> >
> > + self.ListType = False
> >
> > + self.ValueType = None
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Negative(self):
> >
> > + return self.getToken(VfrSyntaxParser.Negative, 0)
> >
> > +
> >
> > + def TrueSymbol(self):
> >
> > + return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
> >
> > +
> >
> > + def FalseSymbol(self):
> >
> > + return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
> >
> > +
> >
> > + def One(self):
> >
> > + return self.getToken(VfrSyntaxParser.One, 0)
> >
> > +
> >
> > + def Ones(self):
> >
> > + return self.getToken(VfrSyntaxParser.Ones, 0)
> >
> > +
> >
> > + def Zero(self):
> >
> > + return self.getToken(VfrSyntaxParser.Zero, 0)
> >
> > +
> >
> > + def Colon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Colon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Colon, i)
> >
> > +
> >
> > + def Slash(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Slash)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Slash, i)
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def OpenBrace(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBrace, 0)
> >
> > +
> >
> > + def CloseBrace(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBrace, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrConstantValueField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrConstantValueField" ):
> >
> > + return visitor.visitVfrConstantValueField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrConstantValueField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrConstantValueFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 88, self.RULE_vfrConstantValueField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.state = 996
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 953
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Negative:
> >
> > + self.state = 952
> >
> > + self.match(VfrSyntaxParser.Negative)
> >
> > +
> >
> > +
> >
> > + self.state = 955
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 956
> >
> > + self.match(VfrSyntaxParser.TrueSymbol)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 3:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 957
> >
> > + self.match(VfrSyntaxParser.FalseSymbol)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 4:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 958
> >
> > + self.match(VfrSyntaxParser.One)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 5:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 959
> >
> > + self.match(VfrSyntaxParser.Ones)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 6:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 960
> >
> > + self.match(VfrSyntaxParser.Zero)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 7:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 961
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 962
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + self.state = 963
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 964
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + self.state = 965
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 8:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 966
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 967
> >
> > + self.match(VfrSyntaxParser.Slash)
> >
> > + self.state = 968
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 969
> >
> > + self.match(VfrSyntaxParser.Slash)
> >
> > + self.state = 970
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 9:
> >
> > + self.enterOuterAlt(localctx, 9)
> >
> > + self.state = 971
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 972
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 973
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 974
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 975
> >
> > + self.guidDefinition()
> >
> > + self.state = 976
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 977
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 978
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 979
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 980
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 10:
> >
> > + self.enterOuterAlt(localctx, 10)
> >
> > + self.state = 982
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 983
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 984
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 985
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 11:
> >
> > + self.enterOuterAlt(localctx, 11)
> >
> > + self.state = 986
> >
> > + self.match(VfrSyntaxParser.OpenBrace)
> >
> > + self.state = 987
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 992
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 988
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 989
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 994
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 995
> >
> > + self.match(VfrSyntaxParser.CloseBrace)
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrImageTagContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_IMAGE_OP)
> >
> > +
> >
> > + def Image(self):
> >
> > + return self.getToken(VfrSyntaxParser.Image, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrImageTag
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrImageTag" ):
> >
> > + return visitor.visitVfrImageTag(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrImageTag(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrImageTagContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 90, self.RULE_vfrImageTag)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 998
> >
> > + self.match(VfrSyntaxParser.Image)
> >
> > + self.state = 999
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1000
> >
> > + self.match(VfrSyntaxParser.T__6)
> >
> > + self.state = 1001
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1002
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1003
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrLockedTagContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_LOCKED_OP)
> >
> > +
> >
> > + def Locked(self):
> >
> > + return self.getToken(VfrSyntaxParser.Locked, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrLockedTag
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrLockedTag" ):
> >
> > + return visitor.visitVfrLockedTag(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrLockedTag(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrLockedTagContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 92, self.RULE_vfrLockedTag)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1005
> >
> > + self.match(VfrSyntaxParser.Locked)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStatTagContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrImageTag(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrLockedTag(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStatTag
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStatTag" ):
> >
> > + return visitor.visitVfrStatementStatTag(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStatTag(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStatTagContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 94, self.RULE_vfrStatementStatTag)
> >
> > + try:
> >
> > + self.state = 1009
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Image]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1007
> >
> > + self.vfrImageTag()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Locked]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1008
> >
> > + self.vfrLockedTag()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStatTagListContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.Node = Node
> >
> > +
> >
> > + def vfrStatementStatTag(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatTagContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStatTagList
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStatTagList" ):
> >
> > + return visitor.visitVfrStatementStatTagList(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStatTagList(self, Node):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStatTagListContext(self,
> self._ctx,
> > self.state, Node)
> >
> > + self.enterRule(localctx, 96, self.RULE_vfrStatementStatTagList)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1011
> >
> > + self.vfrStatementStatTag()
> >
> > + self.state = 1016
> >
> > + self._errHandler.sync(self)
> >
> > + _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
> >
> > + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
> >
> > + if _alt==1:
> >
> > + self.state = 1012
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1013
> >
> > + self.vfrStatementStatTag()
> >
> > + self.state = 1018
> >
> > + self._errHandler.sync(self)
> >
> > + _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrFormDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_FORM_OP)
> >
> > +
> >
> > + def Form(self):
> >
> > + return self.getToken(VfrSyntaxParser.Form, 0)
> >
> > +
> >
> > + def FormId(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormId, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def Title(self):
> >
> > + return self.getToken(VfrSyntaxParser.Title, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def EndForm(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndForm, 0)
> >
> > +
> >
> > + def vfrForm(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
> >
> > + else:
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrFormDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrFormDefinition" ):
> >
> > + return visitor.visitVfrFormDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrFormDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrFormDefinitionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 98, self.RULE_vfrFormDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1019
> >
> > + self.match(VfrSyntaxParser.Form)
> >
> > + self.state = 1020
> >
> > + self.match(VfrSyntaxParser.FormId)
> >
> > + self.state = 1021
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1022
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1023
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1024
> >
> > + self.match(VfrSyntaxParser.Title)
> >
> > + self.state = 1025
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1026
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1027
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1028
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1029
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1030
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + 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 = 1031
> >
> > + self.vfrForm()
> >
> > + self.state = 1036
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1037
> >
> > + self.match(VfrSyntaxParser.EndForm)
> >
> > + self.state = 1038
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrFormContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementImage(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementImageContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementLocked(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLockedContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementRules(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRulesContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementDefault(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementStat(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestions(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementConditional(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementLabel(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementBanner(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBannerContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalid(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementExtension(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementModal(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementModalContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementRefreshEvent(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrForm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrForm" ):
> >
> > + return visitor.visitVfrForm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrForm(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrFormContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 100, self.RULE_vfrForm)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1055
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Image]:
> >
> > + self.state = 1040
> >
> > + self.vfrStatementImage()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Locked]:
> >
> > + self.state = 1041
> >
> > + self.vfrStatementLocked()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Rule]:
> >
> > + self.state = 1042
> >
> > + self.vfrStatementRules()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Default]:
> >
> > + self.state = 1043
> >
> > + self.vfrStatementDefault()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Subtitle, VfrSyntaxParser.Text,
> > VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
> >
> > + 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 = 1045
> >
> > + self.vfrStatementQuestions()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf,
> > VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
> >
> > + self.state = 1046
> >
> > + self.vfrStatementConditional()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Label]:
> >
> > + self.state = 1047
> >
> > + self.vfrStatementLabel()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Banner]:
> >
> > + self.state = 1048
> >
> > + self.vfrStatementBanner()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> > VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
> >
> > + self.state = 1049
> >
> > + self.vfrStatementInvalid()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GuidOp]:
> >
> > + self.state = 1050
> >
> > + self.vfrStatementExtension()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Modal]:
> >
> > + self.state = 1051
> >
> > + self.vfrStatementModal()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.RefreshGuid]:
> >
> > + self.state = 1052
> >
> > + self.vfrStatementRefreshEvent()
> >
> > + self.state = 1053
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrFormMapDefinitionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_FORM_MAP_OP)
> >
> > + self.S1 = None # Token
> >
> > +
> >
> > + def FormMap(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormMap, 0)
> >
> > +
> >
> > + def FormId(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormId, 0)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def EndForm(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndForm, 0)
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def MapTitle(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.MapTitle)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.MapTitle, i)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def MapGuid(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.MapGuid)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.MapGuid, i)
> >
> > +
> >
> > + def guidDefinition(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.GuidDefinitionContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,i)
> >
> > +
> >
> > +
> >
> > + def vfrForm(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> self.getTypedRuleContexts(VfrSyntaxParser.VfrFormContext)
> >
> > + else:
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrFormContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrFormMapDefinition
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrFormMapDefinition" ):
> >
> > + return visitor.visitVfrFormMapDefinition(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrFormMapDefinition(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrFormMapDefinitionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 102, self.RULE_vfrFormMapDefinition)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1057
> >
> > + self.match(VfrSyntaxParser.FormMap)
> >
> > + self.state = 1058
> >
> > + self.match(VfrSyntaxParser.FormId)
> >
> > + self.state = 1059
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1060
> >
> > + localctx.S1 = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1061
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1076
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.MapTitle:
> >
> > + self.state = 1062
> >
> > + self.match(VfrSyntaxParser.MapTitle)
> >
> > + self.state = 1063
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1064
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1065
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1066
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1067
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1068
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 1069
> >
> > + self.match(VfrSyntaxParser.MapGuid)
> >
> > + self.state = 1070
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1071
> >
> > + self.guidDefinition()
> >
> > + self.state = 1072
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 1078
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + 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 = 1079
> >
> > + self.vfrForm()
> >
> > + self.state = 1084
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1085
> >
> > + self.match(VfrSyntaxParser.EndForm)
> >
> > + self.state = 1086
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementImageContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrImageTag(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementImage
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementImage" ):
> >
> > + return visitor.visitVfrStatementImage(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementImage(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementImageContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 104, self.RULE_vfrStatementImage)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1088
> >
> > + self.vfrImageTag()
> >
> > + self.state = 1089
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementLockedContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrLockedTag(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrLockedTagContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementLocked
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementLocked" ):
> >
> > + return visitor.visitVfrStatementLocked(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementLocked(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementLockedContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 106, self.RULE_vfrStatementLocked)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1091
> >
> > + self.vfrLockedTag()
> >
> > + self.state = 1092
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementRulesContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_RULE_OP)
> >
> > +
> >
> > + def Rule(self):
> >
> > + return self.getToken(VfrSyntaxParser.Rule, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def EndRule(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndRule, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementRules
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementRules" ):
> >
> > + return visitor.visitVfrStatementRules(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementRules(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementRulesContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 108, self.RULE_vfrStatementRules)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1094
> >
> > + self.match(VfrSyntaxParser.Rule)
> >
> > + self.state = 1095
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1096
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1097
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 1098
> >
> > + self.match(VfrSyntaxParser.EndRule)
> >
> > + self.state = 1099
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStatContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementSubTitle(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementStaticText(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStaticTextContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementCrossReference(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCrossReferenceContex
> > t,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStat
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStat" ):
> >
> > + return visitor.visitVfrStatementStat(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStat(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStatContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 110, self.RULE_vfrStatementStat)
> >
> > + try:
> >
> > + self.state = 1104
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Subtitle]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1101
> >
> > + self.vfrStatementSubTitle()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Text]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1102
> >
> > + self.vfrStatementStaticText()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Goto, VfrSyntaxParser.ResetButton]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1103
> >
> > + self.vfrStatementCrossReference()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementSubTitleContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_SUBTITLE_OP)
> >
> > +
> >
> > + def Subtitle(self):
> >
> > + return self.getToken(VfrSyntaxParser.Subtitle, 0)
> >
> > +
> >
> > + def Text(self):
> >
> > + return self.getToken(VfrSyntaxParser.Text, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def EndSubtitle(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndSubtitle, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def vfrSubtitleFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrSubtitleFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementStatTagList(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementSubTitleComponent(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementSubTitleComponentC
> > ontext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleComponentCo
> > ntext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementSubTitle
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementSubTitle" ):
> >
> > + return visitor.visitVfrStatementSubTitle(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementSubTitle(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementSubTitleContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 112, self.RULE_vfrStatementSubTitle)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1106
> >
> > + self.match(VfrSyntaxParser.Subtitle)
> >
> > + self.state = 1107
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 1108
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1109
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1110
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1111
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1112
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1117
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1113
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1114
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1115
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1116
> >
> > + self.vfrSubtitleFlags()
> >
> > +
> >
> > +
> >
> > + self.state = 1139
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1121
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 1119
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1120
> >
> > + self.vfrStatementStatTagList(localctx.Node)
> >
> > +
> >
> > +
> >
> > + self.state = 1123
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + self.state = 1126
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1124
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1125
> >
> > + self.vfrStatementStatTagList(localctx.Node)
> >
> > +
> >
> > +
> >
> > + self.state = 1135
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 1128
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + 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 = 1129
> >
> > + self.vfrStatementSubTitleComponent()
> >
> > + self.state = 1134
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > +
> >
> > +
> >
> > + self.state = 1137
> >
> > + self.match(VfrSyntaxParser.EndSubtitle)
> >
> > + self.state = 1138
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementSubTitleComponentContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementStat(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestions(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementSubTitleComponent
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementSubTitleComponent" ):
> >
> > + return visitor.visitVfrStatementSubTitleComponent(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementSubTitleComponent(self):
> >
> > +
> >
> > + localctx =
> VfrSyntaxParser.VfrStatementSubTitleComponentContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 114,
> self.RULE_vfrStatementSubTitleComponent)
> >
> > + try:
> >
> > + self.state = 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 = 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 = 1142
> >
> > + self.vfrStatementQuestions()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrSubtitleFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.SubFlags = 0
> >
> > +
> >
> > + def subtitleFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.SubtitleFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.SubtitleFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrSubtitleFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrSubtitleFlags" ):
> >
> > + return visitor.visitVfrSubtitleFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrSubtitleFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrSubtitleFlagsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 116, self.RULE_vfrSubtitleFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1145
> >
> > + self.subtitleFlagsField()
> >
> > + self.state = 1150
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1146
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1147
> >
> > + self.subtitleFlagsField()
> >
> > + self.state = 1152
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class SubtitleFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Flag = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_subtitleFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitSubtitleFlagsField" ):
> >
> > + return visitor.visitSubtitleFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def subtitleFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.SubtitleFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 118, self.RULE_subtitleFlagsField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1153
> >
> > + _la = self._input.LA(1)
> >
> > + if not(_la==VfrSyntaxParser.T__7 or _la==VfrSyntaxParser.Number):
> >
> > + self._errHandler.recoverInline(self)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStaticTextContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_TEXT_OP)
> >
> > + self.S1 = None # Token
> >
> > + self.S2 = None # Token
> >
> > + self.S3 = None # Token
> >
> > + self.F = None # Token
> >
> > + self.S4 = None # Token
> >
> > +
> >
> > + def Text(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Text)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Text, i)
> >
> > +
> >
> > + def Help(self):
> >
> > + return self.getToken(VfrSyntaxParser.Help, 0)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def staticTextFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.StaticTextFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.StaticTextFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def vfrStatementStatTagList(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
> >
> > +
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStaticText
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStaticText" ):
> >
> > + return visitor.visitVfrStatementStaticText(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStaticText(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStaticTextContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 120, self.RULE_vfrStatementStaticText)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1155
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 1156
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 1157
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1158
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1159
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1160
> >
> > + localctx.S1 = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1161
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1162
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1163
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 1164
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1165
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1166
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1167
> >
> > + localctx.S2 = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1168
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1176
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1169
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1170
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 1171
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1172
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1173
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1174
> >
> > + localctx.S3 = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1175
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > +
> >
> > +
> >
> > + self.state = 1194
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1178
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1179
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1180
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1181
> >
> > + self.staticTextFlagsField()
> >
> > + self.state = 1186
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1182
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1183
> >
> > + self.staticTextFlagsField()
> >
> > + self.state = 1188
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1189
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1190
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1191
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1192
> >
> > + localctx.S4 = self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + self.state = 1198
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 1196
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1197
> >
> > + self.vfrStatementStatTagList(localctx.Node)
> >
> > +
> >
> > +
> >
> > + self.state = 1200
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class StaticTextFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Flag = 0
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_staticTextFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitStaticTextFlagsField" ):
> >
> > + return visitor.visitStaticTextFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def staticTextFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.StaticTextFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 122, self.RULE_staticTextFlagsField)
> >
> > + try:
> >
> > + self.state = 1204
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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 = 1203
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementCrossReferenceContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementGoto(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGotoContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementResetButton(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementResetButtonContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementCrossReference
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementCrossReference" ):
> >
> > + return visitor.visitVfrStatementCrossReference(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementCrossReference(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementCrossReferenceContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 124, self.RULE_vfrStatementCrossReference)
> >
> > + try:
> >
> > + self.state = 1208
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Goto]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1206
> >
> > + self.vfrStatementGoto()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ResetButton]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1207
> >
> > + self.vfrStatementResetButton()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementGotoContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = 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)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def vfrGotoFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrGotoFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def DevicePath(self):
> >
> > + return self.getToken(VfrSyntaxParser.DevicePath, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def FormSetGuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormSetGuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def FormId(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormId, 0)
> >
> > +
> >
> > + def Question(self):
> >
> > + return self.getToken(VfrSyntaxParser.Question, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementGoto
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementGoto" ):
> >
> > + return visitor.visitVfrStatementGoto(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementGoto(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementGotoContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 126, self.RULE_vfrStatementGoto)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1210
> >
> > + self.match(VfrSyntaxParser.Goto)
> >
> > + self.state = 1258
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.DevicePath]:
> >
> > + self.state = 1211
> >
> > + self.match(VfrSyntaxParser.DevicePath)
> >
> > + self.state = 1212
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1213
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1214
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1215
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1216
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1217
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1218
> >
> > + self.match(VfrSyntaxParser.FormSetGuid)
> >
> > + self.state = 1219
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1220
> >
> > + self.guidDefinition()
> >
> > + self.state = 1221
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1222
> >
> > + self.match(VfrSyntaxParser.FormId)
> >
> > + self.state = 1223
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1224
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1225
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1226
> >
> > + self.match(VfrSyntaxParser.Question)
> >
> > + self.state = 1227
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1228
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1229
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.FormSetGuid]:
> >
> > + self.state = 1231
> >
> > + self.match(VfrSyntaxParser.FormSetGuid)
> >
> > + self.state = 1232
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1233
> >
> > + self.guidDefinition()
> >
> > + self.state = 1234
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1235
> >
> > + self.match(VfrSyntaxParser.FormId)
> >
> > + self.state = 1236
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1237
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1238
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1239
> >
> > + self.match(VfrSyntaxParser.Question)
> >
> > + self.state = 1240
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1241
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1242
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.FormId]:
> >
> > + self.state = 1244
> >
> > + self.match(VfrSyntaxParser.FormId)
> >
> > + self.state = 1245
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1246
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1247
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1248
> >
> > + self.match(VfrSyntaxParser.Question)
> >
> > + self.state = 1249
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1254
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.StringIdentifier]:
> >
> > + self.state = 1250
> >
> > + localctx.QN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1251
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Number]:
> >
> > + self.state = 1252
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1253
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Number]:
> >
> > + 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 = 1260
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 1265
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1261
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1262
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1263
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1264
> >
> > + self.vfrGotoFlags()
> >
> > +
> >
> > +
> >
> > + self.state = 1271
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1267
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1268
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1269
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1270
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + self.state = 1275
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 1273
> >
> > + localctx.E = self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1274
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > +
> >
> > +
> >
> > + self.state = 1277
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrGotoFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.GotoFlags = 0
> >
> > +
> >
> > + def gotoFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.GotoFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GotoFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrGotoFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrGotoFlags" ):
> >
> > + return visitor.visitVfrGotoFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrGotoFlags(self):
> >
> > +
> >
> > + 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 = 1279
> >
> > + self.gotoFlagsField()
> >
> > + self.state = 1284
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1280
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1281
> >
> > + self.gotoFlagsField()
> >
> > + self.state = 1286
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class GotoFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Flag = 0
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_gotoFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitGotoFlagsField" ):
> >
> > + return visitor.visitGotoFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def gotoFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.GotoFlagsFieldContext(self, self._ctx,
> self.state)
> >
> > + self.enterRule(localctx, 130, self.RULE_gotoFlagsField)
> >
> > + try:
> >
> > + self.state = 1289
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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 = 1288
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementResetButtonContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_RESET_BUTTON_OP)
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def ResetButton(self):
> >
> > + return self.getToken(VfrSyntaxParser.ResetButton, 0)
> >
> > +
> >
> > + def DefaultStore(self):
> >
> > + return self.getToken(VfrSyntaxParser.DefaultStore, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def EndResetButton(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndResetButton, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def vfrStatementStatTagList(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagListContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementResetButton
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementResetButton" ):
> >
> > + return visitor.visitVfrStatementResetButton(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementResetButton(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementResetButtonContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 132, self.RULE_vfrStatementResetButton)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1291
> >
> > + self.match(VfrSyntaxParser.ResetButton)
> >
> > + self.state = 1292
> >
> > + self.match(VfrSyntaxParser.DefaultStore)
> >
> > + self.state = 1293
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1294
> >
> > + localctx.N = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1295
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1296
> >
> > + self.vfrStatementHeader(localctx.Node)
> >
> > + self.state = 1297
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1301
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Image or _la==VfrSyntaxParser.Locked:
> >
> > + self.state = 1298
> >
> > + self.vfrStatementStatTagList(localctx.Node)
> >
> > + self.state = 1299
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1303
> >
> > + self.match(VfrSyntaxParser.EndResetButton)
> >
> > + self.state = 1304
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementQuestionsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementBooleanType(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementBooleanTypeContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def vfrStatementDate(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDateContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementNumericType(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericTypeContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def vfrStatementStringType(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringTypeContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementOrderedList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOrderedListContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementTime(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementTimeContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementQuestions
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementQuestions" ):
> >
> > + return visitor.visitVfrStatementQuestions(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestions(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementQuestionsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 134, self.RULE_vfrStatementQuestions)
> >
> > + try:
> >
> > + self.state = 1312
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.CheckBox, VfrSyntaxParser.Action]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1306
> >
> > + self.vfrStatementBooleanType()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Date]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1307
> >
> > + self.vfrStatementDate()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OneOf, VfrSyntaxParser.Numeric]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1308
> >
> > + self.vfrStatementNumericType()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Password, VfrSyntaxParser.String]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1309
> >
> > + self.vfrStatementStringType()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OrderedList]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 1310
> >
> > + self.vfrStatementOrderedList()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Time]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 1311
> >
> > + self.vfrStatementTime()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementQuestionTagContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementStatTag(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatTagContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def vfrStatementInconsistentIf(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementNoSubmitIf(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNoSubmitIfContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementDisableIfQuest(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfQuestContext
> > ,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementRefresh(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarstoreDevice(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarstoreDeviceContext
> > ,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementExtension(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementRefreshEvent(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def vfrStatementWarningIf(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWarningIfContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementQuestionTag
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementQuestionTag" ):
> >
> > + return visitor.visitVfrStatementQuestionTag(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionTag(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementQuestionTagContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 136, self.RULE_vfrStatementQuestionTag)
> >
> > + try:
> >
> > + self.state = 1325
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Image, VfrSyntaxParser.Locked]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1314
> >
> > + self.vfrStatementStatTag()
> >
> > + self.state = 1315
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.InconsistentIf]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1317
> >
> > + self.vfrStatementInconsistentIf()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NoSubmitIf]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1318
> >
> > + self.vfrStatementNoSubmitIf()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DisableIf]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1319
> >
> > + self.vfrStatementDisableIfQuest()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Refresh]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 1320
> >
> > + self.vfrStatementRefresh()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.VarstoreDevice]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 1321
> >
> > + self.vfrStatementVarstoreDevice()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GuidOp]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 1322
> >
> > + self.vfrStatementExtension()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.RefreshGuid]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 1323
> >
> > + self.vfrStatementRefreshEvent()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.WarningIf]:
> >
> > + self.enterOuterAlt(localctx, 9)
> >
> > + self.state = 1324
> >
> > + self.vfrStatementWarningIf()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementInconsistentIfContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
> >
> > +
> >
> > + def InconsistentIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementInconsistentIf
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementInconsistentIf" ):
> >
> > + return visitor.visitVfrStatementInconsistentIf(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementInconsistentIf(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementInconsistentIfContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 138, self.RULE_vfrStatementInconsistentIf)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1327
> >
> > + self.match(VfrSyntaxParser.InconsistentIf)
> >
> > + self.state = 1328
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 1329
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1330
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1331
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1332
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1333
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1334
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1347
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1335
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1336
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1337
> >
> > + self.flagsField()
> >
> > + self.state = 1342
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1338
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1339
> >
> > + self.flagsField()
> >
> > + self.state = 1344
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1345
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + 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,92,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1351
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementNoSubmitIfContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_NO_SUBMIT_IF_OP)
> >
> > +
> >
> > + def NoSubmitIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.NoSubmitIf, 0)
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementNoSubmitIf
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementNoSubmitIf" ):
> >
> > + return visitor.visitVfrStatementNoSubmitIf(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementNoSubmitIf(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementNoSubmitIfContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 140, self.RULE_vfrStatementNoSubmitIf)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1354
> >
> > + self.match(VfrSyntaxParser.NoSubmitIf)
> >
> > + self.state = 1355
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 1356
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1357
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1358
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1359
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1360
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1361
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1374
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1362
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1363
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1364
> >
> > + self.flagsField()
> >
> > + self.state = 1369
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1365
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1366
> >
> > + self.flagsField()
> >
> > + self.state = 1371
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1372
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + 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,95,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1378
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementDisableIfQuestContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
> >
> > +
> >
> > + def DisableIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.DisableIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementDisableIfQuest
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementDisableIfQuest" ):
> >
> > + return visitor.visitVfrStatementDisableIfQuest(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementDisableIfQuest(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementDisableIfQuestContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 142, self.RULE_vfrStatementDisableIfQuest)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1381
> >
> > + self.match(VfrSyntaxParser.DisableIf)
> >
> > + self.state = 1382
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 1383
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 1384
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1385
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 1387
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1386
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementRefreshContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_REFRESH_OP)
> >
> > +
> >
> > + def Refresh(self):
> >
> > + return self.getToken(VfrSyntaxParser.Refresh, 0)
> >
> > +
> >
> > + def Interval(self):
> >
> > + return self.getToken(VfrSyntaxParser.Interval, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementRefresh
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementRefresh" ):
> >
> > + return visitor.visitVfrStatementRefresh(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementRefresh(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementRefreshContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 144, self.RULE_vfrStatementRefresh)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1389
> >
> > + self.match(VfrSyntaxParser.Refresh)
> >
> > + self.state = 1390
> >
> > + self.match(VfrSyntaxParser.Interval)
> >
> > + self.state = 1391
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1392
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementVarstoreDeviceContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_VARSTORE_DEVICE_OP)
> >
> > +
> >
> > + def VarstoreDevice(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarstoreDevice, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementVarstoreDevice
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementVarstoreDevice" ):
> >
> > + return visitor.visitVfrStatementVarstoreDevice(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementVarstoreDevice(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementVarstoreDeviceContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 146, self.RULE_vfrStatementVarstoreDevice)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1394
> >
> > + self.match(VfrSyntaxParser.VarstoreDevice)
> >
> > + self.state = 1395
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1396
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1397
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1398
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1399
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1400
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementRefreshEventContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_REFRESH_ID_OP)
> >
> > +
> >
> > + def RefreshGuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.RefreshGuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementRefreshEvent
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementRefreshEvent" ):
> >
> > + return visitor.visitVfrStatementRefreshEvent(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementRefreshEvent(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementRefreshEventContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 148, self.RULE_vfrStatementRefreshEvent)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1402
> >
> > + self.match(VfrSyntaxParser.RefreshGuid)
> >
> > + self.state = 1403
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1404
> >
> > + self.guidDefinition()
> >
> > + self.state = 1405
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementWarningIfContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_WARNING_IF_OP)
> >
> > +
> >
> > + def WarningIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.WarningIf, 0)
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def Timeout(self):
> >
> > + return self.getToken(VfrSyntaxParser.Timeout, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementWarningIf
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementWarningIf" ):
> >
> > + return visitor.visitVfrStatementWarningIf(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementWarningIf(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementWarningIfContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 150, self.RULE_vfrStatementWarningIf)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1407
> >
> > + self.match(VfrSyntaxParser.WarningIf)
> >
> > + self.state = 1408
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 1409
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1410
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1411
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1412
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1413
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1414
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1419
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Timeout:
> >
> > + self.state = 1415
> >
> > + self.match(VfrSyntaxParser.Timeout)
> >
> > + self.state = 1416
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1417
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1418
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + 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,98,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1423
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementQuestionTagListContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.Node = Node
> >
> > +
> >
> > + def vfrStatementQuestionTag(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionTagContext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementQuestionTagList
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementQuestionTagList" ):
> >
> > + return visitor.visitVfrStatementQuestionTagList(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionTagList(self, Node):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementQuestionTagListContext(self,
> > self._ctx, self.state, Node)
> >
> > + self.enterRule(localctx, 152, self.RULE_vfrStatementQuestionTagList)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 1426
> >
> > + self.vfrStatementQuestionTag()
> >
> > + self.state = 1431
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementQuestionOptionTagContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementSuppressIfQuest(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfQuestConte
> > xt,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementGrayOutIfQuest(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfQuestContex
> > t,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementValue(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementDefault(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementOptions(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOptionsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementRead(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementReadContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementWrite(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementWriteContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementQuestionOptionTag
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementQuestionOptionTag" ):
> >
> > + return visitor.visitVfrStatementQuestionOptionTag(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionOptionTag(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementQuestionOptionTagContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 154,
> self.RULE_vfrStatementQuestionOptionTag)
> >
> > + try:
> >
> > + self.state = 1439
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.SuppressIf]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1432
> >
> > + self.vfrStatementSuppressIfQuest()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GrayOutIf]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1433
> >
> > + self.vfrStatementGrayOutIfQuest()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Value]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1434
> >
> > + self.vfrStatementValue()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Default]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1435
> >
> > + self.vfrStatementDefault()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Option]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 1436
> >
> > + self.vfrStatementOptions()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Read]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 1437
> >
> > + self.vfrStatementRead()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Write]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 1438
> >
> > + self.vfrStatementWrite()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class FlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.N = None # Token
> >
> > + self.L = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def InteractiveFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
> >
> > +
> >
> > + def ManufacturingFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
> >
> > +
> >
> > + def DefaultFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
> >
> > +
> >
> > + def ResetRequiredFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
> >
> > +
> >
> > + def ReconnectRequiredFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
> >
> > +
> >
> > + def NVAccessFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
> >
> > +
> >
> > + def LateCheckFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_flagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitFlagsField" ):
> >
> > + return visitor.visitFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def flagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.FlagsFieldContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 156, self.RULE_flagsField)
> >
> > + try:
> >
> > + self.state = 1449
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1441
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.InteractiveFlag]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1442
> >
> > + self.match(VfrSyntaxParser.InteractiveFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ManufacturingFlag]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1443
> >
> > + self.match(VfrSyntaxParser.ManufacturingFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DefaultFlag]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1444
> >
> > + self.match(VfrSyntaxParser.DefaultFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ResetRequiredFlag]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 1445
> >
> > + self.match(VfrSyntaxParser.ResetRequiredFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 1446
> >
> > + self.match(VfrSyntaxParser.ReconnectRequiredFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NVAccessFlag]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 1447
> >
> > + localctx.N = self.match(VfrSyntaxParser.NVAccessFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LateCheckFlag]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 1448
> >
> > + localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementSuppressIfQuestContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
> >
> > +
> >
> > + def SuppressIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementSuppressIfQuest
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementSuppressIfQuest" ):
> >
> > + return visitor.visitVfrStatementSuppressIfQuest(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfQuest(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementSuppressIfQuestContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 158, self.RULE_vfrStatementSuppressIfQuest)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1451
> >
> > + self.match(VfrSyntaxParser.SuppressIf)
> >
> > + self.state = 1452
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 1453
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 1466
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1454
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1455
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1456
> >
> > + self.flagsField()
> >
> > + self.state = 1461
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1457
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1458
> >
> > + self.flagsField()
> >
> > + self.state = 1463
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1464
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1468
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1469
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 1471
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1470
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementGrayOutIfQuestContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
> >
> > +
> >
> > + def GrayOutIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementGrayOutIfQuest
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementGrayOutIfQuest" ):
> >
> > + return visitor.visitVfrStatementGrayOutIfQuest(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementGrayOutIfQuest(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementGrayOutIfQuestContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 160, self.RULE_vfrStatementGrayOutIfQuest)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1473
> >
> > + self.match(VfrSyntaxParser.GrayOutIf)
> >
> > + self.state = 1474
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 1475
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 1488
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1476
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1477
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1478
> >
> > + self.flagsField()
> >
> > + self.state = 1483
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1479
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1480
> >
> > + self.flagsField()
> >
> > + self.state = 1485
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1486
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1490
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1491
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 1493
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1492
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementDefaultContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = 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 Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrConstantValueField(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementValue(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementValueContext,0)
> >
> > +
> >
> > +
> >
> > + def DefaultStore(self):
> >
> > + return self.getToken(VfrSyntaxParser.DefaultStore, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementDefault
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementDefault" ):
> >
> > + return visitor.visitVfrStatementDefault(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementDefault(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementDefaultContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 162, self.RULE_vfrStatementDefault)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1495
> >
> > + localctx.D = self.match(VfrSyntaxParser.Default)
> >
> > +
> >
> > + self.state = 1503
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Value]:
> >
> > + self.state = 1496
> >
> > + localctx.V = self.vfrStatementValue()
> >
> > + self.state = 1497
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.T__5]:
> >
> > + self.state = 1499
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1500
> >
> > + self.vfrConstantValueField()
> >
> > + self.state = 1501
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 1509
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.DefaultStore:
> >
> > + self.state = 1505
> >
> > + self.match(VfrSyntaxParser.DefaultStore)
> >
> > + self.state = 1506
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1507
> >
> > + localctx.SN = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1508
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementValueContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_VALUE_OP)
> >
> > +
> >
> > + def Value(self):
> >
> > + return self.getToken(VfrSyntaxParser.Value, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementValue
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementValue" ):
> >
> > + return visitor.visitVfrStatementValue(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementValue(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementValueContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 164, self.RULE_vfrStatementValue)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1511
> >
> > + self.match(VfrSyntaxParser.Value)
> >
> > + self.state = 1512
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1513
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementOptionsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementOneOfOption(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfOptionContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementOptions
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementOptions" ):
> >
> > + return visitor.visitVfrStatementOptions(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementOptions(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementOptionsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 166, self.RULE_vfrStatementOptions)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1515
> >
> > + self.vfrStatementOneOfOption()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementOneOfOptionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = 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)
> >
> > +
> >
> > + def Text(self):
> >
> > + return self.getToken(VfrSyntaxParser.Text, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Value(self):
> >
> > + return self.getToken(VfrSyntaxParser.Value, 0)
> >
> > +
> >
> > + def vfrConstantValueField(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrConstantValueFieldContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrOneOfOptionFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrOneOfOptionFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def vfrImageTag(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrImageTagContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrImageTagContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementOneOfOption
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementOneOfOption" ):
> >
> > + return visitor.visitVfrStatementOneOfOption(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementOneOfOption(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementOneOfOptionContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 168, self.RULE_vfrStatementOneOfOption)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1517
> >
> > + self.match(VfrSyntaxParser.Option)
> >
> > + self.state = 1518
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 1519
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1520
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1521
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1522
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1523
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1524
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1525
> >
> > + self.match(VfrSyntaxParser.Value)
> >
> > + self.state = 1526
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1527
> >
> > + self.vfrConstantValueField()
> >
> > + self.state = 1528
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1529
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1530
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1531
> >
> > + self.vfrOneOfOptionFlags()
> >
> > + self.state = 1536
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 1532
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1533
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1534
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1535
> >
> > + localctx.KN = self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + self.state = 1542
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 1538
> >
> > + localctx.T = self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1539
> >
> > + self.vfrImageTag()
> >
> > + self.state = 1544
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 1545
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrOneOfOptionFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > + self.LFlags = 0
> >
> > +
> >
> > + def oneofoptionFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.OneofoptionFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.OneofoptionFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrOneOfOptionFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrOneOfOptionFlags" ):
> >
> > + return visitor.visitVfrOneOfOptionFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrOneOfOptionFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrOneOfOptionFlagsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 170, self.RULE_vfrOneOfOptionFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1547
> >
> > + self.oneofoptionFlagsField()
> >
> > + self.state = 1552
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1548
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1549
> >
> > + self.oneofoptionFlagsField()
> >
> > + self.state = 1554
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class OneofoptionFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlag = 0
> >
> > + self.LFlag = 0
> >
> > + self.A = None # Token
> >
> > + self.L = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def OptionDefault(self):
> >
> > + return self.getToken(VfrSyntaxParser.OptionDefault, 0)
> >
> > +
> >
> > + def OptionDefaultMfg(self):
> >
> > + return self.getToken(VfrSyntaxParser.OptionDefaultMfg, 0)
> >
> > +
> >
> > + def InteractiveFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.InteractiveFlag, 0)
> >
> > +
> >
> > + def ResetRequiredFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ResetRequiredFlag, 0)
> >
> > +
> >
> > + def RestStyleFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.RestStyleFlag, 0)
> >
> > +
> >
> > + def ReconnectRequiredFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ReconnectRequiredFlag, 0)
> >
> > +
> >
> > + def ManufacturingFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
> >
> > +
> >
> > + def DefaultFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
> >
> > +
> >
> > + def NVAccessFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.NVAccessFlag, 0)
> >
> > +
> >
> > + def LateCheckFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.LateCheckFlag, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_oneofoptionFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitOneofoptionFlagsField" ):
> >
> > + return visitor.visitOneofoptionFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def oneofoptionFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.OneofoptionFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 172, self.RULE_oneofoptionFlagsField)
> >
> > + try:
> >
> > + self.state = 1566
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1555
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OptionDefault]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1556
> >
> > + self.match(VfrSyntaxParser.OptionDefault)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OptionDefaultMfg]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1557
> >
> > + self.match(VfrSyntaxParser.OptionDefaultMfg)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.InteractiveFlag]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1558
> >
> > + self.match(VfrSyntaxParser.InteractiveFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ResetRequiredFlag]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 1559
> >
> > + self.match(VfrSyntaxParser.ResetRequiredFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.RestStyleFlag]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 1560
> >
> > + self.match(VfrSyntaxParser.RestStyleFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ReconnectRequiredFlag]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 1561
> >
> > + self.match(VfrSyntaxParser.ReconnectRequiredFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ManufacturingFlag]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 1562
> >
> > + self.match(VfrSyntaxParser.ManufacturingFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DefaultFlag]:
> >
> > + self.enterOuterAlt(localctx, 9)
> >
> > + self.state = 1563
> >
> > + self.match(VfrSyntaxParser.DefaultFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NVAccessFlag]:
> >
> > + self.enterOuterAlt(localctx, 10)
> >
> > + self.state = 1564
> >
> > + localctx.A = self.match(VfrSyntaxParser.NVAccessFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LateCheckFlag]:
> >
> > + self.enterOuterAlt(localctx, 11)
> >
> > + self.state = 1565
> >
> > + localctx.L = self.match(VfrSyntaxParser.LateCheckFlag)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementReadContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_READ_OP)
> >
> > +
> >
> > + def Read(self):
> >
> > + return self.getToken(VfrSyntaxParser.Read, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementRead
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementRead" ):
> >
> > + return visitor.visitVfrStatementRead(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementRead(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementReadContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 174, self.RULE_vfrStatementRead)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1568
> >
> > + self.match(VfrSyntaxParser.Read)
> >
> > + self.state = 1569
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 1570
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementWriteContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_WRITE_OP)
> >
> > +
> >
> > + def Write(self):
> >
> > + return self.getToken(VfrSyntaxParser.Write, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementWrite
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementWrite" ):
> >
> > + return visitor.visitVfrStatementWrite(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementWrite(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementWriteContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 176, self.RULE_vfrStatementWrite)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1572
> >
> > + self.match(VfrSyntaxParser.Write)
> >
> > + self.state = 1573
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 1574
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementQuestionOptionListContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.Node = Node
> >
> > +
> >
> > + def vfrStatementQuestionOption(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementQuestionOptionConte
> > xt)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionContex
> > t,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementQuestionOptionList
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementQuestionOptionList" ):
> >
> > + return visitor.visitVfrStatementQuestionOptionList(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self, Node):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementQuestionOptionListContext(self,
> > self._ctx, self.state, Node)
> >
> > + self.enterRule(localctx, 178,
> self.RULE_vfrStatementQuestionOptionList)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 1576
> >
> > + self.vfrStatementQuestionOption()
> >
> > + self.state = 1581
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementQuestionOptionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementQuestionTag(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionOptionTag(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionTagCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementQuestionOption
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementQuestionOption" ):
> >
> > + return visitor.visitVfrStatementQuestionOption(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionOption(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementQuestionOptionContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 180, self.RULE_vfrStatementQuestionOption)
> >
> > + try:
> >
> > + self.state = 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 = 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 = 1583
> >
> > + self.vfrStatementQuestionOptionTag()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementBooleanTypeContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementCheckBox(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementCheckBoxContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementAction(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementActionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementBooleanType
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementBooleanType" ):
> >
> > + return visitor.visitVfrStatementBooleanType(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementBooleanType(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementBooleanTypeContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 182, self.RULE_vfrStatementBooleanType)
> >
> > + try:
> >
> > + self.state = 1588
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.CheckBox]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1586
> >
> > + self.vfrStatementCheckBox()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Action]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1587
> >
> > + self.vfrStatementAction()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementCheckBoxContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = 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
> >
> > +
> >
> > + def vfrQuestionBaseInfo(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndCheckBox(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndCheckBox, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def CheckBox(self):
> >
> > + return self.getToken(VfrSyntaxParser.CheckBox, 0)
> >
> > +
> >
> > + def vfrCheckBoxFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrCheckBoxFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementCheckBox
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementCheckBox" ):
> >
> > + return visitor.visitVfrStatementCheckBox(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementCheckBox(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementCheckBoxContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 184, self.RULE_vfrStatementCheckBox)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 1599
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1594
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1595
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1596
> >
> > + self.vfrCheckBoxFlags()
> >
> > + self.state = 1597
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1605
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Key:
> >
> > + self.state = 1601
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1602
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1603
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1604
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1607
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1608
> >
> > + self.match(VfrSyntaxParser.EndCheckBox)
> >
> > + self.state = 1609
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrCheckBoxFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.LFlags = 0
> >
> > + self.HFlags = 0
> >
> > +
> >
> > + def checkboxFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.CheckboxFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.CheckboxFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrCheckBoxFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrCheckBoxFlags" ):
> >
> > + return visitor.visitVfrCheckBoxFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrCheckBoxFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrCheckBoxFlagsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 186, self.RULE_vfrCheckBoxFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1611
> >
> > + self.checkboxFlagsField()
> >
> > + self.state = 1616
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1612
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1613
> >
> > + self.checkboxFlagsField()
> >
> > + self.state = 1618
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class CheckboxFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.LFlag = 0
> >
> > + self.HFlag = 0
> >
> > + self.D = None # Token
> >
> > + self.M = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def DefaultFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.DefaultFlag, 0)
> >
> > +
> >
> > + def ManufacturingFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.ManufacturingFlag, 0)
> >
> > +
> >
> > + def CheckBoxDefaultFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.CheckBoxDefaultFlag, 0)
> >
> > +
> >
> > + def CheckBoxDefaultMfgFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.CheckBoxDefaultMfgFlag, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_checkboxFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCheckboxFlagsField" ):
> >
> > + return visitor.visitCheckboxFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def checkboxFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.CheckboxFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 188, self.RULE_checkboxFlagsField)
> >
> > + try:
> >
> > + self.state = 1625
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1619
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DefaultFlag]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1620
> >
> > + localctx.D = self.match(VfrSyntaxParser.DefaultFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ManufacturingFlag]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1621
> >
> > + localctx.M = self.match(VfrSyntaxParser.ManufacturingFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.CheckBoxDefaultFlag]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1622
> >
> > + self.match(VfrSyntaxParser.CheckBoxDefaultFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.CheckBoxDefaultMfgFlag]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + 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 = 1624
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementActionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_ACTION_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> >
> > +
> >
> > + def Action(self):
> >
> > + return self.getToken(VfrSyntaxParser.Action, 0)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Config(self):
> >
> > + return self.getToken(VfrSyntaxParser.Config, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def vfrStatementQuestionTagList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionTagListContex
> > t,0)
> >
> > +
> >
> > +
> >
> > + def EndAction(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndAction, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def vfrActionFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrActionFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementAction
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementAction" ):
> >
> > + return visitor.visitVfrStatementAction(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementAction(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementActionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 190, self.RULE_vfrStatementAction)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1627
> >
> > + self.match(VfrSyntaxParser.Action)
> >
> > + self.state = 1628
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 1629
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1635
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1630
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1631
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1632
> >
> > + self.vfrActionFlags()
> >
> > + self.state = 1633
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1637
> >
> > + self.match(VfrSyntaxParser.Config)
> >
> > + self.state = 1638
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1639
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1640
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1641
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1642
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1643
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1644
> >
> > + self.vfrStatementQuestionTagList(localctx.Node)
> >
> > + self.state = 1645
> >
> > + self.match(VfrSyntaxParser.EndAction)
> >
> > + self.state = 1646
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrActionFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > +
> >
> > + def actionFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.ActionFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ActionFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrActionFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrActionFlags" ):
> >
> > + return visitor.visitVfrActionFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrActionFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrActionFlagsContext(self, self._ctx,
> self.state)
> >
> > + self.enterRule(localctx, 192, self.RULE_vfrActionFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1648
> >
> > + self.actionFlagsField()
> >
> > + self.state = 1653
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1649
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1650
> >
> > + self.actionFlagsField()
> >
> > + self.state = 1655
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ActionFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlag = 0
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_actionFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitActionFlagsField" ):
> >
> > + return visitor.visitActionFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def actionFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ActionFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 194, self.RULE_actionFlagsField)
> >
> > + try:
> >
> > + self.state = 1658
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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 = 1657
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementNumericTypeContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementNumeric(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNumericContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementOneOf(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementOneOfContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementNumericType
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementNumericType" ):
> >
> > + return visitor.visitVfrStatementNumericType(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementNumericType(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementNumericTypeContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 196, self.RULE_vfrStatementNumericType)
> >
> > + try:
> >
> > + self.state = 1662
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Numeric]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1660
> >
> > + self.vfrStatementNumeric()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OneOf]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1661
> >
> > + self.vfrStatementOneOf()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementNumericContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_NUMERIC_OP)
> >
> > + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> >
> > + self.F = None # Token
> >
> > +
> >
> > + def Numeric(self):
> >
> > + return self.getToken(VfrSyntaxParser.Numeric, 0)
> >
> > +
> >
> > + def vfrQuestionBaseInfo(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrSetMinMaxStep(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndNumeric(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndNumeric, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def vfrNumericFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrNumericFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementNumeric
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementNumeric" ):
> >
> > + return visitor.visitVfrStatementNumeric(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementNumeric(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementNumericContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 198, self.RULE_vfrStatementNumeric)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 1673
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1668
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1669
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1670
> >
> > + self.vfrNumericFlags()
> >
> > + self.state = 1671
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1679
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Key:
> >
> > + self.state = 1675
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1676
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1677
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1678
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1681
> >
> > + self.vfrSetMinMaxStep(localctx.Node)
> >
> > + self.state = 1682
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1683
> >
> > + self.match(VfrSyntaxParser.EndNumeric)
> >
> > + self.state = 1684
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrSetMinMaxStepContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, Node=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > + self.N1 = None # Token
> >
> > + self.I = None # Token
> >
> > + self.N2 = None # Token
> >
> > + self.A = None # Token
> >
> > + self.S = None # Token
> >
> > + self.Node = Node
> >
> > +
> >
> > + def Minimum(self):
> >
> > + return self.getToken(VfrSyntaxParser.Minimum, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Maximum(self):
> >
> > + return self.getToken(VfrSyntaxParser.Maximum, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Step(self):
> >
> > + return self.getToken(VfrSyntaxParser.Step, 0)
> >
> > +
> >
> > + def Negative(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Negative)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Negative, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrSetMinMaxStep
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrSetMinMaxStep" ):
> >
> > + return visitor.visitVfrSetMinMaxStep(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrSetMinMaxStep(self, Node):
> >
> > +
> >
> > + 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 = 1686
> >
> > + self.match(VfrSyntaxParser.Minimum)
> >
> > + self.state = 1687
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1689
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Negative:
> >
> > + self.state = 1688
> >
> > + localctx.N1 = self.match(VfrSyntaxParser.Negative)
> >
> > +
> >
> > +
> >
> > + self.state = 1691
> >
> > + localctx.I = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1692
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1693
> >
> > + self.match(VfrSyntaxParser.Maximum)
> >
> > + self.state = 1694
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1696
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Negative:
> >
> > + self.state = 1695
> >
> > + localctx.N2 = self.match(VfrSyntaxParser.Negative)
> >
> > +
> >
> > +
> >
> > + self.state = 1698
> >
> > + localctx.A = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1699
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1704
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Step:
> >
> > + self.state = 1700
> >
> > + self.match(VfrSyntaxParser.Step)
> >
> > + self.state = 1701
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1702
> >
> > + localctx.S = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1703
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrNumericFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > + self.LFlags = 0
> >
> > + self.IsDisplaySpecified = False
> >
> > + self.UpdateVarType = False
> >
> > +
> >
> > + def numericFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrNumericFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrNumericFlags" ):
> >
> > + return visitor.visitVfrNumericFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrNumericFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrNumericFlagsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 202, self.RULE_vfrNumericFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1706
> >
> > + self.numericFlagsField()
> >
> > + self.state = 1711
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1707
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1708
> >
> > + self.numericFlagsField()
> >
> > + self.state = 1713
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class NumericFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlag = 0
> >
> > + self.IsSetType = False
> >
> > + self.IsDisplaySpecified = False
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def NumericSizeOne(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
> >
> > +
> >
> > + def NumericSizeTwo(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
> >
> > +
> >
> > + def NumericSizeFour(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
> >
> > +
> >
> > + def NumericSizeEight(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
> >
> > +
> >
> > + def DisPlayIntDec(self):
> >
> > + return self.getToken(VfrSyntaxParser.DisPlayIntDec, 0)
> >
> > +
> >
> > + def DisPlayUIntDec(self):
> >
> > + return self.getToken(VfrSyntaxParser.DisPlayUIntDec, 0)
> >
> > +
> >
> > + def DisPlayUIntHex(self):
> >
> > + return self.getToken(VfrSyntaxParser.DisPlayUIntHex, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_numericFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitNumericFlagsField" ):
> >
> > + return visitor.visitNumericFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def numericFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.NumericFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 204, self.RULE_numericFlagsField)
> >
> > + try:
> >
> > + self.state = 1723
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1714
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NumericSizeOne]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1715
> >
> > + self.match(VfrSyntaxParser.NumericSizeOne)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NumericSizeTwo]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 1716
> >
> > + self.match(VfrSyntaxParser.NumericSizeTwo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NumericSizeFour]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 1717
> >
> > + self.match(VfrSyntaxParser.NumericSizeFour)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NumericSizeEight]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 1718
> >
> > + self.match(VfrSyntaxParser.NumericSizeEight)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DisPlayIntDec]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 1719
> >
> > + self.match(VfrSyntaxParser.DisPlayIntDec)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DisPlayUIntDec]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 1720
> >
> > + self.match(VfrSyntaxParser.DisPlayUIntDec)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.DisPlayUIntHex]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + 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 = 1722
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementOneOfContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_ONE_OF_OP)
> >
> > + self.GuidNode = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> >
> > + self.F = None # Token
> >
> > +
> >
> > + def OneOf(self):
> >
> > + return self.getToken(VfrSyntaxParser.OneOf, 0)
> >
> > +
> >
> > + def vfrQuestionBaseInfo(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionBaseInfoContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndOneOf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndOneOf, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def vfrOneofFlagsField(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrOneofFlagsFieldContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrSetMinMaxStep(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrSetMinMaxStepContext,0)
> >
> > +
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementOneOf
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementOneOf" ):
> >
> > + return visitor.visitVfrStatementOneOf(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementOneOf(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementOneOfContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 206, self.RULE_vfrStatementOneOf)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 1734
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1729
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1730
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1731
> >
> > + self.vfrOneofFlagsField()
> >
> > + self.state = 1732
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1737
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Minimum:
> >
> > + self.state = 1736
> >
> > + self.vfrSetMinMaxStep(localctx.Node)
> >
> > +
> >
> > +
> >
> > + self.state = 1739
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1740
> >
> > + self.match(VfrSyntaxParser.EndOneOf)
> >
> > + self.state = 1741
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrOneofFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > + self.LFlags = 0
> >
> > + self.UpdateVarType = False
> >
> > +
> >
> > + def numericFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.NumericFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.NumericFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrOneofFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrOneofFlagsField" ):
> >
> > + return visitor.visitVfrOneofFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrOneofFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrOneofFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 208, self.RULE_vfrOneofFlagsField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1743
> >
> > + self.numericFlagsField()
> >
> > + self.state = 1748
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1744
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1745
> >
> > + self.numericFlagsField()
> >
> > + self.state = 1750
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStringTypeContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementString(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStringContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementPassword(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementPasswordContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStringType
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStringType" ):
> >
> > + return visitor.visitVfrStatementStringType(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStringType(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStringTypeContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 210, self.RULE_vfrStatementStringType)
> >
> > + try:
> >
> > + self.state = 1753
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.String]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1751
> >
> > + self.vfrStatementString()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Password]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1752
> >
> > + self.vfrStatementPassword()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStringContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_STRING_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> >
> > + self.F = None # Token
> >
> > + self.Min = None # Token
> >
> > + self.Max = None # Token
> >
> > +
> >
> > + def String(self):
> >
> > + return self.getToken(VfrSyntaxParser.String, 0)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndString(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndString, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def MinSize(self):
> >
> > + return self.getToken(VfrSyntaxParser.MinSize, 0)
> >
> > +
> >
> > + def MaxSize(self):
> >
> > + return self.getToken(VfrSyntaxParser.MaxSize, 0)
> >
> > +
> >
> > + def vfrStringFlagsField(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStringFlagsFieldContext,0)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementString
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementString" ):
> >
> > + return visitor.visitVfrStatementString(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementString(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStringContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 212, self.RULE_vfrStatementString)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1755
> >
> > + self.match(VfrSyntaxParser.String)
> >
> > + self.state = 1756
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 1757
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1763
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1758
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1759
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1760
> >
> > + self.vfrStringFlagsField()
> >
> > + self.state = 1761
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1769
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Key:
> >
> > + self.state = 1765
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1766
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1767
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1768
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1771
> >
> > + localctx.Min = self.match(VfrSyntaxParser.MinSize)
> >
> > + self.state = 1772
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1773
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1774
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1775
> >
> > + localctx.Max = self.match(VfrSyntaxParser.MaxSize)
> >
> > + self.state = 1776
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1777
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1778
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1779
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1780
> >
> > + self.match(VfrSyntaxParser.EndString)
> >
> > + self.state = 1781
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStringFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > + self.LFlags = 0
> >
> > +
> >
> > + def stringFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.StringFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.StringFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStringFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStringFlagsField" ):
> >
> > + return visitor.visitVfrStringFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStringFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStringFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 214, self.RULE_vfrStringFlagsField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1783
> >
> > + self.stringFlagsField()
> >
> > + self.state = 1788
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1784
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1785
> >
> > + self.stringFlagsField()
> >
> > + self.state = 1790
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class StringFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlag = 0
> >
> > + self.LFlag = 0
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_stringFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitStringFlagsField" ):
> >
> > + return visitor.visitStringFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def stringFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.StringFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 216, self.RULE_stringFlagsField)
> >
> > + try:
> >
> > + self.state = 1794
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1791
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.T__8]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + 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 = 1793
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementPasswordContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_PASSWORD_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> >
> > + self.F = None # Token
> >
> > + self.Min = None # Token
> >
> > + self.Max = None # Token
> >
> > +
> >
> > + def Password(self):
> >
> > + return self.getToken(VfrSyntaxParser.Password, 0)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndPassword(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndPassword, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def MinSize(self):
> >
> > + return self.getToken(VfrSyntaxParser.MinSize, 0)
> >
> > +
> >
> > + def MaxSize(self):
> >
> > + return self.getToken(VfrSyntaxParser.MaxSize, 0)
> >
> > +
> >
> > + def vfrPasswordFlagsField(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrPasswordFlagsFieldContext,0)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def Encoding(self):
> >
> > + return self.getToken(VfrSyntaxParser.Encoding, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementPassword
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementPassword" ):
> >
> > + return visitor.visitVfrStatementPassword(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementPassword(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementPasswordContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 218, self.RULE_vfrStatementPassword)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1796
> >
> > + self.match(VfrSyntaxParser.Password)
> >
> > + self.state = 1797
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 1798
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1804
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1799
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1800
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1801
> >
> > + self.vfrPasswordFlagsField()
> >
> > + self.state = 1802
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1810
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Key:
> >
> > + self.state = 1806
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 1807
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1808
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1809
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1812
> >
> > + localctx.Min = self.match(VfrSyntaxParser.MinSize)
> >
> > + self.state = 1813
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1814
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1815
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1816
> >
> > + localctx.Max = self.match(VfrSyntaxParser.MaxSize)
> >
> > + self.state = 1817
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1818
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1819
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1824
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Encoding:
> >
> > + self.state = 1820
> >
> > + self.match(VfrSyntaxParser.Encoding)
> >
> > + self.state = 1821
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1822
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1823
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1826
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1827
> >
> > + self.match(VfrSyntaxParser.EndPassword)
> >
> > + self.state = 1828
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrPasswordFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > +
> >
> > + def passwordFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.PasswordFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.PasswordFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrPasswordFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrPasswordFlagsField" ):
> >
> > + return visitor.visitVfrPasswordFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrPasswordFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrPasswordFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 220, self.RULE_vfrPasswordFlagsField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1830
> >
> > + self.passwordFlagsField()
> >
> > + self.state = 1835
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1831
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1832
> >
> > + self.passwordFlagsField()
> >
> > + self.state = 1837
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class PasswordFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlag = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_passwordFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitPasswordFlagsField" ):
> >
> > + return visitor.visitPasswordFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def passwordFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.PasswordFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 222, self.RULE_passwordFlagsField)
> >
> > + try:
> >
> > + self.state = 1840
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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 = 1839
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementOrderedListContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_ORDERED_LIST_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_NORMAL
> >
> > + self.M = None # Token
> >
> > + self.F = None # Token
> >
> > +
> >
> > + def OrderedList(self):
> >
> > + return self.getToken(VfrSyntaxParser.OrderedList, 0)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def EndList(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndList, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def vfrOrderedListFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrOrderedListFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def MaxContainers(self):
> >
> > + return self.getToken(VfrSyntaxParser.MaxContainers, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementOrderedList
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementOrderedList" ):
> >
> > + return visitor.visitVfrStatementOrderedList(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementOrderedList(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementOrderedListContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 224, self.RULE_vfrStatementOrderedList)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1842
> >
> > + self.match(VfrSyntaxParser.OrderedList)
> >
> > + self.state = 1843
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 1844
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1849
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.MaxContainers:
> >
> > + self.state = 1845
> >
> > + localctx.M = self.match(VfrSyntaxParser.MaxContainers)
> >
> > + self.state = 1846
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1847
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1848
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1856
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1851
> >
> > + localctx.F = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1852
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1853
> >
> > + self.vfrOrderedListFlags()
> >
> > + self.state = 1854
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1858
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + self.state = 1859
> >
> > + self.match(VfrSyntaxParser.EndList)
> >
> > + self.state = 1860
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrOrderedListFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlags = 0
> >
> > + self.LFlags = 0
> >
> > +
> >
> > + def orderedlistFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.OrderedlistFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.OrderedlistFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrOrderedListFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrOrderedListFlags" ):
> >
> > + return visitor.visitVfrOrderedListFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrOrderedListFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrOrderedListFlagsContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 226, self.RULE_vfrOrderedListFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1862
> >
> > + self.orderedlistFlagsField()
> >
> > + self.state = 1867
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1863
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1864
> >
> > + self.orderedlistFlagsField()
> >
> > + self.state = 1869
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class OrderedlistFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.HFlag = 0
> >
> > + self.LFlag = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def UniQueFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.UniQueFlag, 0)
> >
> > +
> >
> > + def NoEmptyFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.NoEmptyFlag, 0)
> >
> > +
> >
> > + def questionheaderFlagsField(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.QuestionheaderFlagsFieldContext,0
> > )
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_orderedlistFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitOrderedlistFlagsField" ):
> >
> > + return visitor.visitOrderedlistFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def orderedlistFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.OrderedlistFlagsFieldContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 228, self.RULE_orderedlistFlagsField)
> >
> > + try:
> >
> > + self.state = 1874
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Number]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1870
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.UniQueFlag]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 1871
> >
> > + self.match(VfrSyntaxParser.UniQueFlag)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NoEmptyFlag]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + 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 = 1873
> >
> > + self.questionheaderFlagsField()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementDateContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_DATE_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_DATE
> >
> > + self.Val = EFI_HII_DATE()
> >
> > + self.F1 = None # Token
> >
> > + self.F2 = None # Token
> >
> > +
> >
> > + def Date(self):
> >
> > + return self.getToken(VfrSyntaxParser.Date, 0)
> >
> > +
> >
> > + def EndDate(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndDate, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def Year(self):
> >
> > + return self.getToken(VfrSyntaxParser.Year, 0)
> >
> > +
> >
> > + def VarId(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.VarId)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.VarId, i)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def Dot(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Dot)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Dot, i)
> >
> > +
> >
> > + def Prompt(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Prompt)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, i)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Help(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Help)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Help, i)
> >
> > +
> >
> > + def minMaxDateStepDefault(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.MinMaxDateStepDefaultContext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.MinMaxDateStepDefaultContext,i)
> >
> > +
> >
> > +
> >
> > + def Month(self):
> >
> > + return self.getToken(VfrSyntaxParser.Month, 0)
> >
> > +
> >
> > + def Day(self):
> >
> > + return self.getToken(VfrSyntaxParser.Day, 0)
> >
> > +
> >
> > + def vfrDateFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrDateFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInconsistentIf(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext
> > )
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i
> > )
> >
> > +
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementDate
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementDate" ):
> >
> > + return visitor.visitVfrStatementDate(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementDate(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementDateContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 230, self.RULE_vfrStatementDate)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1876
> >
> > + self.match(VfrSyntaxParser.Date)
> >
> > + 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 = 1877
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 1878
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1884
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 1879
> >
> > + localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1880
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1881
> >
> > + self.vfrDateFlags()
> >
> > + self.state = 1882
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1886
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Year]:
> >
> > + self.state = 1888
> >
> > + self.match(VfrSyntaxParser.Year)
> >
> > + self.state = 1889
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 1890
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1891
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1892
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 1893
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1894
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1895
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 1896
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1897
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1898
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1899
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1900
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1901
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1902
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 1903
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1904
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1905
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1906
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1907
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1908
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1909
> >
> > + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 0)
> >
> > + self.state = 1910
> >
> > + self.match(VfrSyntaxParser.Month)
> >
> > + self.state = 1911
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 1912
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1913
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1914
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 1915
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1916
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1917
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 1918
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1919
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1920
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1921
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1922
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1923
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1924
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 1925
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1926
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1927
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1928
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1929
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1930
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1931
> >
> > + self.minMaxDateStepDefault(localctx.Node, localctx.Val, 1)
> >
> > + self.state = 1932
> >
> > + self.match(VfrSyntaxParser.Day)
> >
> > + self.state = 1933
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 1934
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1935
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1936
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 1937
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 1938
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1939
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 1940
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1941
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1942
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1943
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1944
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 1945
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1946
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 1947
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1948
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 1949
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 1950
> >
> > + 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 = 1954
> >
> > + localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 1955
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1956
> >
> > + self.vfrDateFlags()
> >
> > + self.state = 1957
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1964
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.InconsistentIf:
> >
> > + self.state = 1961
> >
> > + self.vfrStatementInconsistentIf()
> >
> > + self.state = 1966
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 1969
> >
> > + self.match(VfrSyntaxParser.EndDate)
> >
> > + self.state = 1970
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class MinMaxDateStepDefaultContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, 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
> >
> > +
> >
> > + def Minimum(self):
> >
> > + return self.getToken(VfrSyntaxParser.Minimum, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Maximum(self):
> >
> > + return self.getToken(VfrSyntaxParser.Maximum, 0)
> >
> > +
> >
> > + def Step(self):
> >
> > + return self.getToken(VfrSyntaxParser.Step, 0)
> >
> > +
> >
> > + def Default(self):
> >
> > + return self.getToken(VfrSyntaxParser.Default, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_minMaxDateStepDefault
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMinMaxDateStepDefault" ):
> >
> > + return visitor.visitMinMaxDateStepDefault(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def minMaxDateStepDefault(self, Node, 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 = 1972
> >
> > + self.match(VfrSyntaxParser.Minimum)
> >
> > + self.state = 1973
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1974
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1975
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1976
> >
> > + self.match(VfrSyntaxParser.Maximum)
> >
> > + self.state = 1977
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1978
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1979
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 1984
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Step:
> >
> > + self.state = 1980
> >
> > + self.match(VfrSyntaxParser.Step)
> >
> > + self.state = 1981
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1982
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1983
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 1990
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Default:
> >
> > + self.state = 1986
> >
> > + self.match(VfrSyntaxParser.Default)
> >
> > + self.state = 1987
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 1988
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 1989
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrDateFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.LFlags = 0
> >
> > +
> >
> > + def dateFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.DateFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.DateFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrDateFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrDateFlags" ):
> >
> > + return visitor.visitVfrDateFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrDateFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrDateFlagsContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 234, self.RULE_vfrDateFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 1992
> >
> > + self.dateFlagsField()
> >
> > + self.state = 1997
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 1993
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 1994
> >
> > + self.dateFlagsField()
> >
> > + self.state = 1999
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DateFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.LFlag = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def YearSupppressFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.YearSupppressFlag, 0)
> >
> > +
> >
> > + def MonthSuppressFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.MonthSuppressFlag, 0)
> >
> > +
> >
> > + def DaySuppressFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.DaySuppressFlag, 0)
> >
> > +
> >
> > + def StorageNormalFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
> >
> > +
> >
> > + def StorageTimeFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
> >
> > +
> >
> > + def StorageWakeUpFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dateFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDateFlagsField" ):
> >
> > + return visitor.visitDateFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dateFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DateFlagsFieldContext(self, self._ctx,
> self.state)
> >
> > + self.enterRule(localctx, 236, self.RULE_dateFlagsField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementTimeContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_TIME_OP)
> >
> > + self.QType = EFI_QUESION_TYPE.QUESTION_TIME
> >
> > + self.Val = EFI_HII_TIME()
> >
> > + self.F1 = None # Token
> >
> > + self.F2 = None # Token
> >
> > +
> >
> > + def Time(self):
> >
> > + return self.getToken(VfrSyntaxParser.Time, 0)
> >
> > +
> >
> > + def EndTime(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndTime, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def vfrQuestionHeader(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionHeaderContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementQuestionOptionList(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionListCo
> > ntext,0)
> >
> > +
> >
> > +
> >
> > + def Hour(self):
> >
> > + return self.getToken(VfrSyntaxParser.Hour, 0)
> >
> > +
> >
> > + def VarId(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.VarId)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.VarId, i)
> >
> > +
> >
> > + def StringIdentifier(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringIdentifier)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, i)
> >
> > +
> >
> > + def Dot(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Dot)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Dot, i)
> >
> > +
> >
> > + def Prompt(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Prompt)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, i)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Help(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Help)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Help, i)
> >
> > +
> >
> > + def minMaxTimeStepDefault(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.MinMaxTimeStepDefaultContext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.MinMaxTimeStepDefaultContext,i)
> >
> > +
> >
> > +
> >
> > + def Minute(self):
> >
> > + return self.getToken(VfrSyntaxParser.Minute, 0)
> >
> > +
> >
> > + def Second(self):
> >
> > + return self.getToken(VfrSyntaxParser.Second, 0)
> >
> > +
> >
> > + def vfrTimeFlags(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrTimeFlagsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInconsistentIf(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementInconsistentIfContext
> > )
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContext,i
> > )
> >
> > +
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementTime
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementTime" ):
> >
> > + return visitor.visitVfrStatementTime(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementTime(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementTimeContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 238, self.RULE_vfrStatementTime)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2002
> >
> > + self.match(VfrSyntaxParser.Time)
> >
> > + 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 = 2003
> >
> > + self.vfrQuestionHeader(localctx.Node, localctx.QType)
> >
> > + self.state = 2004
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2010
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 2005
> >
> > + localctx.F1 = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2006
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2007
> >
> > + self.vfrTimeFlags()
> >
> > + self.state = 2008
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2012
> >
> > + self.vfrStatementQuestionOptionList(localctx.Node)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Hour]:
> >
> > + self.state = 2014
> >
> > + self.match(VfrSyntaxParser.Hour)
> >
> > + self.state = 2015
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 2016
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2017
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2018
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 2019
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2020
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2021
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 2022
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2023
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2024
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2025
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2026
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2027
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2028
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 2029
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2030
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2031
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2032
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2033
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2034
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2035
> >
> > + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 0)
> >
> > + self.state = 2036
> >
> > + self.match(VfrSyntaxParser.Minute)
> >
> > + self.state = 2037
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 2038
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2039
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2040
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 2041
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2042
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2043
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 2044
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2045
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2046
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2047
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2048
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2049
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2050
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 2051
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2052
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2053
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2054
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2055
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2056
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2057
> >
> > + self.minMaxTimeStepDefault(localctx.Node, localctx.Val, 1)
> >
> > + self.state = 2058
> >
> > + self.match(VfrSyntaxParser.Second)
> >
> > + self.state = 2059
> >
> > + self.match(VfrSyntaxParser.VarId)
> >
> > + self.state = 2060
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2061
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2062
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 2063
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2064
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2065
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 2066
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2067
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2068
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2069
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2070
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2071
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2072
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 2073
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2074
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2075
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2076
> >
> > + 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 = 2080
> >
> > + localctx.F2 = self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2081
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2082
> >
> > + self.vfrTimeFlags()
> >
> > + self.state = 2083
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2090
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.InconsistentIf:
> >
> > + self.state = 2087
> >
> > + self.vfrStatementInconsistentIf()
> >
> > + self.state = 2092
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 2095
> >
> > + self.match(VfrSyntaxParser.EndTime)
> >
> > + self.state = 2096
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class MinMaxTimeStepDefaultContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, 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
> >
> > +
> >
> > + def Minimum(self):
> >
> > + return self.getToken(VfrSyntaxParser.Minimum, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Maximum(self):
> >
> > + return self.getToken(VfrSyntaxParser.Maximum, 0)
> >
> > +
> >
> > + def Step(self):
> >
> > + return self.getToken(VfrSyntaxParser.Step, 0)
> >
> > +
> >
> > + def Default(self):
> >
> > + return self.getToken(VfrSyntaxParser.Default, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_minMaxTimeStepDefault
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMinMaxTimeStepDefault" ):
> >
> > + return visitor.visitMinMaxTimeStepDefault(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def minMaxTimeStepDefault(self, Node, 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 = 2098
> >
> > + self.match(VfrSyntaxParser.Minimum)
> >
> > + self.state = 2099
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2100
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2101
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2102
> >
> > + self.match(VfrSyntaxParser.Maximum)
> >
> > + self.state = 2103
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2104
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2105
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2110
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Step:
> >
> > + self.state = 2106
> >
> > + self.match(VfrSyntaxParser.Step)
> >
> > + self.state = 2107
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2108
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2109
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2116
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Default:
> >
> > + self.state = 2112
> >
> > + self.match(VfrSyntaxParser.Default)
> >
> > + self.state = 2113
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2114
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2115
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrTimeFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.LFlags = 0
> >
> > +
> >
> > + def timeFlagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.TimeFlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.TimeFlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrTimeFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrTimeFlags" ):
> >
> > + return visitor.visitVfrTimeFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrTimeFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrTimeFlagsContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 242, self.RULE_vfrTimeFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2118
> >
> > + self.timeFlagsField()
> >
> > + self.state = 2123
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2119
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2120
> >
> > + self.timeFlagsField()
> >
> > + self.state = 2125
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class TimeFlagsFieldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.LFlag = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def HourSupppressFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.HourSupppressFlag, 0)
> >
> > +
> >
> > + def MinuteSuppressFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.MinuteSuppressFlag, 0)
> >
> > +
> >
> > + def SecondSuppressFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.SecondSuppressFlag, 0)
> >
> > +
> >
> > + def StorageNormalFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.StorageNormalFlag, 0)
> >
> > +
> >
> > + def StorageTimeFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.StorageTimeFlag, 0)
> >
> > +
> >
> > + def StorageWakeUpFlag(self):
> >
> > + return self.getToken(VfrSyntaxParser.StorageWakeUpFlag, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_timeFlagsField
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitTimeFlagsField" ):
> >
> > + return visitor.visitTimeFlagsField(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def timeFlagsField(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.TimeFlagsFieldContext(self, self._ctx,
> self.state)
> >
> > + self.enterRule(localctx, 244, self.RULE_timeFlagsField)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementConditionalContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementDisableIfStat(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfStat(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementGrayOutIfStat(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInconsistentIfStat(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatCont
> > ext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementConditional
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementConditional" ):
> >
> > + return visitor.visitVfrStatementConditional(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementConditional(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementConditionalContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 246, self.RULE_vfrStatementConditional)
> >
> > + try:
> >
> > + self.state = 2132
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.DisableIf]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2128
> >
> > + self.vfrStatementDisableIfStat()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.SuppressIf]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2129
> >
> > + self.vfrStatementSuppressIfStat()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GrayOutIf]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2130
> >
> > + self.vfrStatementGrayOutIfStat()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.InconsistentIf]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2131
> >
> > + self.vfrStatementInconsistentIfStat()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementConditionalNewContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementDisableIfStat(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfStatContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfStatNew(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewCon
> > text,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementGrayOutIfStatNew(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewCont
> > ext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInconsistentIfStat(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatCont
> > ext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementConditionalNew
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementConditionalNew" ):
> >
> > + return visitor.visitVfrStatementConditionalNew(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementConditionalNew(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementConditionalNewContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 248, self.RULE_vfrStatementConditionalNew)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2134
> >
> > + self.vfrStatementDisableIfStat()
> >
> > + self.state = 2135
> >
> > + self.vfrStatementSuppressIfStatNew()
> >
> > + self.state = 2136
> >
> > + self.vfrStatementGrayOutIfStatNew()
> >
> > + self.state = 2137
> >
> > + self.vfrStatementInconsistentIfStat()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementSuppressIfStatContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementSuppressIfStatNew(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfStatNewCon
> > text,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementSuppressIfStat
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementSuppressIfStat" ):
> >
> > + return visitor.visitVfrStatementSuppressIfStat(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfStat(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementSuppressIfStatContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 250, self.RULE_vfrStatementSuppressIfStat)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2139
> >
> > + self.vfrStatementSuppressIfStatNew()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementGrayOutIfStatContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementGrayOutIfStatNew(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewCont
> > ext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStat
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementGrayOutIfStat" ):
> >
> > + return visitor.visitVfrStatementGrayOutIfStat(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementGrayOutIfStat(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 252, self.RULE_vfrStatementGrayOutIfStat)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2141
> >
> > + self.vfrStatementGrayOutIfStatNew()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStatListContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrStatementStat(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestions(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementConditional(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementConditionalContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementLabel(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementExtension(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalid(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStatList
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStatList" ):
> >
> > + return visitor.visitVfrStatementStatList(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStatList(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStatListContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 254, self.RULE_vfrStatementStatList)
> >
> > + try:
> >
> > + self.state = 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 = 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 = 2144
> >
> > + self.vfrStatementQuestions()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GrayOutIf, VfrSyntaxParser.SuppressIf,
> > VfrSyntaxParser.DisableIf, VfrSyntaxParser.InconsistentIf]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2145
> >
> > + self.vfrStatementConditional()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Label]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2146
> >
> > + self.vfrStatementLabel()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GuidOp]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 2147
> >
> > + self.vfrStatementExtension()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> > VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 2148
> >
> > + self.vfrStatementInvalid()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementStatListOldContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def vfrStatementStat(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementQuestions(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionsContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementLabel(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementLabelContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalid(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementStatListOld
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementStatListOld" ):
> >
> > + return visitor.visitVfrStatementStatListOld(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementStatListOld(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementStatListOldContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 256, self.RULE_vfrStatementStatListOld)
> >
> > + try:
> >
> > + self.state = 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 = 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 = 2152
> >
> > + self.vfrStatementQuestions()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Label]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2153
> >
> > + self.vfrStatementLabel()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Inventory, VfrSyntaxParser.Hidden,
> > VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2154
> >
> > + self.vfrStatementInvalid()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementDisableIfStatContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_DISABLE_IF_OP)
> >
> > +
> >
> > + def DisableIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.DisableIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def vfrStatementStatList(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementDisableIfStat
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementDisableIfStat" ):
> >
> > + return visitor.visitVfrStatementDisableIfStat(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementDisableIfStat(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementDisableIfStatContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 258, self.RULE_vfrStatementDisableIfStat)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2157
> >
> > + self.match(VfrSyntaxParser.DisableIf)
> >
> > + self.state = 2158
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2159
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + 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 = 2160
> >
> > + self.vfrStatementStatList()
> >
> > + self.state = 2165
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2166
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 2167
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementgrayoutIfSuppressIfContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def SuppressIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementgrayoutIfSuppressIf
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementgrayoutIfSuppressIf" ):
> >
> > + return visitor.visitVfrStatementgrayoutIfSuppressIf(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementgrayoutIfSuppressIf(self):
> >
> > +
> >
> > + localctx =
> VfrSyntaxParser.VfrStatementgrayoutIfSuppressIfContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 260,
> self.RULE_vfrStatementgrayoutIfSuppressIf)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2169
> >
> > + self.match(VfrSyntaxParser.SuppressIf)
> >
> > + self.state = 2182
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 2170
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2171
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2172
> >
> > + self.flagsField()
> >
> > + self.state = 2177
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2173
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2174
> >
> > + self.flagsField()
> >
> > + self.state = 2179
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2180
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2184
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2185
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementsuppressIfGrayOutIfContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def GrayOutIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementsuppressIfGrayOutIf
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementsuppressIfGrayOutIf" ):
> >
> > + return visitor.visitVfrStatementsuppressIfGrayOutIf(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementsuppressIfGrayOutIf(self):
> >
> > +
> >
> > + localctx =
> VfrSyntaxParser.VfrStatementsuppressIfGrayOutIfContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 262,
> self.RULE_vfrStatementsuppressIfGrayOutIf)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2187
> >
> > + self.match(VfrSyntaxParser.GrayOutIf)
> >
> > + self.state = 2200
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 2188
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2189
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2190
> >
> > + self.flagsField()
> >
> > + self.state = 2195
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2191
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2192
> >
> > + self.flagsField()
> >
> > + self.state = 2197
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2198
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2202
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2203
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementSuppressIfStatNewContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_SUPPRESS_IF_OP)
> >
> > +
> >
> > + def SuppressIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.SuppressIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def vfrStatementStatList(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementSuppressIfStatNew
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementSuppressIfStatNew" ):
> >
> > + return visitor.visitVfrStatementSuppressIfStatNew(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementSuppressIfStatNew(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementSuppressIfStatNewContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 264,
> self.RULE_vfrStatementSuppressIfStatNew)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2205
> >
> > + self.match(VfrSyntaxParser.SuppressIf)
> >
> > + self.state = 2218
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 2206
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2207
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2208
> >
> > + self.flagsField()
> >
> > + self.state = 2213
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2209
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2210
> >
> > + self.flagsField()
> >
> > + self.state = 2215
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2216
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2220
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2221
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + 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 = 2222
> >
> > + self.vfrStatementStatList()
> >
> > + self.state = 2227
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2228
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 2229
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementGrayOutIfStatNewContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GRAY_OUT_IF_OP)
> >
> > +
> >
> > + def GrayOutIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.GrayOutIf, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def vfrStatementStatList(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementStatListContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementStatListContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementGrayOutIfStatNew
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementGrayOutIfStatNew" ):
> >
> > + return visitor.visitVfrStatementGrayOutIfStatNew(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementGrayOutIfStatNew(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 266, self.RULE_vfrStatementGrayOutIfStatNew)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2231
> >
> > + self.match(VfrSyntaxParser.GrayOutIf)
> >
> > + self.state = 2244
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 2232
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2233
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2234
> >
> > + self.flagsField()
> >
> > + self.state = 2239
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2235
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2236
> >
> > + self.flagsField()
> >
> > + self.state = 2241
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2242
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2246
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2247
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + 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 = 2248
> >
> > + self.vfrStatementStatList()
> >
> > + self.state = 2253
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2254
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 2255
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementInconsistentIfStatContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_INCONSISTENT_IF_OP)
> >
> > +
> >
> > + def InconsistentIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.InconsistentIf, 0)
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementExpression(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,0)
> >
> > +
> >
> > +
> >
> > + def EndIf(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndIf, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementInconsistentIfStat
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementInconsistentIfStat" ):
> >
> > + return visitor.visitVfrStatementInconsistentIfStat(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementInconsistentIfStat(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementInconsistentIfStatContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 268, self.RULE_vfrStatementInconsistentIfStat)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2257
> >
> > + self.match(VfrSyntaxParser.InconsistentIf)
> >
> > + self.state = 2258
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 2259
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2260
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2261
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2262
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2263
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2264
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2277
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.FLAGS:
> >
> > + self.state = 2265
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2266
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2267
> >
> > + self.flagsField()
> >
> > + self.state = 2272
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2268
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2269
> >
> > + self.flagsField()
> >
> > + self.state = 2274
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2275
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2279
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2280
> >
> > + self.match(VfrSyntaxParser.EndIf)
> >
> > + self.state = 2281
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementInvalidContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def vfrStatementInvalidHidden(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidHiddenContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalidInventory(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidInventoryConte
> > xt,0)
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalidSaveRestoreDefaults(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidSaveRestoreDef
> > aultsContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementInvalid
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementInvalid" ):
> >
> > + return visitor.visitVfrStatementInvalid(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalid(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementInvalidContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 270, self.RULE_vfrStatementInvalid)
> >
> > + try:
> >
> > + self.state = 2286
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Hidden]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2283
> >
> > + self.vfrStatementInvalidHidden()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Inventory]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2284
> >
> > + self.vfrStatementInvalidInventory()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Restore, VfrSyntaxParser.Save]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2285
> >
> > + self.vfrStatementInvalidSaveRestoreDefaults()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementInvalidHiddenContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def Hidden(self):
> >
> > + return self.getToken(VfrSyntaxParser.Hidden, 0)
> >
> > +
> >
> > + def Value(self):
> >
> > + return self.getToken(VfrSyntaxParser.Value, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementInvalidHidden
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementInvalidHidden" ):
> >
> > + return visitor.visitVfrStatementInvalidHidden(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalidHidden(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementInvalidHiddenContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 272, self.RULE_vfrStatementInvalidHidden)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2288
> >
> > + self.match(VfrSyntaxParser.Hidden)
> >
> > + self.state = 2289
> >
> > + self.match(VfrSyntaxParser.Value)
> >
> > + self.state = 2290
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2291
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2292
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2293
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 2294
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2295
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2296
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementInvalidInventoryContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def Inventory(self):
> >
> > + return self.getToken(VfrSyntaxParser.Inventory, 0)
> >
> > +
> >
> > + def Help(self):
> >
> > + return self.getToken(VfrSyntaxParser.Help, 0)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Text(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Text)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Text, i)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementInvalidInventory
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementInvalidInventory" ):
> >
> > + return visitor.visitVfrStatementInvalidInventory(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalidInventory(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementInvalidInventoryContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 274, self.RULE_vfrStatementInvalidInventory)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2298
> >
> > + self.match(VfrSyntaxParser.Inventory)
> >
> > + self.state = 2299
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 2300
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2301
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2302
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2303
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2304
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2305
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2306
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 2307
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2308
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2309
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2310
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2311
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2312
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2319
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Text:
> >
> > + self.state = 2313
> >
> > + self.match(VfrSyntaxParser.Text)
> >
> > + self.state = 2314
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2315
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2316
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2317
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2318
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > +
> >
> > +
> >
> > + self.state = 2321
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class
> VfrStatementInvalidSaveRestoreDefaultsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > +
> >
> > + def Defaults(self):
> >
> > + return self.getToken(VfrSyntaxParser.Defaults, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def FormId(self):
> >
> > + return self.getToken(VfrSyntaxParser.FormId, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def Prompt(self):
> >
> > + return self.getToken(VfrSyntaxParser.Prompt, 0)
> >
> > +
> >
> > + def StringToken(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.StringToken)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, i)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def Help(self):
> >
> > + return self.getToken(VfrSyntaxParser.Help, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Save(self):
> >
> > + return self.getToken(VfrSyntaxParser.Save, 0)
> >
> > +
> >
> > + def Restore(self):
> >
> > + return self.getToken(VfrSyntaxParser.Restore, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def flagsField(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FlagsFieldContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FlagsFieldContext,i)
> >
> > +
> >
> > +
> >
> > + def Key(self):
> >
> > + return self.getToken(VfrSyntaxParser.Key, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return
> VfrSyntaxParser.RULE_vfrStatementInvalidSaveRestoreDefaults
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementInvalidSaveRestoreDefaults" ):
> >
> > + return visitor.visitVfrStatementInvalidSaveRestoreDefaults(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementInvalidSaveRestoreDefaults(self):
> >
> > +
> >
> > + localctx =
> > VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext(self,
> self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 276,
> > self.RULE_vfrStatementInvalidSaveRestoreDefaults)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 2324
> >
> > + self.match(VfrSyntaxParser.Defaults)
> >
> > + self.state = 2325
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2326
> >
> > + self.match(VfrSyntaxParser.FormId)
> >
> > + self.state = 2327
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2328
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2329
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2330
> >
> > + self.match(VfrSyntaxParser.Prompt)
> >
> > + self.state = 2331
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2332
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2333
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2334
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2335
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2336
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2337
> >
> > + self.match(VfrSyntaxParser.Help)
> >
> > + self.state = 2338
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2339
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2340
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2341
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2342
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2354
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 2343
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2344
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2345
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2346
> >
> > + self.flagsField()
> >
> > + self.state = 2351
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2347
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2348
> >
> > + self.flagsField()
> >
> > + self.state = 2353
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > +
> >
> > +
> >
> > + self.state = 2360
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 2356
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2357
> >
> > + self.match(VfrSyntaxParser.Key)
> >
> > + self.state = 2358
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2359
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > +
> >
> > +
> >
> > + self.state = 2362
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementLabelContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > +
> >
> > + def Label(self):
> >
> > + return self.getToken(VfrSyntaxParser.Label, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementLabel
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementLabel" ):
> >
> > + return visitor.visitVfrStatementLabel(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementLabel(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementLabelContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 278, self.RULE_vfrStatementLabel)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2364
> >
> > + self.match(VfrSyntaxParser.Label)
> >
> > + self.state = 2365
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2366
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementBannerContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > +
> >
> > + def Banner(self):
> >
> > + return self.getToken(VfrSyntaxParser.Banner, 0)
> >
> > +
> >
> > + def Title(self):
> >
> > + return self.getToken(VfrSyntaxParser.Title, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Line(self):
> >
> > + return self.getToken(VfrSyntaxParser.Line, 0)
> >
> > +
> >
> > + def Align(self):
> >
> > + return self.getToken(VfrSyntaxParser.Align, 0)
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Timeout(self):
> >
> > + return self.getToken(VfrSyntaxParser.Timeout, 0)
> >
> > +
> >
> > + def Left(self):
> >
> > + return self.getToken(VfrSyntaxParser.Left, 0)
> >
> > +
> >
> > + def Center(self):
> >
> > + return self.getToken(VfrSyntaxParser.Center, 0)
> >
> > +
> >
> > + def Right(self):
> >
> > + return self.getToken(VfrSyntaxParser.Right, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementBanner
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementBanner" ):
> >
> > + return visitor.visitVfrStatementBanner(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementBanner(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementBannerContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 280, self.RULE_vfrStatementBanner)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2368
> >
> > + self.match(VfrSyntaxParser.Banner)
> >
> > + self.state = 2370
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 2369
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2372
> >
> > + self.match(VfrSyntaxParser.Title)
> >
> > + self.state = 2373
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2374
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2375
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2376
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2377
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2378
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2389
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Line]:
> >
> > + self.state = 2379
> >
> > + self.match(VfrSyntaxParser.Line)
> >
> > + self.state = 2380
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2381
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2382
> >
> > + self.match(VfrSyntaxParser.Align)
> >
> > + 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 = 2384
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Timeout]:
> >
> > + self.state = 2385
> >
> > + self.match(VfrSyntaxParser.Timeout)
> >
> > + self.state = 2386
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2387
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2388
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementExtensionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GUID_OP)
> >
> > + self.Buffer = None
> >
> > + self.Size = 0
> >
> > + self.TypeName = ''
> >
> > + self.TypeSize = 0
> >
> > + self.IsStruct = False
> >
> > + self.ArrayNum = 0
> >
> > + self.D = None # Token
> >
> > +
> >
> > + def GuidOp(self):
> >
> > + return self.getToken(VfrSyntaxParser.GuidOp, 0)
> >
> > +
> >
> > + def Uuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def EndGuidOp(self):
> >
> > + return self.getToken(VfrSyntaxParser.EndGuidOp, 0)
> >
> > +
> >
> > + def DataType(self):
> >
> > + return self.getToken(VfrSyntaxParser.DataType, 0)
> >
> > +
> >
> > + def Uint64(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint64, 0)
> >
> > +
> >
> > + def Uint32(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint32, 0)
> >
> > +
> >
> > + def Uint16(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint16, 0)
> >
> > +
> >
> > + def Uint8(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uint8, 0)
> >
> > +
> >
> > + def Boolean(self):
> >
> > + return self.getToken(VfrSyntaxParser.Boolean, 0)
> >
> > +
> >
> > + def EFI_STRING_ID(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_STRING_ID, 0)
> >
> > +
> >
> > + def EFI_HII_DATE(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_DATE, 0)
> >
> > +
> >
> > + def EFI_HII_TIME(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_TIME, 0)
> >
> > +
> >
> > + def EFI_HII_REF(self):
> >
> > + return self.getToken(VfrSyntaxParser.EFI_HII_REF, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def vfrExtensionData(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrExtensionDataContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExtensionDataContext,i)
> >
> > +
> >
> > +
> >
> > + def vfrStatementExtension(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExtensionContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,i)
> >
> > +
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementExtension
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementExtension" ):
> >
> > + return visitor.visitVfrStatementExtension(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementExtension(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementExtensionContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 282, self.RULE_vfrStatementExtension)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2391
> >
> > + self.match(VfrSyntaxParser.GuidOp)
> >
> > + self.state = 2392
> >
> > + self.match(VfrSyntaxParser.Uuid)
> >
> > + self.state = 2393
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2394
> >
> > + self.guidDefinition()
> >
> > + self.state = 2466
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
> >
> > + if la_ == 1:
> >
> > + self.state = 2395
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2396
> >
> > + localctx.D = self.match(VfrSyntaxParser.DataType)
> >
> > + self.state = 2397
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2458
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Uint64]:
> >
> > + self.state = 2398
> >
> > + self.match(VfrSyntaxParser.Uint64)
> >
> > + self.state = 2402
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2399
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2400
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2401
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint32]:
> >
> > + self.state = 2404
> >
> > + self.match(VfrSyntaxParser.Uint32)
> >
> > + self.state = 2408
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2405
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2406
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2407
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint16]:
> >
> > + self.state = 2410
> >
> > + self.match(VfrSyntaxParser.Uint16)
> >
> > + self.state = 2414
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2411
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2412
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2413
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Uint8]:
> >
> > + self.state = 2416
> >
> > + self.match(VfrSyntaxParser.Uint8)
> >
> > + self.state = 2420
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2417
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2418
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2419
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Boolean]:
> >
> > + self.state = 2422
> >
> > + self.match(VfrSyntaxParser.Boolean)
> >
> > + self.state = 2426
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2423
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2424
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2425
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_STRING_ID]:
> >
> > + self.state = 2428
> >
> > + self.match(VfrSyntaxParser.EFI_STRING_ID)
> >
> > + self.state = 2432
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2429
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2430
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2431
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_DATE]:
> >
> > + self.state = 2434
> >
> > + self.match(VfrSyntaxParser.EFI_HII_DATE)
> >
> > + self.state = 2438
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2435
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2436
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2437
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_TIME]:
> >
> > + self.state = 2440
> >
> > + self.match(VfrSyntaxParser.EFI_HII_TIME)
> >
> > + self.state = 2444
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2441
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2442
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2443
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.EFI_HII_REF]:
> >
> > + self.state = 2446
> >
> > + self.match(VfrSyntaxParser.EFI_HII_REF)
> >
> > + self.state = 2450
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2447
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2448
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2449
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.StringIdentifier]:
> >
> > + self.state = 2452
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2456
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2453
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2454
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2455
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 2463
> >
> > + self._errHandler.sync(self)
> >
> > + _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
> >
> > + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
> >
> > + if _alt==1:
> >
> > + self.state = 2460
> >
> > + self.vfrExtensionData()
> >
> > + self.state = 2465
> >
> > + self._errHandler.sync(self)
> >
> > + _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
> >
> > +
> >
> > +
> >
> > +
> >
> > + self.state = 2476
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Comma:
> >
> > + self.state = 2468
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2472
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.GuidOp:
> >
> > + self.state = 2469
> >
> > + self.vfrStatementExtension()
> >
> > + self.state = 2474
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2475
> >
> > + self.match(VfrSyntaxParser.EndGuidOp)
> >
> > +
> >
> > +
> >
> > + self.state = 2478
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExtensionDataContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.TFName = ''
> >
> > + self.FName = ''
> >
> > + self.TFValue = None
> >
> > + self.I = None # Token
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def Data(self):
> >
> > + return self.getToken(VfrSyntaxParser.Data, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def Dot(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Dot)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Dot, i)
> >
> > +
> >
> > + def arrayName(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExtensionData
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExtensionData" ):
> >
> > + return visitor.visitVfrExtensionData(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExtensionData(self):
> >
> > +
> >
> > + 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 = 2480
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2481
> >
> > + self.match(VfrSyntaxParser.Data)
> >
> > + self.state = 2485
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.OpenBracket:
> >
> > + self.state = 2482
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2483
> >
> > + localctx.I = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2484
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + self.state = 2491
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.Dot:
> >
> > + self.state = 2487
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 2488
> >
> > + self.arrayName()
> >
> > + self.state = 2493
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2494
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2495
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementModalContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = None
> >
> > +
> >
> > + def vfrModalTag(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrModalTagContext,0)
> >
> > +
> >
> > +
> >
> > + def Semicolon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementModal
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementModal" ):
> >
> > + return visitor.visitVfrStatementModal(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementModal(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrStatementModalContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 286, self.RULE_vfrStatementModal)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2497
> >
> > + self.vfrModalTag()
> >
> > + self.state = 2498
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrModalTagContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Node = IfrTreeNode(EFI_IFR_MODAL_TAG_OP)
> >
> > +
> >
> > + def Modal(self):
> >
> > + return self.getToken(VfrSyntaxParser.Modal, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrModalTag
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrModalTag" ):
> >
> > + return visitor.visitVfrModalTag(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrModalTag(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrModalTagContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 288, self.RULE_vfrModalTag)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2500
> >
> > + self.match(VfrSyntaxParser.Modal)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementExpressionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, 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:
> >
> > + return
> self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
> >
> > + else:
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
> >
> > +
> >
> > +
> >
> > + def OR(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OR)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OR, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementExpression
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementExpression" ):
> >
> > + return visitor.visitVfrStatementExpression(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementExpression(self, ParentNode):
> >
> > +
> >
> > + 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 = 2502
> >
> > + self.andTerm(localctx.ExpInfo)
> >
> > + self.state = 2507
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.OR:
> >
> > + self.state = 2503
> >
> > + localctx.L = self.match(VfrSyntaxParser.OR)
> >
> > + self.state = 2504
> >
> > + self.andTerm(localctx.ExpInfo)
> >
> > + self.state = 2509
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrStatementExpressionSubContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, 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:
> >
> > + return
> self.getTypedRuleContexts(VfrSyntaxParser.AndTermContext)
> >
> > + else:
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.AndTermContext,i)
> >
> > +
> >
> > +
> >
> > + def OR(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OR)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OR, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrStatementExpressionSub
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrStatementExpressionSub" ):
> >
> > + return visitor.visitVfrStatementExpressionSub(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, ParentNodes):
> >
> > +
> >
> > + 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 = 2510
> >
> > + self.andTerm(localctx.ExpInfo)
> >
> > + self.state = 2515
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.OR:
> >
> > + self.state = 2511
> >
> > + self.match(VfrSyntaxParser.OR)
> >
> > + self.state = 2512
> >
> > + self.andTerm(localctx.ExpInfo)
> >
> > + self.state = 2517
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class AndTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.Line = None
> >
> > + self.L = None # Token
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def bitwiseorTerm(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.BitwiseorTermContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.BitwiseorTermContext,i)
> >
> > +
> >
> > +
> >
> > + def AND(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.AND)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.AND, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_andTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitAndTerm" ):
> >
> > + return visitor.visitAndTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def andTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.AndTermContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 294, self.RULE_andTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2518
> >
> > + self.bitwiseorTerm(ExpInfo)
> >
> > + self.state = 2523
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.AND:
> >
> > + self.state = 2519
> >
> > + localctx.L = self.match(VfrSyntaxParser.AND)
> >
> > + self.state = 2520
> >
> > + self.bitwiseorTerm(ExpInfo)
> >
> > + self.state = 2525
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class BitwiseorTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.Line = None
> >
> > + self.L = None # Token
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def bitwiseandTerm(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.BitwiseandTermContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.BitwiseandTermContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_bitwiseorTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitBitwiseorTerm" ):
> >
> > + return visitor.visitBitwiseorTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def bitwiseorTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.BitwiseorTermContext(self, self._ctx,
> self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 296, self.RULE_bitwiseorTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2526
> >
> > + self.bitwiseandTerm(ExpInfo)
> >
> > + self.state = 2531
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2527
> >
> > + localctx.L = self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2528
> >
> > + self.bitwiseandTerm(ExpInfo)
> >
> > + self.state = 2533
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class BitwiseandTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.Line = None
> >
> > + self.L = None # Token
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def equalTerm(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.EqualTermContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.EqualTermContext,i)
> >
> > +
> >
> > +
> >
> > + def BitWiseAnd(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseAnd)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseAnd, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_bitwiseandTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitBitwiseandTerm" ):
> >
> > + return visitor.visitBitwiseandTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def bitwiseandTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.BitwiseandTermContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 298, self.RULE_bitwiseandTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2534
> >
> > + self.equalTerm(ExpInfo)
> >
> > + self.state = 2539
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseAnd:
> >
> > + self.state = 2535
> >
> > + localctx.L = self.match(VfrSyntaxParser.BitWiseAnd)
> >
> > + self.state = 2536
> >
> > + self.equalTerm(ExpInfo)
> >
> > + self.state = 2541
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class EqualTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.Line = None
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def compareTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
> >
> > +
> >
> > +
> >
> > + def equalTermSupplementary(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.EqualTermSupplementaryContext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.EqualTermSupplementaryContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_equalTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitEqualTerm" ):
> >
> > + return visitor.visitEqualTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def equalTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.EqualTermContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 300, self.RULE_equalTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 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 = 2543
> >
> > + self.equalTermSupplementary(ExpInfo)
> >
> > + self.state = 2548
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class EqualTermSupplementaryContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_equalTermSupplementary
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.ExpInfo = ctx.ExpInfo
> >
> > + self.Nodes = ctx.Nodes
> >
> > +
> >
> > +
> >
> > +
> >
> > + class EqualTermEqualRuleContext(EqualTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.EqualTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def Equal(self):
> >
> > + return self.getToken(VfrSyntaxParser.Equal, 0)
> >
> > + def compareTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitEqualTermEqualRule" ):
> >
> > + return visitor.visitEqualTermEqualRule(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> EqualTermNotEqualRuleContext(EqualTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.EqualTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def NotEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.NotEqual, 0)
> >
> > + def compareTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.CompareTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitEqualTermNotEqualRule" ):
> >
> > + return visitor.visitEqualTermNotEqualRule(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def equalTermSupplementary(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.EqualTermSupplementaryContext(self,
> > self._ctx, self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 302, self.RULE_equalTermSupplementary)
> >
> > + try:
> >
> > + 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 = 2549
> >
> > + self.match(VfrSyntaxParser.Equal)
> >
> > + self.state = 2550
> >
> > + self.compareTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NotEqual]:
> >
> > + localctx = VfrSyntaxParser.EqualTermNotEqualRuleContext(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2551
> >
> > + self.match(VfrSyntaxParser.NotEqual)
> >
> > + self.state = 2552
> >
> > + self.compareTerm(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class CompareTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def shiftTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
> >
> > +
> >
> > +
> >
> > + def compareTermSupplementary(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.CompareTermSupplementaryCont
> > ext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.CompareTermSupplementaryConte
> > xt,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_compareTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCompareTerm" ):
> >
> > + return visitor.visitCompareTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def compareTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.CompareTermContext(self, self._ctx,
> self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 304, self.RULE_compareTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2555
> >
> > + self.shiftTerm(ExpInfo)
> >
> > + 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 = 2556
> >
> > + self.compareTermSupplementary(ExpInfo)
> >
> > + self.state = 2561
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class CompareTermSupplementaryContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_compareTermSupplementary
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.ExpInfo = ctx.ExpInfo
> >
> > + self.Nodes = ctx.Nodes
> >
> > +
> >
> > +
> >
> > +
> >
> > + class
> > CompareTermLessRuleContext(CompareTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.CompareTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def Less(self):
> >
> > + return self.getToken(VfrSyntaxParser.Less, 0)
> >
> > + def shiftTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCompareTermLessRule" ):
> >
> > + return visitor.visitCompareTermLessRule(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> >
> CompareTermGreaterEqualRuleContext(CompareTermSupplementaryContext
> > ):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.CompareTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def GreaterEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
> >
> > + def shiftTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCompareTermGreaterEqualRule" ):
> >
> > + return visitor.visitCompareTermGreaterEqualRule(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> > CompareTermGreaterRuleContext(CompareTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.CompareTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def Greater(self):
> >
> > + return self.getToken(VfrSyntaxParser.Greater, 0)
> >
> > + def shiftTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCompareTermGreaterRule" ):
> >
> > + return visitor.visitCompareTermGreaterRule(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> > CompareTermLessEqualRuleContext(CompareTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.CompareTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def LessEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.LessEqual, 0)
> >
> > + def shiftTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCompareTermLessEqualRule" ):
> >
> > + return visitor.visitCompareTermLessEqualRule(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def compareTermSupplementary(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.CompareTermSupplementaryContext(self,
> > self._ctx, self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 306, self.RULE_compareTermSupplementary)
> >
> > + try:
> >
> > + 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 = 2562
> >
> > + self.match(VfrSyntaxParser.Less)
> >
> > + self.state = 2563
> >
> > + self.shiftTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LessEqual]:
> >
> > + localctx =
> VfrSyntaxParser.CompareTermLessEqualRuleContext(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2564
> >
> > + self.match(VfrSyntaxParser.LessEqual)
> >
> > + self.state = 2565
> >
> > + self.shiftTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Greater]:
> >
> > + localctx = VfrSyntaxParser.CompareTermGreaterRuleContext(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2566
> >
> > + self.match(VfrSyntaxParser.Greater)
> >
> > + self.state = 2567
> >
> > + self.shiftTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GreaterEqual]:
> >
> > + localctx =
> > VfrSyntaxParser.CompareTermGreaterEqualRuleContext(self, localctx)
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2568
> >
> > + self.match(VfrSyntaxParser.GreaterEqual)
> >
> > + self.state = 2569
> >
> > + self.shiftTerm(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ShiftTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def addMinusTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
> >
> > +
> >
> > +
> >
> > + def shiftTermSupplementary(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.ShiftTermSupplementaryContext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.ShiftTermSupplementaryContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_shiftTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitShiftTerm" ):
> >
> > + return visitor.visitShiftTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def shiftTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ShiftTermContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 308, self.RULE_shiftTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2572
> >
> > + self.addMinusTerm(ExpInfo)
> >
> > + self.state = 2576
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.T__9 or _la==VfrSyntaxParser.T__10:
> >
> > + self.state = 2573
> >
> > + self.shiftTermSupplementary(ExpInfo)
> >
> > + self.state = 2578
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ShiftTermSupplementaryContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_shiftTermSupplementary
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.ExpInfo = ctx.ExpInfo
> >
> > + self.Nodes = ctx.Nodes
> >
> > +
> >
> > +
> >
> > +
> >
> > + class ShiftTermRightContext(ShiftTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.ShiftTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def addMinusTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitShiftTermRight" ):
> >
> > + return visitor.visitShiftTermRight(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class ShiftTermLeftContext(ShiftTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.ShiftTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def addMinusTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitShiftTermLeft" ):
> >
> > + return visitor.visitShiftTermLeft(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def shiftTermSupplementary(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ShiftTermSupplementaryContext(self,
> self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 310, self.RULE_shiftTermSupplementary)
> >
> > + try:
> >
> > + 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 = 2579
> >
> > + self.match(VfrSyntaxParser.T__9)
> >
> > + self.state = 2580
> >
> > + self.addMinusTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.T__10]:
> >
> > + localctx = VfrSyntaxParser.ShiftTermRightContext(self, localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2581
> >
> > + self.match(VfrSyntaxParser.T__10)
> >
> > + self.state = 2582
> >
> > + self.addMinusTerm(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class AddMinusTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def multdivmodTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
> >
> > +
> >
> > +
> >
> > + def addMinusTermSupplementary(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.AddMinusTermSupplementaryCon
> > text)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermSupplementaryCont
> > ext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_addMinusTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitAddMinusTerm" ):
> >
> > + return visitor.visitAddMinusTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def addMinusTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.AddMinusTermContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 312, self.RULE_addMinusTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2585
> >
> > + self.multdivmodTerm(ExpInfo)
> >
> > + self.state = 2589
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.T__11 or _la==VfrSyntaxParser.Negative:
> >
> > + self.state = 2586
> >
> > + self.addMinusTermSupplementary(ExpInfo)
> >
> > + self.state = 2591
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class AddMinusTermSupplementaryContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_addMinusTermSupplementary
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.ExpInfo = ctx.ExpInfo
> >
> > + self.Nodes = ctx.Nodes
> >
> > +
> >
> > +
> >
> > +
> >
> > + class
> > AddMinusTermpAddContext(AddMinusTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.AddMinusTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def multdivmodTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitAddMinusTermpAdd" ):
> >
> > + return visitor.visitAddMinusTermpAdd(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> > AddMinusTermSubtractContext(AddMinusTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.AddMinusTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def Negative(self):
> >
> > + return self.getToken(VfrSyntaxParser.Negative, 0)
> >
> > + def multdivmodTerm(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitAddMinusTermSubtract" ):
> >
> > + return visitor.visitAddMinusTermSubtract(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def addMinusTermSupplementary(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.AddMinusTermSupplementaryContext(self,
> > self._ctx, self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 314, self.RULE_addMinusTermSupplementary)
> >
> > + try:
> >
> > + 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 = 2592
> >
> > + self.match(VfrSyntaxParser.T__11)
> >
> > + self.state = 2593
> >
> > + self.multdivmodTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Negative]:
> >
> > + localctx = VfrSyntaxParser.AddMinusTermSubtractContext(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2594
> >
> > + self.match(VfrSyntaxParser.Negative)
> >
> > + self.state = 2595
> >
> > + self.multdivmodTerm(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class MultdivmodTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def castTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
> >
> > +
> >
> > +
> >
> > + def multdivmodTermSupplementary(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.MultdivmodTermSupplementaryC
> > ontext)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermSupplementaryCo
> > ntext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_multdivmodTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMultdivmodTerm" ):
> >
> > + return visitor.visitMultdivmodTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def multdivmodTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.MultdivmodTermContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 316, self.RULE_multdivmodTerm)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2598
> >
> > + self.castTerm(ExpInfo)
> >
> > + 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 = 2599
> >
> > + self.multdivmodTermSupplementary(ExpInfo)
> >
> > + self.state = 2604
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class MultdivmodTermSupplementaryContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_multdivmodTermSupplementary
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.ExpInfo = ctx.ExpInfo
> >
> > + self.Nodes = ctx.Nodes
> >
> > +
> >
> > +
> >
> > +
> >
> > + class
> > MultdivmodTermDivContext(MultdivmodTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.MultdivmodTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def Slash(self):
> >
> > + return self.getToken(VfrSyntaxParser.Slash, 0)
> >
> > + def castTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMultdivmodTermDiv" ):
> >
> > + return visitor.visitMultdivmodTermDiv(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> > MultdivmodTermMulContext(MultdivmodTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.MultdivmodTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def castTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMultdivmodTermMul" ):
> >
> > + return visitor.visitMultdivmodTermMul(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> > MultdivmodTermModuloContext(MultdivmodTermSupplementaryContext):
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.MultdivmodTermSupplementaryContext
> >
> > + super().__init__(parser)
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def castTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.CastTermContext,0)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMultdivmodTermModulo" ):
> >
> > + return visitor.visitMultdivmodTermModulo(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def multdivmodTermSupplementary(self, ExpInfo):
> >
> > +
> >
> > + localctx =
> VfrSyntaxParser.MultdivmodTermSupplementaryContext(self,
> > self._ctx, self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 318,
> self.RULE_multdivmodTermSupplementary)
> >
> > + try:
> >
> > + 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 = 2605
> >
> > + self.match(VfrSyntaxParser.T__12)
> >
> > + self.state = 2606
> >
> > + self.castTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Slash]:
> >
> > + localctx = VfrSyntaxParser.MultdivmodTermDivContext(self,
> localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2607
> >
> > + self.match(VfrSyntaxParser.Slash)
> >
> > + self.state = 2608
> >
> > + self.castTerm(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.T__13]:
> >
> > + localctx = VfrSyntaxParser.MultdivmodTermModuloContext(self,
> > localctx)
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2609
> >
> > + self.match(VfrSyntaxParser.T__13)
> >
> > + self.state = 2610
> >
> > + self.castTerm(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class CastTermContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def atomTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
> >
> > +
> >
> > +
> >
> > + def castTermSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.CastTermSubContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.CastTermSubContext,i)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_castTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitCastTerm" ):
> >
> > + return visitor.visitCastTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def castTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.CastTermContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 320, self.RULE_castTerm)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2616
> >
> > + self._errHandler.sync(self)
> >
> > + _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
> >
> > + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
> >
> > + if _alt==1:
> >
> > + self.state = 2613
> >
> > + self.castTermSub()
> >
> > + self.state = 2618
> >
> > + self._errHandler.sync(self)
> >
> > + _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
> >
> > +
> >
> > + self.state = 2619
> >
> > + self.atomTerm(ExpInfo)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class 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):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionCatenateContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionMatch(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatchContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionMatch2(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMatch2Context,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionParen(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionParenContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionBuildInFunction(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionBuildInFunctionConte
> > xt,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionConstant(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionConstantContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionUnaryOp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionUnaryOpContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionTernaryOp(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionTernaryOpContext,0)
> >
> > +
> >
> > +
> >
> > + def vfrExpressionMap(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrExpressionMapContext,0)
> >
> > +
> >
> > +
> >
> > + def NOT(self):
> >
> > + return self.getToken(VfrSyntaxParser.NOT, 0)
> >
> > +
> >
> > + def atomTerm(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.AtomTermContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_atomTerm
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitAtomTerm" ):
> >
> > + return visitor.visitAtomTerm(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def atomTerm(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.AtomTermContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 324, self.RULE_atomTerm)
> >
> > + try:
> >
> > + self.state = 2636
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Catenate]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2625
> >
> > + self.vfrExpressionCatenate(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Match]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2626
> >
> > + self.vfrExpressionMatch(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Match2]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2627
> >
> > + self.vfrExpressionMatch2(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.OpenParen]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2628
> >
> > + self.vfrExpressionParen(ExpInfo)
> >
> > + pass
> >
> > + 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 = 2629
> >
> > + self.vfrExpressionBuildInFunction(ExpInfo)
> >
> > + pass
> >
> > + 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 = 2630
> >
> > + self.vfrExpressionConstant(ExpInfo)
> >
> > + pass
> >
> > + 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 = 2631
> >
> > + self.vfrExpressionUnaryOp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Cond, VfrSyntaxParser.Find,
> > VfrSyntaxParser.Mid, VfrSyntaxParser.Tok, VfrSyntaxParser.Span]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 2632
> >
> > + self.vfrExpressionTernaryOp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Map]:
> >
> > + self.enterOuterAlt(localctx, 9)
> >
> > + self.state = 2633
> >
> > + self.vfrExpressionMap(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.NOT]:
> >
> > + self.enterOuterAlt(localctx, 10)
> >
> > + self.state = 2634
> >
> > + self.match(VfrSyntaxParser.NOT)
> >
> > + self.state = 2635
> >
> > + self.atomTerm(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionCatenateContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Catenate(self):
> >
> > + return self.getToken(VfrSyntaxParser.Catenate, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionCatenate
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionCatenate" ):
> >
> > + return visitor.visitVfrExpressionCatenate(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionCatenate(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionCatenateContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 326, self.RULE_vfrExpressionCatenate)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2638
> >
> > + self.match(VfrSyntaxParser.Catenate)
> >
> > + self.state = 2639
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2640
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2641
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2642
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2643
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionMatchContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Match(self):
> >
> > + return self.getToken(VfrSyntaxParser.Match, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionMatch
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionMatch" ):
> >
> > + return visitor.visitVfrExpressionMatch(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionMatch(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionMatchContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 328, self.RULE_vfrExpressionMatch)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2645
> >
> > + self.match(VfrSyntaxParser.Match)
> >
> > + self.state = 2646
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2647
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2648
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2649
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2650
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionMatch2Context(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Match2(self):
> >
> > + return self.getToken(VfrSyntaxParser.Match2, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionMatch2
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionMatch2" ):
> >
> > + return visitor.visitVfrExpressionMatch2(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionMatch2(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionMatch2Context(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 330, self.RULE_vfrExpressionMatch2)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2652
> >
> > + self.match(VfrSyntaxParser.Match2)
> >
> > + self.state = 2653
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2654
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2655
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2656
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2657
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2658
> >
> > + self.guidDefinition()
> >
> > + self.state = 2659
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionParenContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionParen
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionParen" ):
> >
> > + return visitor.visitVfrExpressionParen(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionParen(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionParenContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 332, self.RULE_vfrExpressionParen)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2661
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2662
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2663
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionBuildInFunctionContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = None
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def dupExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.DupExpContext,0)
> >
> > +
> >
> > +
> >
> > + def vareqvalExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VareqvalExpContext,0)
> >
> > +
> >
> > +
> >
> > + def ideqvalExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.IdeqvalExpContext,0)
> >
> > +
> >
> > +
> >
> > + def ideqidExp(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.IdeqidExpContext,0)
> >
> > +
> >
> > +
> >
> > + def ideqvallistExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.IdeqvallistExpContext,0)
> >
> > +
> >
> > +
> >
> > + def questionref1Exp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.Questionref1ExpContext,0)
> >
> > +
> >
> > +
> >
> > + def rulerefExp(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.RulerefExpContext,0)
> >
> > +
> >
> > +
> >
> > + def stringref1Exp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.Stringref1ExpContext,0)
> >
> > +
> >
> > +
> >
> > + def pushthisExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.PushthisExpContext,0)
> >
> > +
> >
> > +
> >
> > + def securityExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.SecurityExpContext,0)
> >
> > +
> >
> > +
> >
> > + def getExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.GetExpContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionBuildInFunction
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionBuildInFunction" ):
> >
> > + return visitor.visitVfrExpressionBuildInFunction(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionBuildInFunction(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionBuildInFunctionContext(self,
> > self._ctx, self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 334, self.RULE_vfrExpressionBuildInFunction)
> >
> > + try:
> >
> > + self.state = 2676
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Dup]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2665
> >
> > + self.dupExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.VarEqVal]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2666
> >
> > + self.vareqvalExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.IdEqVal]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2667
> >
> > + self.ideqvalExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.IdEqId]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2668
> >
> > + self.ideqidExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.IdEqValList]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 2669
> >
> > + self.ideqvallistExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.QuestionRef]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 2670
> >
> > + self.questionref1Exp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.RuleRef]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 2671
> >
> > + self.rulerefExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.StringRef]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 2672
> >
> > + self.stringref1Exp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.PushThis]:
> >
> > + self.enterOuterAlt(localctx, 9)
> >
> > + self.state = 2673
> >
> > + self.pushthisExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Security]:
> >
> > + self.enterOuterAlt(localctx, 10)
> >
> > + self.state = 2674
> >
> > + self.securityExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Get]:
> >
> > + self.enterOuterAlt(localctx, 11)
> >
> > + self.state = 2675
> >
> > + self.getExp(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class DupExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = IfrTreeNode(EFI_IFR_DUP_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Dup(self):
> >
> > + return self.getToken(VfrSyntaxParser.Dup, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_dupExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitDupExp" ):
> >
> > + return visitor.visitDupExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def dupExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.DupExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 336, self.RULE_dupExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2678
> >
> > + self.match(VfrSyntaxParser.Dup)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VareqvalExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = None
> >
> > + self.VN = None # Token
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def VarEqVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.VarEqVal, 0)
> >
> > +
> >
> > + def Var(self):
> >
> > + return self.getToken(VfrSyntaxParser.Var, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def 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 Equal(self):
> >
> > + return self.getToken(VfrSyntaxParser.Equal, 0)
> >
> > +
> >
> > + def LessEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.LessEqual, 0)
> >
> > +
> >
> > + def Less(self):
> >
> > + return self.getToken(VfrSyntaxParser.Less, 0)
> >
> > +
> >
> > + def GreaterEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
> >
> > +
> >
> > + def Greater(self):
> >
> > + return self.getToken(VfrSyntaxParser.Greater, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vareqvalExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVareqvalExp" ):
> >
> > + return visitor.visitVareqvalExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vareqvalExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VareqvalExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 338, self.RULE_vareqvalExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2680
> >
> > + self.match(VfrSyntaxParser.VarEqVal)
> >
> > + self.state = 2681
> >
> > + self.match(VfrSyntaxParser.Var)
> >
> > + self.state = 2682
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2683
> >
> > + localctx.VN = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2684
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2695
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Equal]:
> >
> > + self.state = 2685
> >
> > + self.match(VfrSyntaxParser.Equal)
> >
> > + self.state = 2686
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LessEqual]:
> >
> > + self.state = 2687
> >
> > + self.match(VfrSyntaxParser.LessEqual)
> >
> > + self.state = 2688
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Less]:
> >
> > + self.state = 2689
> >
> > + self.match(VfrSyntaxParser.Less)
> >
> > + self.state = 2690
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GreaterEqual]:
> >
> > + self.state = 2691
> >
> > + self.match(VfrSyntaxParser.GreaterEqual)
> >
> > + self.state = 2692
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Greater]:
> >
> > + self.state = 2693
> >
> > + self.match(VfrSyntaxParser.Greater)
> >
> > + self.state = 2694
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class IdeqvalExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = None
> >
> > + self.I = None # Token
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def vfrQuestionDataFieldName(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def IdEqVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.IdEqVal, 0)
> >
> > +
> >
> > + def Equal(self):
> >
> > + return self.getToken(VfrSyntaxParser.Equal, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def LessEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.LessEqual, 0)
> >
> > +
> >
> > + def Less(self):
> >
> > + return self.getToken(VfrSyntaxParser.Less, 0)
> >
> > +
> >
> > + def GreaterEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
> >
> > +
> >
> > + def Greater(self):
> >
> > + return self.getToken(VfrSyntaxParser.Greater, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_ideqvalExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitIdeqvalExp" ):
> >
> > + return visitor.visitIdeqvalExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def ideqvalExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.IdeqvalExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 340, self.RULE_ideqvalExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2697
> >
> > + localctx.I = self.match(VfrSyntaxParser.IdEqVal)
> >
> > + self.state = 2698
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + self.state = 2709
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Equal]:
> >
> > + self.state = 2699
> >
> > + self.match(VfrSyntaxParser.Equal)
> >
> > + self.state = 2700
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LessEqual]:
> >
> > + self.state = 2701
> >
> > + self.match(VfrSyntaxParser.LessEqual)
> >
> > + self.state = 2702
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Less]:
> >
> > + self.state = 2703
> >
> > + self.match(VfrSyntaxParser.Less)
> >
> > + self.state = 2704
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GreaterEqual]:
> >
> > + self.state = 2705
> >
> > + self.match(VfrSyntaxParser.GreaterEqual)
> >
> > + self.state = 2706
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Greater]:
> >
> > + self.state = 2707
> >
> > + self.match(VfrSyntaxParser.Greater)
> >
> > + self.state = 2708
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class IdeqidExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = None
> >
> > + self.I = None # Token
> >
> > + self.E = None # Token
> >
> > + self.LE = None # Token
> >
> > + self.L = None # Token
> >
> > + self.BE = None # Token
> >
> > + self.B = None # Token
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def vfrQuestionDataFieldName(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrQuestionDataFieldNameContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def IdEqId(self):
> >
> > + return self.getToken(VfrSyntaxParser.IdEqId, 0)
> >
> > +
> >
> > + def Equal(self):
> >
> > + return self.getToken(VfrSyntaxParser.Equal, 0)
> >
> > +
> >
> > + def LessEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.LessEqual, 0)
> >
> > +
> >
> > + def Less(self):
> >
> > + return self.getToken(VfrSyntaxParser.Less, 0)
> >
> > +
> >
> > + def GreaterEqual(self):
> >
> > + return self.getToken(VfrSyntaxParser.GreaterEqual, 0)
> >
> > +
> >
> > + def Greater(self):
> >
> > + return self.getToken(VfrSyntaxParser.Greater, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_ideqidExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitIdeqidExp" ):
> >
> > + return visitor.visitIdeqidExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def ideqidExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.IdeqidExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 342, self.RULE_ideqidExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2711
> >
> > + localctx.I = self.match(VfrSyntaxParser.IdEqId)
> >
> > + self.state = 2712
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + self.state = 2723
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Equal]:
> >
> > + self.state = 2713
> >
> > + localctx.E = self.match(VfrSyntaxParser.Equal)
> >
> > + self.state = 2714
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.LessEqual]:
> >
> > + self.state = 2715
> >
> > + localctx.LE = self.match(VfrSyntaxParser.LessEqual)
> >
> > + self.state = 2716
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Less]:
> >
> > + self.state = 2717
> >
> > + localctx.L = self.match(VfrSyntaxParser.Less)
> >
> > + self.state = 2718
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.GreaterEqual]:
> >
> > + self.state = 2719
> >
> > + localctx.BE = self.match(VfrSyntaxParser.GreaterEqual)
> >
> > + self.state = 2720
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Greater]:
> >
> > + self.state = 2721
> >
> > + localctx.B = self.match(VfrSyntaxParser.Greater)
> >
> > + self.state = 2722
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class IdeqvallistExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = None
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def IdEqValList(self):
> >
> > + return self.getToken(VfrSyntaxParser.IdEqValList, 0)
> >
> > +
> >
> > + def vfrQuestionDataFieldName(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def Equal(self):
> >
> > + return self.getToken(VfrSyntaxParser.Equal, 0)
> >
> > +
> >
> > + def Number(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Number)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Number, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_ideqvallistExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitIdeqvallistExp" ):
> >
> > + return visitor.visitIdeqvallistExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def ideqvallistExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.IdeqvallistExpContext(self, self._ctx,
> self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 344, self.RULE_ideqvallistExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2725
> >
> > + self.match(VfrSyntaxParser.IdEqValList)
> >
> > + self.state = 2726
> >
> > + self.vfrQuestionDataFieldName()
> >
> > + self.state = 2727
> >
> > + self.match(VfrSyntaxParser.Equal)
> >
> > + self.state = 2729
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while True:
> >
> > + self.state = 2728
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2731
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if not (_la==VfrSyntaxParser.Number):
> >
> > + break
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrQuestionDataFieldNameContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.QId = EFI_QUESTION_ID_INVALID
> >
> > + self.Mask = 0
> >
> > + self.VarIdStr = ''
> >
> > + self.Line = None
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrQuestionDataFieldName
> >
> > +
> >
> > +
> >
> > + def copyFrom(self, ctx:ParserRuleContext):
> >
> > + super().copyFrom(ctx)
> >
> > + self.QId = ctx.QId
> >
> > + self.Mask = ctx.Mask
> >
> > + self.VarIdStr = ctx.VarIdStr
> >
> > + self.Line = ctx.Line
> >
> > +
> >
> > +
> >
> > +
> >
> > + class
> >
> VfrQuestionDataFieldNameRule2Context(VfrQuestionDataFieldNameContext)
> > :
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.VfrQuestionDataFieldNameContext
> >
> > + super().__init__(parser)
> >
> > + self.SN2 = None # Token
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > + def Dot(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Dot)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Dot, i)
> >
> > + def arrayName(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.ArrayNameContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ArrayNameContext,i)
> >
> > +
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrQuestionDataFieldNameRule2" ):
> >
> > + return visitor.visitVfrQuestionDataFieldNameRule2(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > + class
> >
> VfrQuestionDataFieldNameRule1Context(VfrQuestionDataFieldNameContext)
> > :
> >
> > +
> >
> > + def __init__(self, parser, ctx:ParserRuleContext): # actually a
> > VfrSyntaxParser.VfrQuestionDataFieldNameContext
> >
> > + super().__init__(parser)
> >
> > + self.SN1 = None # Token
> >
> > + self.I = None # Token
> >
> > + self.copyFrom(ctx)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrQuestionDataFieldNameRule1" ):
> >
> > + return visitor.visitVfrQuestionDataFieldNameRule1(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrQuestionDataFieldName(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrQuestionDataFieldNameContext(self,
> > self._ctx, self.state)
> >
> > + self.enterRule(localctx, 346, self.RULE_vfrQuestionDataFieldName)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.state = 2745
> >
> > + self._errHandler.sync(self)
> >
> > + la_ = self._interp.adaptivePredict(self._input,226,self._ctx)
> >
> > + if la_ == 1:
> >
> > + localctx =
> > VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context(self, localctx)
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2733
> >
> > + localctx.SN1 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2734
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2735
> >
> > + localctx.I = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2736
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > + pass
> >
> > +
> >
> > + elif la_ == 2:
> >
> > + localctx =
> > VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context(self, localctx)
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2737
> >
> > + localctx.SN2 = self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2742
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.Dot:
> >
> > + self.state = 2738
> >
> > + self.match(VfrSyntaxParser.Dot)
> >
> > + self.state = 2739
> >
> > + self.arrayName()
> >
> > + self.state = 2744
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + pass
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ArrayNameContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.SubStr = ''
> >
> > + self.SubStrZ = ''
> >
> > + self.N = None # Token
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def OpenBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenBracket, 0)
> >
> > +
> >
> > + def CloseBracket(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseBracket, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_arrayName
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitArrayName" ):
> >
> > + return visitor.visitArrayName(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def arrayName(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ArrayNameContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 348, self.RULE_arrayName)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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 = 2748
> >
> > + self.match(VfrSyntaxParser.OpenBracket)
> >
> > + self.state = 2749
> >
> > + localctx.N = self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2750
> >
> > + self.match(VfrSyntaxParser.CloseBracket)
> >
> > +
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class Questionref1ExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = IfrTreeNode(EFI_IFR_QUESTION_REF1_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def QuestionRef(self):
> >
> > + return self.getToken(VfrSyntaxParser.QuestionRef, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_questionref1Exp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitQuestionref1Exp" ):
> >
> > + return visitor.visitQuestionref1Exp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def questionref1Exp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.Questionref1ExpContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 350, self.RULE_questionref1Exp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2753
> >
> > + self.match(VfrSyntaxParser.QuestionRef)
> >
> > + self.state = 2754
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + 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 = 2756
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class RulerefExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = IfrTreeNode(EFI_IFR_RULE_REF_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def RuleRef(self):
> >
> > + return self.getToken(VfrSyntaxParser.RuleRef, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def StringIdentifier(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringIdentifier, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_rulerefExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitRulerefExp" ):
> >
> > + return visitor.visitRulerefExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def rulerefExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.RulerefExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 352, self.RULE_rulerefExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2758
> >
> > + self.match(VfrSyntaxParser.RuleRef)
> >
> > + self.state = 2759
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2760
> >
> > + self.match(VfrSyntaxParser.StringIdentifier)
> >
> > + self.state = 2761
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class Stringref1ExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = IfrTreeNode(EFI_IFR_STRING_REF1_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def StringRef(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringRef, 0)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_stringref1Exp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitStringref1Exp" ):
> >
> > + return visitor.visitStringref1Exp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def stringref1Exp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.Stringref1ExpContext(self, self._ctx,
> self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 354, self.RULE_stringref1Exp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2763
> >
> > + self.match(VfrSyntaxParser.StringRef)
> >
> > + self.state = 2764
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2770
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.StringToken]:
> >
> > + self.state = 2765
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2766
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2767
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2768
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Number]:
> >
> > + self.state = 2769
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + self.state = 2772
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class PushthisExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = IfrTreeNode(EFI_IFR_THIS_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def PushThis(self):
> >
> > + return self.getToken(VfrSyntaxParser.PushThis, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_pushthisExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitPushthisExp" ):
> >
> > + return visitor.visitPushthisExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def pushthisExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.PushthisExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 356, self.RULE_pushthisExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2774
> >
> > + self.match(VfrSyntaxParser.PushThis)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class SecurityExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = IfrTreeNode(EFI_IFR_SECURITY_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Security(self):
> >
> > + return self.getToken(VfrSyntaxParser.Security, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_securityExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitSecurityExp" ):
> >
> > + return visitor.visitSecurityExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def securityExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.SecurityExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 358, self.RULE_securityExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2776
> >
> > + self.match(VfrSyntaxParser.Security)
> >
> > + self.state = 2777
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2778
> >
> > + self.guidDefinition()
> >
> > + self.state = 2779
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class NumericVarStoreTypeContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.VarType = None
> >
> > +
> >
> > + def NumericSizeOne(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeOne, 0)
> >
> > +
> >
> > + def NumericSizeTwo(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeTwo, 0)
> >
> > +
> >
> > + def NumericSizeFour(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeFour, 0)
> >
> > +
> >
> > + def NumericSizeEight(self):
> >
> > + return self.getToken(VfrSyntaxParser.NumericSizeEight, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_numericVarStoreType
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitNumericVarStoreType" ):
> >
> > + return visitor.visitNumericVarStoreType(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def numericVarStoreType(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.NumericVarStoreTypeContext(self, self._ctx,
> > self.state)
> >
> > + self.enterRule(localctx, 360, self.RULE_numericVarStoreType)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class GetExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.BaseInfo = EFI_VARSTORE_INFO()
> >
> > + self.Node = IfrTreeNode(EFI_IFR_GET_OP)
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Get(self):
> >
> > + return self.getToken(VfrSyntaxParser.Get, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStorageVarId(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def BitWiseOr(self):
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def numericVarStoreType(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_getExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitGetExp" ):
> >
> > + return visitor.visitGetExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def getExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.GetExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 362, self.RULE_getExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2783
> >
> > + self.match(VfrSyntaxParser.Get)
> >
> > + self.state = 2784
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2785
> >
> > + self.vfrStorageVarId(localctx.BaseInfo, False)
> >
> > + self.state = 2790
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2786
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2787
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2788
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2789
> >
> > + self.numericVarStoreType()
> >
> > +
> >
> > +
> >
> > + self.state = 2792
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionConstantContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Node = None
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def TrueSymbol(self):
> >
> > + return self.getToken(VfrSyntaxParser.TrueSymbol, 0)
> >
> > +
> >
> > + def FalseSymbol(self):
> >
> > + return self.getToken(VfrSyntaxParser.FalseSymbol, 0)
> >
> > +
> >
> > + def One(self):
> >
> > + return self.getToken(VfrSyntaxParser.One, 0)
> >
> > +
> >
> > + def Ones(self):
> >
> > + return self.getToken(VfrSyntaxParser.Ones, 0)
> >
> > +
> >
> > + def Zero(self):
> >
> > + return self.getToken(VfrSyntaxParser.Zero, 0)
> >
> > +
> >
> > + def Undefined(self):
> >
> > + return self.getToken(VfrSyntaxParser.Undefined, 0)
> >
> > +
> >
> > + def Version(self):
> >
> > + return self.getToken(VfrSyntaxParser.Version, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionConstant
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionConstant" ):
> >
> > + return visitor.visitVfrExpressionConstant(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionConstant(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionConstantContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 364, self.RULE_vfrExpressionConstant)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionUnaryOpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = None
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def lengthExp(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.LengthExpContext,0)
> >
> > +
> >
> > +
> >
> > + def bitwisenotExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.BitwisenotExpContext,0)
> >
> > +
> >
> > +
> >
> > + def question23refExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.Question23refExpContext,0)
> >
> > +
> >
> > +
> >
> > + def stringref2Exp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.Stringref2ExpContext,0)
> >
> > +
> >
> > +
> >
> > + def toboolExp(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.ToboolExpContext,0)
> >
> > +
> >
> > +
> >
> > + def tostringExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.TostringExpContext,0)
> >
> > +
> >
> > +
> >
> > + def unintExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.UnintExpContext,0)
> >
> > +
> >
> > +
> >
> > + def toupperExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ToupperExpContext,0)
> >
> > +
> >
> > +
> >
> > + def tolwerExp(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.TolwerExpContext,0)
> >
> > +
> >
> > +
> >
> > + def setExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.SetExpContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionUnaryOp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionUnaryOp" ):
> >
> > + return visitor.visitVfrExpressionUnaryOp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionUnaryOp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionUnaryOpContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 366, self.RULE_vfrExpressionUnaryOp)
> >
> > + try:
> >
> > + self.state = 2806
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Length]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2796
> >
> > + self.lengthExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.BitWiseNot]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2797
> >
> > + self.bitwisenotExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.QuestionRefVal]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2798
> >
> > + self.question23refExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.StringRefVal]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2799
> >
> > + self.stringref2Exp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.BoolVal]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 2800
> >
> > + self.toboolExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.StringVal]:
> >
> > + self.enterOuterAlt(localctx, 6)
> >
> > + self.state = 2801
> >
> > + self.tostringExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.UnIntVal]:
> >
> > + self.enterOuterAlt(localctx, 7)
> >
> > + self.state = 2802
> >
> > + self.unintExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ToUpper]:
> >
> > + self.enterOuterAlt(localctx, 8)
> >
> > + self.state = 2803
> >
> > + self.toupperExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.ToLower]:
> >
> > + self.enterOuterAlt(localctx, 9)
> >
> > + self.state = 2804
> >
> > + self.tolwerExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Set]:
> >
> > + self.enterOuterAlt(localctx, 10)
> >
> > + self.state = 2805
> >
> > + self.setExp(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class LengthExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Length(self):
> >
> > + return self.getToken(VfrSyntaxParser.Length, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_lengthExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitLengthExp" ):
> >
> > + return visitor.visitLengthExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def lengthExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.LengthExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 368, self.RULE_lengthExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2808
> >
> > + self.match(VfrSyntaxParser.Length)
> >
> > + self.state = 2809
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2810
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2811
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class BitwisenotExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def BitWiseNot(self):
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseNot, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_bitwisenotExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitBitwisenotExp" ):
> >
> > + return visitor.visitBitwisenotExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def bitwisenotExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.BitwisenotExpContext(self, self._ctx,
> self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 370, self.RULE_bitwisenotExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2813
> >
> > + self.match(VfrSyntaxParser.BitWiseNot)
> >
> > + self.state = 2814
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2815
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2816
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class Question23refExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def QuestionRefVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.QuestionRefVal, 0)
> >
> > +
> >
> > + def OpenParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.OpenParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, i)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.CloseParen)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, i)
> >
> > +
> >
> > + def DevicePath(self):
> >
> > + return self.getToken(VfrSyntaxParser.DevicePath, 0)
> >
> > +
> >
> > + def StringToken(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringToken, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Uuid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Uuid, 0)
> >
> > +
> >
> > + def guidDefinition(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.GuidDefinitionContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_question23refExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitQuestion23refExp" ):
> >
> > + return visitor.visitQuestion23refExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def question23refExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.Question23refExpContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 372, self.RULE_question23refExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2818
> >
> > + self.match(VfrSyntaxParser.QuestionRefVal)
> >
> > + self.state = 2819
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2827
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.DevicePath:
> >
> > + self.state = 2820
> >
> > + self.match(VfrSyntaxParser.DevicePath)
> >
> > + self.state = 2821
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2822
> >
> > + self.match(VfrSyntaxParser.StringToken)
> >
> > + self.state = 2823
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2824
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2825
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + self.state = 2826
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2834
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.Uuid:
> >
> > + self.state = 2829
> >
> > + self.match(VfrSyntaxParser.Uuid)
> >
> > + self.state = 2830
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2831
> >
> > + self.guidDefinition()
> >
> > + self.state = 2832
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2836
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2837
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class Stringref2ExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def StringRefVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringRefVal, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_stringref2Exp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitStringref2Exp" ):
> >
> > + return visitor.visitStringref2Exp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def stringref2Exp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.Stringref2ExpContext(self, self._ctx,
> self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 374, self.RULE_stringref2Exp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2839
> >
> > + self.match(VfrSyntaxParser.StringRefVal)
> >
> > + self.state = 2840
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2841
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2842
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ToboolExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def BoolVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.BoolVal, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_toboolExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitToboolExp" ):
> >
> > + return visitor.visitToboolExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def toboolExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ToboolExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 376, self.RULE_toboolExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2844
> >
> > + self.match(VfrSyntaxParser.BoolVal)
> >
> > + self.state = 2845
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2846
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2847
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class TostringExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def StringVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.StringVal, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_tostringExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitTostringExp" ):
> >
> > + return visitor.visitTostringExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def tostringExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.TostringExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 378, self.RULE_tostringExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2849
> >
> > + self.match(VfrSyntaxParser.StringVal)
> >
> > + self.state = 2854
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.T__14:
> >
> > + self.state = 2850
> >
> > + self.match(VfrSyntaxParser.T__14)
> >
> > + self.state = 2851
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2852
> >
> > + self.match(VfrSyntaxParser.Number)
> >
> > + self.state = 2853
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > +
> >
> > +
> >
> > + self.state = 2856
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2857
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2858
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class UnintExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def UnIntVal(self):
> >
> > + return self.getToken(VfrSyntaxParser.UnIntVal, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_unintExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitUnintExp" ):
> >
> > + return visitor.visitUnintExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def unintExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.UnintExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 380, self.RULE_unintExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2860
> >
> > + self.match(VfrSyntaxParser.UnIntVal)
> >
> > + self.state = 2861
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2862
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2863
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ToupperExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def ToUpper(self):
> >
> > + return self.getToken(VfrSyntaxParser.ToUpper, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_toupperExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitToupperExp" ):
> >
> > + return visitor.visitToupperExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def toupperExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ToupperExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 382, self.RULE_toupperExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2865
> >
> > + self.match(VfrSyntaxParser.ToUpper)
> >
> > + self.state = 2866
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2867
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2868
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class TolwerExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def ToLower(self):
> >
> > + return self.getToken(VfrSyntaxParser.ToLower, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_tolwerExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitTolwerExp" ):
> >
> > + return visitor.visitTolwerExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def tolwerExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.TolwerExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 384, self.RULE_tolwerExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2870
> >
> > + self.match(VfrSyntaxParser.ToLower)
> >
> > + self.state = 2871
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2872
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2873
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class SetExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.BaseInfo = EFI_VARSTORE_INFO()
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Set(self):
> >
> > + return self.getToken(VfrSyntaxParser.Set, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStorageVarId(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStorageVarIdContext,0)
> >
> > +
> >
> > +
> >
> > + def Comma(self):
> >
> > + return self.getToken(VfrSyntaxParser.Comma, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def BitWiseOr(self):
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def numericVarStoreType(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.NumericVarStoreTypeContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_setExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitSetExp" ):
> >
> > + return visitor.visitSetExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def setExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.SetExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 386, self.RULE_setExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2875
> >
> > + self.match(VfrSyntaxParser.Set)
> >
> > + self.state = 2876
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2877
> >
> > + self.vfrStorageVarId(localctx.BaseInfo, False)
> >
> > + self.state = 2882
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + if _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2878
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2879
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2880
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2881
> >
> > + self.numericVarStoreType()
> >
> > +
> >
> > +
> >
> > + self.state = 2884
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2885
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2886
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionTernaryOpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = None
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def conditionalExp(self):
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.ConditionalExpContext,0)
> >
> > +
> >
> > +
> >
> > + def findExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.FindExpContext,0)
> >
> > +
> >
> > +
> >
> > + def midExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.MidExpContext,0)
> >
> > +
> >
> > +
> >
> > + def tokenExp(self):
> >
> > + return
> self.getTypedRuleContext(VfrSyntaxParser.TokenExpContext,0)
> >
> > +
> >
> > +
> >
> > + def spanExp(self):
> >
> > + return self.getTypedRuleContext(VfrSyntaxParser.SpanExpContext,0)
> >
> > +
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionTernaryOp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionTernaryOp" ):
> >
> > + return visitor.visitVfrExpressionTernaryOp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionTernaryOp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionTernaryOpContext(self,
> self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 388, self.RULE_vfrExpressionTernaryOp)
> >
> > + try:
> >
> > + self.state = 2893
> >
> > + self._errHandler.sync(self)
> >
> > + token = self._input.LA(1)
> >
> > + if token in [VfrSyntaxParser.Cond]:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2888
> >
> > + self.conditionalExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Find]:
> >
> > + self.enterOuterAlt(localctx, 2)
> >
> > + self.state = 2889
> >
> > + self.findExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Mid]:
> >
> > + self.enterOuterAlt(localctx, 3)
> >
> > + self.state = 2890
> >
> > + self.midExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Tok]:
> >
> > + self.enterOuterAlt(localctx, 4)
> >
> > + self.state = 2891
> >
> > + self.tokenExp(ExpInfo)
> >
> > + pass
> >
> > + elif token in [VfrSyntaxParser.Span]:
> >
> > + self.enterOuterAlt(localctx, 5)
> >
> > + self.state = 2892
> >
> > + self.spanExp(ExpInfo)
> >
> > + pass
> >
> > + else:
> >
> > + raise NoViableAltException(self)
> >
> > +
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class ConditionalExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Cond(self):
> >
> > + return self.getToken(VfrSyntaxParser.Cond, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def Colon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Colon, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_conditionalExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitConditionalExp" ):
> >
> > + return visitor.visitConditionalExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def conditionalExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.ConditionalExpContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 390, self.RULE_conditionalExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2895
> >
> > + self.match(VfrSyntaxParser.Cond)
> >
> > + self.state = 2896
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2897
> >
> > + 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
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class FindExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Find(self):
> >
> > + return self.getToken(VfrSyntaxParser.Find, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def findFormat(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.FindFormatContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.FindFormatContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_findExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitFindExp" ):
> >
> > + return visitor.visitFindExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def findExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.FindExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 392, self.RULE_findExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2904
> >
> > + self.match(VfrSyntaxParser.Find)
> >
> > + self.state = 2905
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2906
> >
> > + self.findFormat(ExpInfo)
> >
> > + self.state = 2911
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2907
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2908
> >
> > + self.findFormat(ExpInfo)
> >
> > + self.state = 2913
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2914
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2915
> >
> > + 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
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class FindFormatContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Format = 0
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Sensitive(self):
> >
> > + return self.getToken(VfrSyntaxParser.Sensitive, 0)
> >
> > +
> >
> > + def Insensitive(self):
> >
> > + return self.getToken(VfrSyntaxParser.Insensitive, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_findFormat
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitFindFormat" ):
> >
> > + return visitor.visitFindFormat(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def findFormat(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.FindFormatContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 394, self.RULE_findFormat)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2922
> >
> > + _la = self._input.LA(1)
> >
> > + if not(_la==VfrSyntaxParser.Insensitive or
> > _la==VfrSyntaxParser.Sensitive):
> >
> > + self._errHandler.recoverInline(self)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class MidExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Mid(self):
> >
> > + return self.getToken(VfrSyntaxParser.Mid, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_midExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitMidExp" ):
> >
> > + return visitor.visitMidExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def midExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.MidExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 396, self.RULE_midExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2924
> >
> > + self.match(VfrSyntaxParser.Mid)
> >
> > + self.state = 2925
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2926
> >
> > + 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
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class TokenExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Tok(self):
> >
> > + return self.getToken(VfrSyntaxParser.Tok, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_tokenExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitTokenExp" ):
> >
> > + return visitor.visitTokenExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def tokenExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.TokenExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 398, self.RULE_tokenExp)
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2933
> >
> > + self.match(VfrSyntaxParser.Tok)
> >
> > + self.state = 2934
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2935
> >
> > + 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
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class SpanExpContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Span(self):
> >
> > + return self.getToken(VfrSyntaxParser.Span, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def FLAGS(self):
> >
> > + return self.getToken(VfrSyntaxParser.FLAGS, 0)
> >
> > +
> >
> > + def spanFlags(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.SpanFlagsContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.SpanFlagsContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> >
> self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionSubContex
> > t)
> >
> > + else:
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > i)
> >
> > +
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def BitWiseOr(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.BitWiseOr)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.BitWiseOr, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_spanExp
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitSpanExp" ):
> >
> > + return visitor.visitSpanExp(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def spanExp(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.SpanExpContext(self, self._ctx, self.state,
> > ExpInfo)
> >
> > + self.enterRule(localctx, 400, self.RULE_spanExp)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2942
> >
> > + self.match(VfrSyntaxParser.Span)
> >
> > + self.state = 2943
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2944
> >
> > + self.match(VfrSyntaxParser.FLAGS)
> >
> > + self.state = 2945
> >
> > + self.match(VfrSyntaxParser.T__5)
> >
> > + self.state = 2946
> >
> > + self.spanFlags()
> >
> > + self.state = 2951
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > + while _la==VfrSyntaxParser.BitWiseOr:
> >
> > + self.state = 2947
> >
> > + self.match(VfrSyntaxParser.BitWiseOr)
> >
> > + self.state = 2948
> >
> > + self.spanFlags()
> >
> > + self.state = 2953
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2954
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2955
> >
> > + 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
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class SpanFlagsContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.Flag = 0
> >
> > +
> >
> > + def Number(self):
> >
> > + return self.getToken(VfrSyntaxParser.Number, 0)
> >
> > +
> >
> > + def LastNonMatch(self):
> >
> > + return self.getToken(VfrSyntaxParser.LastNonMatch, 0)
> >
> > +
> >
> > + def FirstNonMatch(self):
> >
> > + return self.getToken(VfrSyntaxParser.FirstNonMatch, 0)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_spanFlags
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitSpanFlags" ):
> >
> > + return visitor.visitSpanFlags(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def spanFlags(self):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.SpanFlagsContext(self, self._ctx, self.state)
> >
> > + self.enterRule(localctx, 402, self.RULE_spanFlags)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + 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)
> >
> > + else:
> >
> > + self._errHandler.reportMatch(self)
> >
> > + self.consume()
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > +
> >
> > +
> >
> > + class VfrExpressionMapContext(ParserRuleContext):
> >
> > +
> >
> > + def __init__(self, parser, parent:ParserRuleContext=None,
> > invokingState:int=-1, ExpInfo=None):
> >
> > + super().__init__(parent, invokingState)
> >
> > + self.parser = parser
> >
> > + self.ExpInfo = None
> >
> > + self.Nodes = []
> >
> > + self.Node = IfrTreeNode()
> >
> > + self.ExpInfo = ExpInfo
> >
> > +
> >
> > + def Map(self):
> >
> > + return self.getToken(VfrSyntaxParser.Map, 0)
> >
> > +
> >
> > + def OpenParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.OpenParen, 0)
> >
> > +
> >
> > + def vfrStatementExpressionSub(self):
> >
> > + return
> >
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubContext,
> > 0)
> >
> > +
> >
> > +
> >
> > + def Colon(self):
> >
> > + return self.getToken(VfrSyntaxParser.Colon, 0)
> >
> > +
> >
> > + def CloseParen(self):
> >
> > + return self.getToken(VfrSyntaxParser.CloseParen, 0)
> >
> > +
> >
> > + def vfrStatementExpression(self, i:int=None):
> >
> > + if i is None:
> >
> > + return
> > self.getTypedRuleContexts(VfrSyntaxParser.VfrStatementExpressionContext)
> >
> > + else:
> >
> > + return
> > self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionContext,i)
> >
> > +
> >
> > +
> >
> > + def Comma(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Comma)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Comma, i)
> >
> > +
> >
> > + def Semicolon(self, i:int=None):
> >
> > + if i is None:
> >
> > + return self.getTokens(VfrSyntaxParser.Semicolon)
> >
> > + else:
> >
> > + return self.getToken(VfrSyntaxParser.Semicolon, i)
> >
> > +
> >
> > + def getRuleIndex(self):
> >
> > + return VfrSyntaxParser.RULE_vfrExpressionMap
> >
> > +
> >
> > + def accept(self, visitor:ParseTreeVisitor):
> >
> > + if hasattr( visitor, "visitVfrExpressionMap" ):
> >
> > + return visitor.visitVfrExpressionMap(self)
> >
> > + else:
> >
> > + return visitor.visitChildren(self)
> >
> > +
> >
> > +
> >
> > +
> >
> > +
> >
> > + def vfrExpressionMap(self, ExpInfo):
> >
> > +
> >
> > + localctx = VfrSyntaxParser.VfrExpressionMapContext(self, self._ctx,
> > self.state, ExpInfo)
> >
> > + self.enterRule(localctx, 404, self.RULE_vfrExpressionMap)
> >
> > + self._la = 0 # Token type
> >
> > + try:
> >
> > + self.enterOuterAlt(localctx, 1)
> >
> > + self.state = 2964
> >
> > + self.match(VfrSyntaxParser.Map)
> >
> > + self.state = 2965
> >
> > + self.match(VfrSyntaxParser.OpenParen)
> >
> > + self.state = 2966
> >
> > + self.vfrStatementExpressionSub(localctx.Nodes)
> >
> > + self.state = 2967
> >
> > + self.match(VfrSyntaxParser.Colon)
> >
> > + 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 = 2968
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2969
> >
> > + self.match(VfrSyntaxParser.Comma)
> >
> > + self.state = 2970
> >
> > + self.vfrStatementExpression(localctx.Node)
> >
> > + self.state = 2971
> >
> > + self.match(VfrSyntaxParser.Semicolon)
> >
> > + self.state = 2977
> >
> > + self._errHandler.sync(self)
> >
> > + _la = self._input.LA(1)
> >
> > +
> >
> > + self.state = 2978
> >
> > + self.match(VfrSyntaxParser.CloseParen)
> >
> > + except RecognitionException as re:
> >
> > + localctx.exception = re
> >
> > + self._errHandler.reportError(self, re)
> >
> > + self._errHandler.recover(self, re)
> >
> > + finally:
> >
> > + self.exitRule()
> >
> > + return localctx
> >
> > diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> > b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> > new file mode 100644
> > index 0000000000..622e63347c
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> > @@ -0,0 +1,5504 @@
> > +## @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/__init__.py
> > b/BaseTools/Source/Python/VfrCompiler/__init__.py
> > new file mode 100644
> > index 0000000000..72d3a47bb7
> > --- /dev/null
> > +++ b/BaseTools/Source/Python/VfrCompiler/__init__.py
> > @@ -0,0 +1 @@
> > +__all__ = ["VfrCompiler"]
> >
> > --
> > 2.39.1.windows.1
>
>
>
>
>
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#110935): https://edk2.groups.io/g/devel/message/110935
Mute This Topic: https://groups.io/mt/102463460/7686176
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [rebecca@openfw.io]
-=-=-=-=-=-=-=-=-=-=-=-
^ permalink raw reply [flat|nested] 4+ messages in thread
* [edk2-devel] [PATCH] BaseTools: Python VfrCompiler implementation
@ 2024-03-15 6:38 Yuting Yang
0 siblings, 0 replies; 4+ messages in thread
From: Yuting Yang @ 2024-03-15 6:38 UTC (permalink / raw)
To: devel
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/VfrCompile.
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
Signed-off-by: Yuwei Chen yuwei.chen@intel.com
Signed-off-by: Yuting Yang <yuting2.yang@intel.com>
---
BaseTools/BinWrappers/PosixLike/PyVfrCompile | 13 +
.../BinWrappers/WindowsLike/PyVfrCompile.bat | 4 +
BaseTools/Conf/build_rule.template | 4 +-
BaseTools/Conf/tools_def.template | 1 +
.../Source/Python/VfrCompiler/CommonCtypes.py | 1394 --
.../Source/Python/VfrCompiler/IfrCommon.py | 100 +
.../Source/Python/VfrCompiler/IfrCompiler.py | 587 +
.../Source/Python/VfrCompiler/IfrCtypes.py | 1811 +++
.../Source/Python/VfrCompiler/IfrError.py | 153 +
.../Source/Python/VfrCompiler/IfrFormPkg.py | 2937 +++++
.../Python/VfrCompiler/IfrPreProcess.py | 262 +
.../Source/Python/VfrCompiler/IfrTree.py | 1734 +++
.../Source/Python/VfrCompiler/IfrUtility.py | 2226 ++++
BaseTools/Source/Python/VfrCompiler/README.md | 88 +-
.../Source/Python/VfrCompiler/VfrError.py | 162 -
.../Source/Python/VfrCompiler/VfrFormPkg.py | 2738 ----
.../Source/Python/VfrCompiler/VfrSyntax.g4 | 3808 +++---
.../Python/VfrCompiler/VfrSyntaxLexer.py | 17 +-
.../Python/VfrCompiler/VfrSyntaxParser.py | 8145 ++++++------
.../Python/VfrCompiler/VfrSyntaxVisitor.py | 10610 ++++++++--------
.../Source/Python/VfrCompiler/VfrTree.py | 88 -
.../Source/Python/VfrCompiler/VfrUtility.py | 1991 ---
.../Source/Python/VfrCompiler/__init__.py | 1 +
BaseTools/Source/Python/VfrCompiler/main.py | 27 -
24 files changed, 21413 insertions(+), 17488 deletions(-)
create mode 100644 BaseTools/BinWrappers/PosixLike/PyVfrCompile
create mode 100644 BaseTools/BinWrappers/WindowsLike/PyVfrCompile.bat
delete mode 100644 BaseTools/Source/Python/VfrCompiler/CommonCtypes.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCommon.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrError.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrTree.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/IfrUtility.py
delete mode 100644 BaseTools/Source/Python/VfrCompiler/VfrError.py
delete mode 100644 BaseTools/Source/Python/VfrCompiler/VfrFormPkg.py
delete mode 100644 BaseTools/Source/Python/VfrCompiler/VfrTree.py
delete mode 100644 BaseTools/Source/Python/VfrCompiler/VfrUtility.py
create mode 100644 BaseTools/Source/Python/VfrCompiler/__init__.py
delete mode 100644 BaseTools/Source/Python/VfrCompiler/main.py
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;%BASE_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_OPCODE: ": 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.FormSetGuid.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/VfrCompile.
-
-### Introduction
-The core function of the original C VfrCompiler tool is to convert the vfr file into IFR binary array. However, the vfr format file syntax is relatively uncommon and has poor readability for users. What's more, the C tool does not collect and store extra information except for binary generation. When any modification is needed, developers have to read and deal with the IFR binary, which is quite inefficient. To solve this issue, this python VfrCompiler tool proposes to generate the yaml format file on the basis of the vfr format file. With the yaml file, the layout and hierarchy of all Opcodes in the vfr file will be saved. Then modification will be much eaiser. In addition, an extra json file will be generated for better variable related information presentation. So the long-term aim of this tool is to cover the same usage as the edk2 C VfrCompiler and extend the yaml/json output for better readability and variability.
-
-### Main update in this commitment
-- Update the vfr parser generator from ANTLR to ANTLR v4, which is more readable and is eaiser to add on new functions.
-- Generate a yaml file for each vfr file. The yaml file displays all the contents in the Vfr file by different Opcode types in sequence.
-- Generate a json file for each vfr file. The json file contains all the default values for different Opcode types in vfr files.
-
-### Known issues
-
-- The python VfrCompiler tool aims to cover the same usage as the edk2 C VfrCompiler. But currently, the python VfrCompiler tool does not support IFR binary generation feature, this feature will be added in future update.
-- The python VfrCompiler tool will extend new functions, which is able to compile both the vfr and yaml files. This feature will be added in future update.
-
-### Use with Build System
-- To use the VfrCompiler Python Tool with Build System, please add the ***'--vfr-yaml-enable'*** option in the build command.
-- For Example: ***build -p OvmfPkg\OvmfPkgIa32X64.dsc -a IA32 -a X64 -j build.log --vfr-yaml-enable***
\ No newline at end of file
+# 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/VfrCompile.
+
+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;%BASE_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_OPCODE:
- ": Not recommend to use obsoleted framework opcode",
- EFI_VFR_WARNING_CODE.VFR_WARNING_CODEUNDEFINED: ": undefined Warning Code"
-}
-
-
-class CVfrErrorHandle():
-
- def __init__(self):
- self.__InputFileName = None
- self.__vfrErrorMessage = vfrErrorMessage
- self.__vfrWarningMessage = vfrWarningMessage
- self.__WarningAsError = False
-
- def SetWarningAsError(self, WarningAsError):
- self.__WarningAsError = WarningAsError
-
- def SetInputFile(self, InputFile):
- self.__InputFileName = InputFile
-
- def HandleWarning(self, WarningCode, LineNum, TokenValue=None):
- if self.__vfrWarningMessage == None:
- return 1
- WarningMsg = ''
- for key in self.__vfrWarningMessage.keys():
- if WarningCode == self.__vfrWarningMessage[key]:
- WarningMsg = self.__vfrWarningMessage[key]
- break
- if WarningMsg != '':
- if self.__WarningAsError:
- EdkLogger.error('VfrCompiler', WarningCode, WarningMsg,
- self.__InputFileName, LineNum,
- "warning treated as error")
- EdkLogger.warn('VfrCompiler', WarningMsg, self.__InputFileName,
- LineNum, TokenValue)
-
- def PrintMsg(self,
- LineNum,
- MsgType='Error',
- ErrorMsg=None,
- TokenValue=None):
- if MsgType == 'Warning':
- EdkLogger.verbose(ErrorMsg)
- else:
- EdkLogger.error('VfrCompiler', 0x3000, ErrorMsg,
- self.__InputFileName, LineNum, TokenValue)
-
- def HandleError(self, ErrorCode, LineNum=None, TokenValue=None):
- if self.__vfrErrorMessage == None:
- return 1
- ErrorMsg = ''
- for key in self.__vfrErrorMessage.keys():
- if ErrorCode == self.__vfrErrorMessage[key]:
- ErrorMsg = self.__vfrErrorMessage[key]
- break
- if ErrorMsg != '':
- EdkLogger.error('VfrCompiler', ErrorCode, ErrorMsg,
- self.__InputFileName, LineNum, TokenValue)
- return 1
- else:
- return 0
-
-
-gCVfrErrorHandle = CVfrErrorHandle()
\ No newline at end of file
diff --git a/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(EFI_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\u0102")
- buf.write("\u0ba3\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+ buf.write("\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\16N")
- buf.write("\u0596\13N\3O\3O\3O\3O\3O\3O\3O\5O\u059f\nO\3P\3P\3P\3")
- buf.write("P\3P\3P\3P\3P\5P\u05a9\nP\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u05b3")
- buf.write("\nQ\fQ\16Q\u05b6\13Q\3Q\3Q\5Q\u05ba\nQ\3Q\3Q\3Q\5Q\u05bf")
- buf.write("\nQ\3R\3R\3R\3R\3R\3R\3R\3R\7R\u05c9\nR\fR\16R\u05cc\13")
- buf.write("R\3R\3R\5R\u05d0\nR\3R\3R\3R\5R\u05d5\nR\3S\3S\3S\3S\3")
- buf.write("S\3S\3S\3S\5S\u05df\nS\3S\3S\3S\3S\5S\u05e5\nS\3T\3T\3")
- buf.write("T\3T\3U\3U\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3")
- buf.write("V\3V\3V\3V\3V\5V\u0600\nV\3V\3V\7V\u0604\nV\fV\16V\u0607")
- buf.write("\13V\3V\3V\3W\3W\3W\7W\u060e\nW\fW\16W\u0611\13W\3X\3")
- buf.write("X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u061e\nX\3Y\3Y\3Y\3Y\3")
- buf.write("Z\3Z\3Z\3Z\3[\7[\u0629\n[\f[\16[\u062c\13[\3\\\3\\\5\\")
- buf.write("\u0630\n\\\3]\3]\5]\u0634\n]\3^\3^\3^\3^\3^\3^\3^\3^\3")
- buf.write("^\5^\u063f\n^\3^\3^\3^\3^\5^\u0645\n^\3^\3^\3^\3^\3_\3")
- buf.write("_\3_\7_\u064e\n_\f_\16_\u0651\13_\3`\3`\3`\3`\3`\3`\5")
- buf.write("`\u0659\n`\3a\3a\3a\3a\3a\3a\3a\3a\5a\u0663\na\3a\3a\3")
- buf.write("a\3a\3a\3a\3a\3a\3a\3a\3a\3b\3b\3b\7b\u0673\nb\fb\16b")
- buf.write("\u0676\13b\3c\3c\5c\u067a\nc\3d\3d\5d\u067e\nd\3e\3e\3")
- buf.write("e\3e\3e\3e\3e\3e\3e\5e\u0689\ne\3e\3e\3e\3e\5e\u068f\n")
- buf.write("e\3e\3e\3e\3e\3e\3f\3f\3f\5f\u0699\nf\3f\3f\3f\3f\3f\5")
- buf.write("f\u06a0\nf\3f\3f\3f\3f\3f\3f\5f\u06a8\nf\3g\3g\3g\7g\u06ad")
- buf.write("\ng\fg\16g\u06b0\13g\3h\3h\3h\3h\3h\3h\3h\3h\3h\5h\u06bb")
- buf.write("\nh\3i\3i\3i\3i\3i\3i\3i\3i\3i\5i\u06c6\ni\3i\5i\u06c9")
- buf.write("\ni\3i\3i\3i\3i\3j\3j\3j\7j\u06d2\nj\fj\16j\u06d5\13j")
- buf.write("\3k\3k\5k\u06d9\nk\3l\3l\3l\3l\3l\3l\3l\3l\5l\u06e3\n")
- buf.write("l\3l\3l\3l\3l\5l\u06e9\nl\3l\3l\3l\3l\3l\3l\3l\3l\3l\3")
- buf.write("l\3l\3l\3m\3m\3m\7m\u06fa\nm\fm\16m\u06fd\13m\3n\3n\3")
- buf.write("n\5n\u0702\nn\3o\3o\3o\3o\3o\3o\3o\3o\5o\u070c\no\3o\3")
- buf.write("o\3o\3o\5o\u0712\no\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3")
- buf.write("o\5o\u0720\no\3o\3o\3o\3o\3p\3p\3p\7p\u0729\np\fp\16p")
- buf.write("\u072c\13p\3q\3q\5q\u0730\nq\3r\3r\3r\3r\3r\3r\3r\5r\u0739")
- buf.write("\nr\3r\3r\3r\3r\3r\5r\u0740\nr\3r\3r\3r\3r\3s\3s\3s\7")
- buf.write("s\u0749\ns\fs\16s\u074c\13s\3t\3t\3t\3t\5t\u0752\nt\3")
- buf.write("u\3u\3u\3u\3u\3u\3u\3u\5u\u075c\nu\3u\3u\3u\3u\3u\3u\3")
+ buf.write("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\3M\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\u05ac")
+ 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\u052d")
- buf.write("\5\u0090I\2\u0527\u052d\5\u0092J\2\u0528\u052d\5\u0094")
- buf.write("K\2\u0529\u052d\5\u011c\u008f\2\u052a\u052d\5\u0096L\2")
- buf.write("\u052b\u052d\5\u0098M\2\u052c\u0521\3\2\2\2\u052c\u0524")
- buf.write("\3\2\2\2\u052c\u0525\3\2\2\2\u052c\u0526\3\2\2\2\u052c")
- buf.write("\u0527\3\2\2\2\u052c\u0528\3\2\2\2\u052c\u0529\3\2\2\2")
- buf.write("\u052c\u052a\3\2\2\2\u052c\u052b\3\2\2\2\u052d\u008b\3")
- buf.write("\2\2\2\u052e\u052f\7p\2\2\u052f\u0530\7\62\2\2\u0530\u0531")
- buf.write("\7\b\2\2\u0531\u0532\7\u00ec\2\2\u0532\u0533\7\30\2\2")
- buf.write("\u0533\u0534\7\u00fa\2\2\u0534\u0535\7\31\2\2\u0535\u0542")
- buf.write("\7!\2\2\u0536\u0537\7@\2\2\u0537\u0538\7\b\2\2\u0538\u053d")
- buf.write("\5\u009eP\2\u0539\u053a\7(\2\2\u053a\u053c\5\u009eP\2")
- buf.write("\u053b\u0539\3\2\2\2\u053c\u053f\3\2\2\2\u053d\u053b\3")
- buf.write("\2\2\2\u053d\u053e\3\2\2\2\u053e\u0540\3\2\2\2\u053f\u053d")
- buf.write("\3\2\2\2\u0540\u0541\7!\2\2\u0541\u0543\3\2\2\2\u0542")
- buf.write("\u0536\3\2\2\2\u0542\u0543\3\2\2\2\u0543\u0544\3\2\2\2")
- buf.write("\u0544\u0545\5\u0124\u0093\2\u0545\u0547\7s\2\2\u0546")
- buf.write("\u0548\7 \2\2\u0547\u0546\3\2\2\2\u0547\u0548\3\2\2\2")
- buf.write("\u0548\u008d\3\2\2\2\u0549\u054a\7r\2\2\u054a\u054b\7")
- buf.write("\62\2\2\u054b\u054c\7\b\2\2\u054c\u054d\7\u00ec\2\2\u054d")
- buf.write("\u054e\7\30\2\2\u054e\u054f\7\u00fa\2\2\u054f\u0550\7")
- buf.write("\31\2\2\u0550\u055d\7!\2\2\u0551\u0552\7@\2\2\u0552\u0553")
- buf.write("\7\b\2\2\u0553\u0558\5\u009eP\2\u0554\u0555\7(\2\2\u0555")
- buf.write("\u0557\5\u009eP\2\u0556\u0554\3\2\2\2\u0557\u055a\3\2")
- buf.write("\2\2\u0558\u0556\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u055b")
- buf.write("\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7!\2\2\u055c")
- buf.write("\u055e\3\2\2\2\u055d\u0551\3\2\2\2\u055d\u055e\3\2\2\2")
- buf.write("\u055e\u055f\3\2\2\2\u055f\u0560\5\u0124\u0093\2\u0560")
- buf.write("\u0562\7s\2\2\u0561\u0563\7 \2\2\u0562\u0561\3\2\2\2\u0562")
- buf.write("\u0563\3\2\2\2\u0563\u008f\3\2\2\2\u0564\u0565\7l\2\2")
- buf.write("\u0565\u0566\5\u0124\u0093\2\u0566\u0567\7 \2\2\u0567")
- buf.write("\u0568\5\u00b4[\2\u0568\u056a\7s\2\2\u0569\u056b\7 \2")
- buf.write("\2\u056a\u0569\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u0091")
- buf.write("\3\2\2\2\u056c\u056d\7\u00a4\2\2\u056d\u056e\7\u00a5\2")
- buf.write("\2\u056e\u056f\7\b\2\2\u056f\u0570\7\u00fa\2\2\u0570\u0093")
- buf.write("\3\2\2\2\u0571\u0572\7\u00a6\2\2\u0572\u0573\7\b\2\2\u0573")
- buf.write("\u0574\7\u00ec\2\2\u0574\u0575\7\30\2\2\u0575\u0576\7")
- buf.write("\u00fa\2\2\u0576\u0577\7\31\2\2\u0577\u0578\7!\2\2\u0578")
- buf.write("\u0095\3\2\2\2\u0579\u057a\7\u00eb\2\2\u057a\u057b\7\b")
- buf.write("\2\2\u057b\u057c\5L\'\2\u057c\u057d\7!\2\2\u057d\u0097")
- buf.write("\3\2\2\2\u057e\u057f\7q\2\2\u057f\u0580\7\62\2\2\u0580")
- buf.write("\u0581\7\b\2\2\u0581\u0582\7\u00ec\2\2\u0582\u0583\7\30")
- buf.write("\2\2\u0583\u0584\7\u00fa\2\2\u0584\u0585\7\31\2\2\u0585")
- buf.write("\u058a\7!\2\2\u0586\u0587\7M\2\2\u0587\u0588\7\b\2\2\u0588")
- buf.write("\u0589\7\u00fa\2\2\u0589\u058b\7!\2\2\u058a\u0586\3\2")
- buf.write("\2\2\u058a\u058b\3\2\2\2\u058b\u058c\3\2\2\2\u058c\u058d")
- buf.write("\5\u0124\u0093\2\u058d\u058f\7s\2\2\u058e\u0590\7 \2\2")
- buf.write("\u058f\u058e\3\2\2\2\u058f\u0590\3\2\2\2\u0590\u0099\3")
- buf.write("\2\2\2\u0591\u0593\5\u008aF\2\u0592\u0591\3\2\2\2\u0593")
- buf.write("\u0596\3\2\2\2\u0594\u0592\3\2\2\2\u0594\u0595\3\2\2\2")
- buf.write("\u0595\u009b\3\2\2\2\u0596\u0594\3\2\2\2\u0597\u059f\5")
- buf.write("\u00a0Q\2\u0598\u059f\5\u00a2R\2\u0599\u059f\5\u00a6T")
- buf.write("\2\u059a\u059f\5\u00a4S\2\u059b\u059f\5\u00a8U\2\u059c")
- buf.write("\u059f\5\u00b0Y\2\u059d\u059f\5\u00b2Z\2\u059e\u0597\3")
- buf.write("\2\2\2\u059e\u0598\3\2\2\2\u059e\u0599\3\2\2\2\u059e\u059a")
- buf.write("\3\2\2\2\u059e\u059b\3\2\2\2\u059e\u059c\3\2\2\2\u059e")
- buf.write("\u059d\3\2\2\2\u059f\u009d\3\2\2\2\u05a0\u05a9\7\u00fa")
- buf.write("\2\2\u05a1\u05a9\7y\2\2\u05a2\u05a9\7v\2\2\u05a3\u05a9")
- buf.write("\7u\2\2\u05a4\u05a9\7{\2\2\u05a5\u05a9\7|\2\2\u05a6\u05a9")
- buf.write("\7z\2\2\u05a7\u05a9\7}\2\2\u05a8\u05a0\3\2\2\2\u05a8\u05a1")
- buf.write("\3\2\2\2\u05a8\u05a2\3\2\2\2\u05a8\u05a3\3\2\2\2\u05a8")
- buf.write("\u05a4\3\2\2\2\u05a8\u05a5\3\2\2\2\u05a8\u05a6\3\2\2\2")
- buf.write("\u05a8\u05a7\3\2\2\2\u05a9\u009f\3\2\2\2\u05aa\u05ab\7")
- buf.write("k\2\2\u05ab\u05ac\5\u0124\u0093\2\u05ac\u05b9\7 \2\2\u05ad")
- buf.write("\u05ae\7@\2\2\u05ae\u05af\7\b\2\2\u05af\u05b4\5\u009e")
- buf.write("P\2\u05b0\u05b1\7(\2\2\u05b1\u05b3\5\u009eP\2\u05b2\u05b0")
- buf.write("\3\2\2\2\u05b3\u05b6\3\2\2\2\u05b4\u05b2\3\2\2\2\u05b4")
- buf.write("\u05b5\3\2\2\2\u05b5\u05b7\3\2\2\2\u05b6\u05b4\3\2\2\2")
- buf.write("\u05b7\u05b8\7!\2\2\u05b8\u05ba\3\2\2\2\u05b9\u05ad\3")
- buf.write("\2\2\2\u05b9\u05ba\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc")
- buf.write("\5\u00b4[\2\u05bc\u05be\7s\2\2\u05bd\u05bf\7 \2\2\u05be")
- buf.write("\u05bd\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf\u00a1\3\2\2\2")
- buf.write("\u05c0\u05c1\7K\2\2\u05c1\u05c2\5\u0124\u0093\2\u05c2")
- buf.write("\u05cf\7 \2\2\u05c3\u05c4\7@\2\2\u05c4\u05c5\7\b\2\2\u05c5")
- buf.write("\u05ca\5\u009eP\2\u05c6\u05c7\7(\2\2\u05c7\u05c9\5\u009e")
- buf.write("P\2\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3\2\2\2\u05ca\u05c8")
- buf.write("\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cd\3\2\2\2\u05cc")
- buf.write("\u05ca\3\2\2\2\u05cd\u05ce\7!\2\2\u05ce\u05d0\3\2\2\2")
- buf.write("\u05cf\u05c3\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u05d1\3")
- buf.write("\2\2\2\u05d1\u05d2\5\u00b4[\2\u05d2\u05d4\7s\2\2\u05d3")
- buf.write("\u05d5\7 \2\2\u05d4\u05d3\3\2\2\2\u05d4\u05d5\3\2\2\2")
- buf.write("\u05d5\u00a3\3\2\2\2\u05d6\u05de\7c\2\2\u05d7\u05d8\5")
- buf.write("\u00a6T\2\u05d8\u05d9\7!\2\2\u05d9\u05df\3\2\2\2\u05da")
- buf.write("\u05db\7\b\2\2\u05db\u05dc\5Z.\2\u05dc\u05dd\7!\2\2\u05dd")
- buf.write("\u05df\3\2\2\2\u05de\u05d7\3\2\2\2\u05de\u05da\3\2\2\2")
- buf.write("\u05df\u05e4\3\2\2\2\u05e0\u05e1\7\u009b\2\2\u05e1\u05e2")
- buf.write("\7\b\2\2\u05e2\u05e3\7\u00fb\2\2\u05e3\u05e5\7!\2\2\u05e4")
- buf.write("\u05e0\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5\u00a5\3\2\2\2")
- buf.write("\u05e6\u05e7\7\u0096\2\2\u05e7\u05e8\7\b\2\2\u05e8\u05e9")
- buf.write("\5\u0124\u0093\2\u05e9\u00a7\3\2\2\2\u05ea\u05eb\5\u00aa")
- buf.write("V\2\u05eb\u00a9\3\2\2\2\u05ec\u05ed\7?\2\2\u05ed\u05ee")
- buf.write("\7>\2\2\u05ee\u05ef\7\b\2\2\u05ef\u05f0\7\u00ec\2\2\u05f0")
- buf.write("\u05f1\7\30\2\2\u05f1\u05f2\7\u00fa\2\2\u05f2\u05f3\7")
- buf.write("\31\2\2\u05f3\u05f4\7!\2\2\u05f4\u05f5\7\u0096\2\2\u05f5")
- buf.write("\u05f6\7\b\2\2\u05f6\u05f7\5Z.\2\u05f7\u05f8\7!\2\2\u05f8")
- buf.write("\u05f9\7@\2\2\u05f9\u05fa\7\b\2\2\u05fa\u05ff\5\u00ac")
- buf.write("W\2\u05fb\u05fc\7!\2\2\u05fc\u05fd\7t\2\2\u05fd\u05fe")
- buf.write("\7\b\2\2\u05fe\u0600\7\u00fa\2\2\u05ff\u05fb\3\2\2\2\u05ff")
- buf.write("\u0600\3\2\2\2\u0600\u0605\3\2\2\2\u0601\u0602\7!\2\2")
- buf.write("\u0602\u0604\5\\/\2\u0603\u0601\3\2\2\2\u0604\u0607\3")
- buf.write("\2\2\2\u0605\u0603\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0608")
- buf.write("\3\2\2\2\u0607\u0605\3\2\2\2\u0608\u0609\7 \2\2\u0609")
- buf.write("\u00ab\3\2\2\2\u060a\u060f\5\u00aeX\2\u060b\u060c\7(\2")
- buf.write("\2\u060c\u060e\5\u00aeX\2\u060d\u060b\3\2\2\2\u060e\u0611")
- buf.write("\3\2\2\2\u060f\u060d\3\2\2\2\u060f\u0610\3\2\2\2\u0610")
- buf.write("\u00ad\3\2\2\2\u0611\u060f\3\2\2\2\u0612\u061e\7\u00fa")
- buf.write("\2\2\u0613\u061e\7\u00ed\2\2\u0614\u061e\7\u00ee\2\2\u0615")
- buf.write("\u061e\7y\2\2\u0616\u061e\7{\2\2\u0617\u061e\7\u0080\2")
- buf.write("\2\u0618\u061e\7|\2\2\u0619\u061e\7v\2\2\u061a\u061e\7")
- buf.write("u\2\2\u061b\u061e\7z\2\2\u061c\u061e\7}\2\2\u061d\u0612")
- buf.write("\3\2\2\2\u061d\u0613\3\2\2\2\u061d\u0614\3\2\2\2\u061d")
- buf.write("\u0615\3\2\2\2\u061d\u0616\3\2\2\2\u061d\u0617\3\2\2\2")
- buf.write("\u061d\u0618\3\2\2\2\u061d\u0619\3\2\2\2\u061d\u061a\3")
- buf.write("\2\2\2\u061d\u061b\3\2\2\2\u061d\u061c\3\2\2\2\u061e\u00af")
- buf.write("\3\2\2\2\u061f\u0620\7\u0097\2\2\u0620\u0621\5\u0124\u0093")
- buf.write("\2\u0621\u0622\7 \2\2\u0622\u00b1\3\2\2\2\u0623\u0624")
- buf.write("\7\u0098\2\2\u0624\u0625\5\u0124\u0093\2\u0625\u0626\7")
- buf.write(" \2\2\u0626\u00b3\3\2\2\2\u0627\u0629\5\u00b6\\\2\u0628")
- buf.write("\u0627\3\2\2\2\u0629\u062c\3\2\2\2\u062a\u0628\3\2\2\2")
- buf.write("\u062a\u062b\3\2\2\2\u062b\u00b5\3\2\2\2\u062c\u062a\3")
- buf.write("\2\2\2\u062d\u0630\5\u008aF\2\u062e\u0630\5\u009cO\2\u062f")
- buf.write("\u062d\3\2\2\2\u062f\u062e\3\2\2\2\u0630\u00b7\3\2\2\2")
- buf.write("\u0631\u0634\5\u00ba^\2\u0632\u0634\5\u00c0a\2\u0633\u0631")
- buf.write("\3\2\2\2\u0633\u0632\3\2\2\2\u0634\u00b9\3\2\2\2\u0635")
- buf.write("\u0636\7\\\2\2\u0636\u0637\5R*\2\u0637\u0638\5T+\2\u0638")
- buf.write("\u063e\7!\2\2\u0639\u063a\7@\2\2\u063a\u063b\7\b\2\2\u063b")
- buf.write("\u063c\5\u00bc_\2\u063c\u063d\7!\2\2\u063d\u063f\3\2\2")
- buf.write("\2\u063e\u0639\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0644")
- buf.write("\3\2\2\2\u0640\u0641\7t\2\2\u0641\u0642\7\b\2\2\u0642")
- buf.write("\u0643\7\u00fa\2\2\u0643\u0645\7!\2\2\u0644\u0640\3\2")
- buf.write("\2\2\u0644\u0645\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0647")
- buf.write("\5\u00b4[\2\u0647\u0648\7]\2\2\u0648\u0649\7 \2\2\u0649")
- buf.write("\u00bb\3\2\2\2\u064a\u064f\5\u00be`\2\u064b\u064c\7(\2")
- buf.write("\2\u064c\u064e\5\u00be`\2\u064d\u064b\3\2\2\2\u064e\u0651")
- buf.write("\3\2\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650")
- buf.write("\u00bd\3\2\2\2\u0651\u064f\3\2\2\2\u0652\u0659\7\u00fa")
- buf.write("\2\2\u0653\u0659\7u\2\2\u0654\u0659\7v\2\2\u0655\u0659")
- buf.write("\7w\2\2\u0656\u0659\7x\2\2\u0657\u0659\5V,\2\u0658\u0652")
- buf.write("\3\2\2\2\u0658\u0653\3\2\2\2\u0658\u0654\3\2\2\2\u0658")
- buf.write("\u0655\3\2\2\2\u0658\u0656\3\2\2\2\u0658\u0657\3\2\2\2")
- buf.write("\u0659\u00bf\3\2\2\2\u065a\u065b\7\u00a1\2\2\u065b\u065c")
- buf.write("\5P)\2\u065c\u0662\7!\2\2\u065d\u065e\7@\2\2\u065e\u065f")
- buf.write("\7\b\2\2\u065f\u0660\5\u00c2b\2\u0660\u0661\7!\2\2\u0661")
- buf.write("\u0663\3\2\2\2\u0662\u065d\3\2\2\2\u0662\u0663\3\2\2\2")
- buf.write("\u0663\u0664\3\2\2\2\u0664\u0665\7\u00a2\2\2\u0665\u0666")
- buf.write("\7\b\2\2\u0666\u0667\7\u00ec\2\2\u0667\u0668\7\30\2\2")
- buf.write("\u0668\u0669\7\u00fa\2\2\u0669\u066a\7\31\2\2\u066a\u066b")
- buf.write("\7!\2\2\u066b\u066c\5\u009aN\2\u066c\u066d\7\u00a3\2\2")
- buf.write("\u066d\u066e\7 \2\2\u066e\u00c1\3\2\2\2\u066f\u0674\5")
- buf.write("\u00c4c\2\u0670\u0671\7(\2\2\u0671\u0673\5\u00c4c\2\u0672")
- buf.write("\u0670\3\2\2\2\u0673\u0676\3\2\2\2\u0674\u0672\3\2\2\2")
- buf.write("\u0674\u0675\3\2\2\2\u0675\u00c3\3\2\2\2\u0676\u0674\3")
- buf.write("\2\2\2\u0677\u067a\7\u00fa\2\2\u0678\u067a\5V,\2\u0679")
- buf.write("\u0677\3\2\2\2\u0679\u0678\3\2\2\2\u067a\u00c5\3\2\2\2")
- buf.write("\u067b\u067e\5\u00c8e\2\u067c\u067e\5\u00d0i\2\u067d\u067b")
- buf.write("\3\2\2\2\u067d\u067c\3\2\2\2\u067e\u00c7\3\2\2\2\u067f")
- buf.write("\u0680\7^\2\2\u0680\u0681\5R*\2\u0681\u0682\5T+\2\u0682")
- buf.write("\u0688\7!\2\2\u0683\u0684\7@\2\2\u0684\u0685\7\b\2\2\u0685")
- buf.write("\u0686\5\u00ccg\2\u0686\u0687\7!\2\2\u0687\u0689\3\2\2")
- buf.write("\2\u0688\u0683\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068e")
- buf.write("\3\2\2\2\u068a\u068b\7t\2\2\u068b\u068c\7\b\2\2\u068c")
- buf.write("\u068d\7\u00fa\2\2\u068d\u068f\7!\2\2\u068e\u068a\3\2")
- buf.write("\2\2\u068e\u068f\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u0691")
- buf.write("\5\u00caf\2\u0691\u0692\5\u00b4[\2\u0692\u0693\7_\2\2")
- buf.write("\u0693\u0694\7 \2\2\u0694\u00c9\3\2\2\2\u0695\u0696\7")
- buf.write("`\2\2\u0696\u0698\7\b\2\2\u0697\u0699\7\35\2\2\u0698\u0697")
- buf.write("\3\2\2\2\u0698\u0699\3\2\2\2\u0699\u069a\3\2\2\2\u069a")
- buf.write("\u069b\7\u00fa\2\2\u069b\u069c\7!\2\2\u069c\u069d\7a\2")
- buf.write("\2\u069d\u069f\7\b\2\2\u069e\u06a0\7\35\2\2\u069f\u069e")
- buf.write("\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1")
- buf.write("\u06a2\7\u00fa\2\2\u06a2\u06a7\7!\2\2\u06a3\u06a4\7b\2")
- buf.write("\2\u06a4\u06a5\7\b\2\2\u06a5\u06a6\7\u00fa\2\2\u06a6\u06a8")
- buf.write("\7!\2\2\u06a7\u06a3\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8")
- buf.write("\u00cb\3\2\2\2\u06a9\u06ae\5\u00ceh\2\u06aa\u06ab\7(\2")
- buf.write("\2\u06ab\u06ad\5\u00ceh\2\u06ac\u06aa\3\2\2\2\u06ad\u06b0")
- buf.write("\3\2\2\2\u06ae\u06ac\3\2\2\2\u06ae\u06af\3\2\2\2\u06af")
- buf.write("\u00cd\3\2\2\2\u06b0\u06ae\3\2\2\2\u06b1\u06bb\7\u00fa")
- buf.write("\2\2\u06b2\u06bb\7\u00ef\2\2\u06b3\u06bb\7\u00f0\2\2\u06b4")
- buf.write("\u06bb\7\u00f1\2\2\u06b5\u06bb\7\u00f2\2\2\u06b6\u06bb")
- buf.write("\7\u00f3\2\2\u06b7\u06bb\7\u00f4\2\2\u06b8\u06bb\7\u00f5")
- buf.write("\2\2\u06b9\u06bb\5V,\2\u06ba\u06b1\3\2\2\2\u06ba\u06b2")
- buf.write("\3\2\2\2\u06ba\u06b3\3\2\2\2\u06ba\u06b4\3\2\2\2\u06ba")
- buf.write("\u06b5\3\2\2\2\u06ba\u06b6\3\2\2\2\u06ba\u06b7\3\2\2\2")
- buf.write("\u06ba\u06b8\3\2\2\2\u06ba\u06b9\3\2\2\2\u06bb\u00cf\3")
- buf.write("\2\2\2\u06bc\u06bd\7\60\2\2\u06bd\u06be\5R*\2\u06be\u06bf")
- buf.write("\5T+\2\u06bf\u06c5\7!\2\2\u06c0\u06c1\7@\2\2\u06c1\u06c2")
- buf.write("\7\b\2\2\u06c2\u06c3\5\u00d2j\2\u06c3\u06c4\7!\2\2\u06c4")
- buf.write("\u06c6\3\2\2\2\u06c5\u06c0\3\2\2\2\u06c5\u06c6\3\2\2\2")
- buf.write("\u06c6\u06c8\3\2\2\2\u06c7\u06c9\5\u00caf\2\u06c8\u06c7")
- buf.write("\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06ca\3\2\2\2\u06ca")
- buf.write("\u06cb\5\u00b4[\2\u06cb\u06cc\7\61\2\2\u06cc\u06cd\7 ")
- buf.write("\2\2\u06cd\u00d1\3\2\2\2\u06ce\u06d3\5\u00ceh\2\u06cf")
- buf.write("\u06d0\7(\2\2\u06d0\u06d2\5\u00ceh\2\u06d1\u06cf\3\2\2")
- buf.write("\2\u06d2\u06d5\3\2\2\2\u06d3\u06d1\3\2\2\2\u06d3\u06d4")
- buf.write("\3\2\2\2\u06d4\u00d3\3\2\2\2\u06d5\u06d3\3\2\2\2\u06d6")
- buf.write("\u06d9\5\u00d6l\2\u06d7\u06d9\5\u00dco\2\u06d8\u06d6\3")
- buf.write("\2\2\2\u06d8\u06d7\3\2\2\2\u06d9\u00d5\3\2\2\2\u06da\u06db")
- buf.write("\7f\2\2\u06db\u06dc\5P)\2\u06dc\u06e2\7!\2\2\u06dd\u06de")
- buf.write("\7@\2\2\u06de\u06df\7\b\2\2\u06df\u06e0\5\u00d8m\2\u06e0")
- buf.write("\u06e1\7!\2\2\u06e1\u06e3\3\2\2\2\u06e2\u06dd\3\2\2\2")
- buf.write("\u06e2\u06e3\3\2\2\2\u06e3\u06e8\3\2\2\2\u06e4\u06e5\7")
- buf.write("t\2\2\u06e5\u06e6\7\b\2\2\u06e6\u06e7\7\u00fa\2\2\u06e7")
- buf.write("\u06e9\7!\2\2\u06e8\u06e4\3\2\2\2\u06e8\u06e9\3\2\2\2")
- buf.write("\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7h\2\2\u06eb\u06ec\7")
- buf.write("\b\2\2\u06ec\u06ed\7\u00fa\2\2\u06ed\u06ee\7!\2\2\u06ee")
- buf.write("\u06ef\7i\2\2\u06ef\u06f0\7\b\2\2\u06f0\u06f1\7\u00fa")
- buf.write("\2\2\u06f1\u06f2\7!\2\2\u06f2\u06f3\5\u00b4[\2\u06f3\u06f4")
- buf.write("\7g\2\2\u06f4\u06f5\7 \2\2\u06f5\u00d7\3\2\2\2\u06f6\u06fb")
- buf.write("\5\u00dan\2\u06f7\u06f8\7(\2\2\u06f8\u06fa\5\u00dan\2")
- buf.write("\u06f9\u06f7\3\2\2\2\u06fa\u06fd\3\2\2\2\u06fb\u06f9\3")
- buf.write("\2\2\2\u06fb\u06fc\3\2\2\2\u06fc\u00d9\3\2\2\2\u06fd\u06fb")
- buf.write("\3\2\2\2\u06fe\u0702\7\u00fa\2\2\u06ff\u0702\7\13\2\2")
- buf.write("\u0700\u0702\5V,\2\u0701\u06fe\3\2\2\2\u0701\u06ff\3\2")
- buf.write("\2\2\u0701\u0700\3\2\2\2\u0702\u00db\3\2\2\2\u0703\u0704")
- buf.write("\7d\2\2\u0704\u0705\5P)\2\u0705\u070b\7!\2\2\u0706\u0707")
- buf.write("\7@\2\2\u0707\u0708\7\b\2\2\u0708\u0709\5\u00dep\2\u0709")
- buf.write("\u070a\7!\2\2\u070a\u070c\3\2\2\2\u070b\u0706\3\2\2\2")
- buf.write("\u070b\u070c\3\2\2\2\u070c\u0711\3\2\2\2\u070d\u070e\7")
- buf.write("t\2\2\u070e\u070f\7\b\2\2\u070f\u0710\7\u00fa\2\2\u0710")
- buf.write("\u0712\7!\2\2\u0711\u070d\3\2\2\2\u0711\u0712\3\2\2\2")
- buf.write("\u0712\u0713\3\2\2\2\u0713\u0714\7h\2\2\u0714\u0715\7")
- buf.write("\b\2\2\u0715\u0716\7\u00fa\2\2\u0716\u0717\7!\2\2\u0717")
- buf.write("\u0718\7i\2\2\u0718\u0719\7\b\2\2\u0719\u071a\7\u00fa")
- buf.write("\2\2\u071a\u071f\7!\2\2\u071b\u071c\7j\2\2\u071c\u071d")
- buf.write("\7\b\2\2\u071d\u071e\7\u00fa\2\2\u071e\u0720\7!\2\2\u071f")
- buf.write("\u071b\3\2\2\2\u071f\u0720\3\2\2\2\u0720\u0721\3\2\2\2")
- buf.write("\u0721\u0722\5\u00b4[\2\u0722\u0723\7e\2\2\u0723\u0724")
- buf.write("\7 \2\2\u0724\u00dd\3\2\2\2\u0725\u072a\5\u00e0q\2\u0726")
- buf.write("\u0727\7(\2\2\u0727\u0729\5\u00e0q\2\u0728\u0726\3\2\2")
- buf.write("\2\u0729\u072c\3\2\2\2\u072a\u0728\3\2\2\2\u072a\u072b")
- buf.write("\3\2\2\2\u072b\u00df\3\2\2\2\u072c\u072a\3\2\2\2\u072d")
- buf.write("\u0730\7\u00fa\2\2\u072e\u0730\5V,\2\u072f\u072d\3\2\2")
- buf.write("\2\u072f\u072e\3\2\2\2\u0730\u00e1\3\2\2\2\u0731\u0732")
- buf.write("\7\63\2\2\u0732\u0733\5P)\2\u0733\u0738\7!\2\2\u0734\u0735")
- buf.write("\7\64\2\2\u0735\u0736\7\b\2\2\u0736\u0737\7\u00fa\2\2")
- buf.write("\u0737\u0739\7!\2\2\u0738\u0734\3\2\2\2\u0738\u0739\3")
- buf.write("\2\2\2\u0739\u073f\3\2\2\2\u073a\u073b\7@\2\2\u073b\u073c")
- buf.write("\7\b\2\2\u073c\u073d\5\u00e4s\2\u073d\u073e\7!\2\2\u073e")
- buf.write("\u0740\3\2\2\2\u073f\u073a\3\2\2\2\u073f\u0740\3\2\2\2")
- buf.write("\u0740\u0741\3\2\2\2\u0741\u0742\5\u00b4[\2\u0742\u0743")
- buf.write("\7\65\2\2\u0743\u0744\7 \2\2\u0744\u00e3\3\2\2\2\u0745")
- buf.write("\u074a\5\u00e6t\2\u0746\u0747\7(\2\2\u0747\u0749\5\u00e6")
- buf.write("t\2\u0748\u0746\3\2\2\2\u0749\u074c\3\2\2\2\u074a\u0748")
- buf.write("\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u00e5\3\2\2\2\u074c")
- buf.write("\u074a\3\2\2\2\u074d\u0752\7\u00fa\2\2\u074e\u0752\7\u00c0")
- buf.write("\2\2\u074f\u0752\7\u00c1\2\2\u0750\u0752\5V,\2\u0751\u074d")
- buf.write("\3\2\2\2\u0751\u074e\3\2\2\2\u0751\u074f\3\2\2\2\u0751")
- buf.write("\u0750\3\2\2\2\u0752\u00e7\3\2\2\2\u0753\u07ae\7A\2\2")
- buf.write("\u0754\u0755\5P)\2\u0755\u075b\7!\2\2\u0756\u0757\7@\2")
- buf.write("\2\u0757\u0758\7\b\2\2\u0758\u0759\5\u00ecw\2\u0759\u075a")
- buf.write("\7!\2\2\u075a\u075c\3\2\2\2\u075b\u0756\3\2\2\2\u075b")
- buf.write("\u075c\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u075e\5\u00b4")
- buf.write("[\2\u075e\u07af\3\2\2\2\u075f\u0760\7C\2\2\u0760\u0761")
- buf.write("\7\u008f\2\2\u0761\u0762\7\b\2\2\u0762\u0763\7\u00fb\2")
- buf.write("\2\u0763\u0764\7\34\2\2\u0764\u0765\7\u00fb\2\2\u0765")
- buf.write("\u0766\7!\2\2\u0766\u0767\7\62\2\2\u0767\u0768\7\b\2\2")
- buf.write("\u0768\u0769\7\u00ec\2\2\u0769\u076a\7\30\2\2\u076a\u076b")
- buf.write("\7\u00fa\2\2\u076b\u076c\7\31\2\2\u076c\u076d\7!\2\2\u076d")
- buf.write("\u076e\7=\2\2\u076e\u076f\7\b\2\2\u076f\u0770\7\u00ec")
- buf.write("\2\2\u0770\u0771\7\30\2\2\u0771\u0772\7\u00fa\2\2\u0772")
- buf.write("\u0773\7\31\2\2\u0773\u0774\7!\2\2\u0774\u0775\5\u00ea")
- buf.write("v\2\u0775\u0776\7D\2\2\u0776\u0777\7\u008f\2\2\u0777\u0778")
- buf.write("\7\b\2\2\u0778\u0779\7\u00fb\2\2\u0779\u077a\7\34\2\2")
- buf.write("\u077a\u077b\7\u00fb\2\2\u077b\u077c\7!\2\2\u077c\u077d")
- buf.write("\7\62\2\2\u077d\u077e\7\b\2\2\u077e\u077f\7\u00ec\2\2")
- buf.write("\u077f\u0780\7\30\2\2\u0780\u0781\7\u00fa\2\2\u0781\u0782")
- buf.write("\7\31\2\2\u0782\u0783\7!\2\2\u0783\u0784\7=\2\2\u0784")
- buf.write("\u0785\7\b\2\2\u0785\u0786\7\u00ec\2\2\u0786\u0787\7\30")
- buf.write("\2\2\u0787\u0788\7\u00fa\2\2\u0788\u0789\7\31\2\2\u0789")
- buf.write("\u078a\7!\2\2\u078a\u078b\5\u00eav\2\u078b\u078c\7E\2")
- buf.write("\2\u078c\u078d\7\u008f\2\2\u078d\u078e\7\b\2\2\u078e\u078f")
- buf.write("\7\u00fb\2\2\u078f\u0790\7\34\2\2\u0790\u0791\7\u00fb")
- buf.write("\2\2\u0791\u0792\7!\2\2\u0792\u0793\7\62\2\2\u0793\u0794")
- buf.write("\7\b\2\2\u0794\u0795\7\u00ec\2\2\u0795\u0796\7\30\2\2")
- buf.write("\u0796\u0797\7\u00fa\2\2\u0797\u0798\7\31\2\2\u0798\u0799")
- buf.write("\7!\2\2\u0799\u079a\7=\2\2\u079a\u079b\7\b\2\2\u079b\u079c")
- buf.write("\7\u00ec\2\2\u079c\u079d\7\30\2\2\u079d\u079e\7\u00fa")
- buf.write("\2\2\u079e\u079f\7\31\2\2\u079f\u07a0\7!\2\2\u07a0\u07a6")
- buf.write("\5\u00eav\2\u07a1\u07a2\7@\2\2\u07a2\u07a3\7\b\2\2\u07a3")
- buf.write("\u07a4\5\u00ecw\2\u07a4\u07a5\7!\2\2\u07a5\u07a7\3\2\2")
- buf.write("\2\u07a6\u07a1\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07ab")
- buf.write("\3\2\2\2\u07a8\u07aa\5\u008cG\2\u07a9\u07a8\3\2\2\2\u07aa")
- buf.write("\u07ad\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07ac\3\2\2\2")
- buf.write("\u07ac\u07af\3\2\2\2\u07ad\u07ab\3\2\2\2\u07ae\u0754\3")
- buf.write("\2\2\2\u07ae\u075f\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1")
- buf.write("\7B\2\2\u07b1\u07b2\7 \2\2\u07b2\u00e9\3\2\2\2\u07b3\u07b4")
- buf.write("\7`\2\2\u07b4\u07b5\7\b\2\2\u07b5\u07b6\7\u00fa\2\2\u07b6")
- buf.write("\u07b7\7!\2\2\u07b7\u07b8\7a\2\2\u07b8\u07b9\7\b\2\2\u07b9")
- buf.write("\u07ba\7\u00fa\2\2\u07ba\u07bf\7!\2\2\u07bb\u07bc\7b\2")
- buf.write("\2\u07bc\u07bd\7\b\2\2\u07bd\u07be\7\u00fa\2\2\u07be\u07c0")
- buf.write("\7!\2\2\u07bf\u07bb\3\2\2\2\u07bf\u07c0\3\2\2\2\u07c0")
- buf.write("\u07c5\3\2\2\2\u07c1\u07c2\7c\2\2\u07c2\u07c3\7\b\2\2")
- buf.write("\u07c3\u07c4\7\u00fa\2\2\u07c4\u07c6\7!\2\2\u07c5\u07c1")
- buf.write("\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u00eb\3\2\2\2\u07c7")
- buf.write("\u07cc\5\u00eex\2\u07c8\u07c9\7(\2\2\u07c9\u07cb\5\u00ee")
- buf.write("x\2\u07ca\u07c8\3\2\2\2\u07cb\u07ce\3\2\2\2\u07cc\u07ca")
- buf.write("\3\2\2\2\u07cc\u07cd\3\2\2\2\u07cd\u00ed\3\2\2\2\u07ce")
- buf.write("\u07cc\3\2\2\2\u07cf\u07d0\t\6\2\2\u07d0\u00ef\3\2\2\2")
- buf.write("\u07d1\u082c\7F\2\2\u07d2\u07d3\5P)\2\u07d3\u07d9\7!\2")
- buf.write("\2\u07d4\u07d5\7@\2\2\u07d5\u07d6\7\b\2\2\u07d6\u07d7")
- buf.write("\5\u00f4{\2\u07d7\u07d8\7!\2\2\u07d8\u07da\3\2\2\2\u07d9")
- buf.write("\u07d4\3\2\2\2\u07d9\u07da\3\2\2\2\u07da\u07db\3\2\2\2")
- buf.write("\u07db\u07dc\5\u00b4[\2\u07dc\u082d\3\2\2\2\u07dd\u07de")
- buf.write("\7H\2\2\u07de\u07df\7\u008f\2\2\u07df\u07e0\7\b\2\2\u07e0")
- buf.write("\u07e1\7\u00fb\2\2\u07e1\u07e2\7\34\2\2\u07e2\u07e3\7")
- buf.write("\u00fb\2\2\u07e3\u07e4\7!\2\2\u07e4\u07e5\7\62\2\2\u07e5")
- buf.write("\u07e6\7\b\2\2\u07e6\u07e7\7\u00ec\2\2\u07e7\u07e8\7\30")
- buf.write("\2\2\u07e8\u07e9\7\u00fa\2\2\u07e9\u07ea\7\31\2\2\u07ea")
- buf.write("\u07eb\7!\2\2\u07eb\u07ec\7=\2\2\u07ec\u07ed\7\b\2\2\u07ed")
- buf.write("\u07ee\7\u00ec\2\2\u07ee\u07ef\7\30\2\2\u07ef\u07f0\7")
- buf.write("\u00fa\2\2\u07f0\u07f1\7\31\2\2\u07f1\u07f2\7!\2\2\u07f2")
- buf.write("\u07f3\5\u00f2z\2\u07f3\u07f4\7I\2\2\u07f4\u07f5\7\u008f")
- buf.write("\2\2\u07f5\u07f6\7\b\2\2\u07f6\u07f7\7\u00fb\2\2\u07f7")
- buf.write("\u07f8\7\34\2\2\u07f8\u07f9\7\u00fb\2\2\u07f9\u07fa\7")
- buf.write("!\2\2\u07fa\u07fb\7\62\2\2\u07fb\u07fc\7\b\2\2\u07fc\u07fd")
- buf.write("\7\u00ec\2\2\u07fd\u07fe\7\30\2\2\u07fe\u07ff\7\u00fa")
- buf.write("\2\2\u07ff\u0800\7\31\2\2\u0800\u0801\7!\2\2\u0801\u0802")
- buf.write("\7=\2\2\u0802\u0803\7\b\2\2\u0803\u0804\7\u00ec\2\2\u0804")
- buf.write("\u0805\7\30\2\2\u0805\u0806\7\u00fa\2\2\u0806\u0807\7")
- buf.write("\31\2\2\u0807\u0808\7!\2\2\u0808\u0809\5\u00f2z\2\u0809")
- buf.write("\u080a\7J\2\2\u080a\u080b\7\u008f\2\2\u080b\u080c\7\b")
- buf.write("\2\2\u080c\u080d\7\u00fb\2\2\u080d\u080e\7\34\2\2\u080e")
- buf.write("\u080f\7\u00fb\2\2\u080f\u0810\7!\2\2\u0810\u0811\7\62")
- buf.write("\2\2\u0811\u0812\7\b\2\2\u0812\u0813\7\u00ec\2\2\u0813")
- buf.write("\u0814\7\30\2\2\u0814\u0815\7\u00fa\2\2\u0815\u0816\7")
- buf.write("\31\2\2\u0816\u0817\7!\2\2\u0817\u0818\7=\2\2\u0818\u0819")
- buf.write("\7\b\2\2\u0819\u081a\7\u00ec\2\2\u081a\u081b\7\30\2\2")
- buf.write("\u081b\u081c\7\u00fa\2\2\u081c\u081d\7\31\2\2\u081d\u081e")
- buf.write("\7!\2\2\u081e\u0824\5\u00f2z\2\u081f\u0820\7@\2\2\u0820")
- buf.write("\u0821\7\b\2\2\u0821\u0822\5\u00f4{\2\u0822\u0823\7!\2")
- buf.write("\2\u0823\u0825\3\2\2\2\u0824\u081f\3\2\2\2\u0824\u0825")
- buf.write("\3\2\2\2\u0825\u0829\3\2\2\2\u0826\u0828\5\u008cG\2\u0827")
- buf.write("\u0826\3\2\2\2\u0828\u082b\3\2\2\2\u0829\u0827\3\2\2\2")
- buf.write("\u0829\u082a\3\2\2\2\u082a\u082d\3\2\2\2\u082b\u0829\3")
- buf.write("\2\2\2\u082c\u07d2\3\2\2\2\u082c\u07dd\3\2\2\2\u082d\u082e")
- buf.write("\3\2\2\2\u082e\u082f\7G\2\2\u082f\u0830\7 \2\2\u0830\u00f1")
- buf.write("\3\2\2\2\u0831\u0832\7`\2\2\u0832\u0833\7\b\2\2\u0833")
- buf.write("\u0834\7\u00fa\2\2\u0834\u0835\7!\2\2\u0835\u0836\7a\2")
- buf.write("\2\u0836\u0837\7\b\2\2\u0837\u0838\7\u00fa\2\2\u0838\u083d")
- buf.write("\7!\2\2\u0839\u083a\7b\2\2\u083a\u083b\7\b\2\2\u083b\u083c")
- buf.write("\7\u00fa\2\2\u083c\u083e\7!\2\2\u083d\u0839\3\2\2\2\u083d")
- buf.write("\u083e\3\2\2\2\u083e\u0843\3\2\2\2\u083f\u0840\7c\2\2")
- buf.write("\u0840\u0841\7\b\2\2\u0841\u0842\7\u00fa\2\2\u0842\u0844")
- buf.write("\7!\2\2\u0843\u083f\3\2\2\2\u0843\u0844\3\2\2\2\u0844")
- buf.write("\u00f3\3\2\2\2\u0845\u084a\5\u00f6|\2\u0846\u0847\7(\2")
- buf.write("\2\u0847\u0849\5\u00f6|\2\u0848\u0846\3\2\2\2\u0849\u084c")
- buf.write("\3\2\2\2\u084a\u0848\3\2\2\2\u084a\u084b\3\2\2\2\u084b")
- buf.write("\u00f5\3\2\2\2\u084c\u084a\3\2\2\2\u084d\u084e\t\7\2\2")
- buf.write("\u084e\u00f7\3\2\2\2\u084f\u0854\5\u0104\u0083\2\u0850")
- buf.write("\u0854\5\u00fc\177\2\u0851\u0854\5\u00fe\u0080\2\u0852")
- buf.write("\u0854\5\u010e\u0088\2\u0853\u084f\3\2\2\2\u0853\u0850")
- buf.write("\3\2\2\2\u0853\u0851\3\2\2\2\u0853\u0852\3\2\2\2\u0854")
- buf.write("\u00f9\3\2\2\2\u0855\u0856\5\u0104\u0083\2\u0856\u0857")
- buf.write("\5\u010a\u0086\2\u0857\u0858\5\u010c\u0087\2\u0858\u0859")
- buf.write("\5\u010e\u0088\2\u0859\u00fb\3\2\2\2\u085a\u085b\5\u010a")
- buf.write("\u0086\2\u085b\u00fd\3\2\2\2\u085c\u085d\5\u010c\u0087")
- buf.write("\2\u085d\u00ff\3\2\2\2\u085e\u0865\5p9\2\u085f\u0865\5")
- buf.write("\u0088E\2\u0860\u0865\5\u00f8}\2\u0861\u0865\5\u0118\u008d")
- buf.write("\2\u0862\u0865\5\u011c\u008f\2\u0863\u0865\5\u0110\u0089")
- buf.write("\2\u0864\u085e\3\2\2\2\u0864\u085f\3\2\2\2\u0864\u0860")
- buf.write("\3\2\2\2\u0864\u0861\3\2\2\2\u0864\u0862\3\2\2\2\u0864")
- buf.write("\u0863\3\2\2\2\u0865\u0101\3\2\2\2\u0866\u086b\5p9\2\u0867")
- buf.write("\u086b\5\u0088E\2\u0868\u086b\5\u0118\u008d\2\u0869\u086b")
- buf.write("\5\u0110\u0089\2\u086a\u0866\3\2\2\2\u086a\u0867\3\2\2")
- buf.write("\2\u086a\u0868\3\2\2\2\u086a\u0869\3\2\2\2\u086b\u0103")
- buf.write("\3\2\2\2\u086c\u086d\7l\2\2\u086d\u086e\5\u0124\u0093")
- buf.write("\2\u086e\u0872\7 \2\2\u086f\u0871\5\u0100\u0081\2\u0870")
- buf.write("\u086f\3\2\2\2\u0871\u0874\3\2\2\2\u0872\u0870\3\2\2\2")
- buf.write("\u0872\u0873\3\2\2\2\u0873\u0875\3\2\2\2\u0874\u0872\3")
- buf.write("\2\2\2\u0875\u0876\7s\2\2\u0876\u0877\7 \2\2\u0877\u0105")
- buf.write("\3\2\2\2\u0878\u0885\7k\2\2\u0879\u087a\7@\2\2\u087a\u087b")
- buf.write("\7\b\2\2\u087b\u0880\5\u009eP\2\u087c\u087d\7(\2\2\u087d")
- buf.write("\u087f\5\u009eP\2\u087e\u087c\3\2\2\2\u087f\u0882\3\2")
- buf.write("\2\2\u0880\u087e\3\2\2\2\u0880\u0881\3\2\2\2\u0881\u0883")
- buf.write("\3\2\2\2\u0882\u0880\3\2\2\2\u0883\u0884\7!\2\2\u0884")
- buf.write("\u0886\3\2\2\2\u0885\u0879\3\2\2\2\u0885\u0886\3\2\2\2")
- buf.write("\u0886\u0887\3\2\2\2\u0887\u0888\5\u0124\u0093\2\u0888")
- buf.write("\u0889\7 \2\2\u0889\u0107\3\2\2\2\u088a\u0897\7K\2\2\u088b")
- buf.write("\u088c\7@\2\2\u088c\u088d\7\b\2\2\u088d\u0892\5\u009e")
- buf.write("P\2\u088e\u088f\7(\2\2\u088f\u0891\5\u009eP\2\u0890\u088e")
- buf.write("\3\2\2\2\u0891\u0894\3\2\2\2\u0892\u0890\3\2\2\2\u0892")
- buf.write("\u0893\3\2\2\2\u0893\u0895\3\2\2\2\u0894\u0892\3\2\2\2")
- buf.write("\u0895\u0896\7!\2\2\u0896\u0898\3\2\2\2\u0897\u088b\3")
- buf.write("\2\2\2\u0897\u0898\3\2\2\2\u0898\u0899\3\2\2\2\u0899\u089a")
- buf.write("\5\u0124\u0093\2\u089a\u089b\7 \2\2\u089b\u0109\3\2\2")
- buf.write("\2\u089c\u08a9\7k\2\2\u089d\u089e\7@\2\2\u089e\u089f\7")
- buf.write("\b\2\2\u089f\u08a4\5\u009eP\2\u08a0\u08a1\7(\2\2\u08a1")
- buf.write("\u08a3\5\u009eP\2\u08a2\u08a0\3\2\2\2\u08a3\u08a6\3\2")
- buf.write("\2\2\u08a4\u08a2\3\2\2\2\u08a4\u08a5\3\2\2\2\u08a5\u08a7")
- buf.write("\3\2\2\2\u08a6\u08a4\3\2\2\2\u08a7\u08a8\7!\2\2\u08a8")
- buf.write("\u08aa\3\2\2\2\u08a9\u089d\3\2\2\2\u08a9\u08aa\3\2\2\2")
- buf.write("\u08aa\u08ab\3\2\2\2\u08ab\u08ac\5\u0124\u0093\2\u08ac")
- buf.write("\u08b0\7 \2\2\u08ad\u08af\5\u0100\u0081\2\u08ae\u08ad")
- buf.write("\3\2\2\2\u08af\u08b2\3\2\2\2\u08b0\u08ae\3\2\2\2\u08b0")
- buf.write("\u08b1\3\2\2\2\u08b1\u08b3\3\2\2\2\u08b2\u08b0\3\2\2\2")
- buf.write("\u08b3\u08b4\7s\2\2\u08b4\u08b5\7 \2\2\u08b5\u010b\3\2")
- buf.write("\2\2\u08b6\u08c3\7K\2\2\u08b7\u08b8\7@\2\2\u08b8\u08b9")
- buf.write("\7\b\2\2\u08b9\u08be\5\u009eP\2\u08ba\u08bb\7(\2\2\u08bb")
- buf.write("\u08bd\5\u009eP\2\u08bc\u08ba\3\2\2\2\u08bd\u08c0\3\2")
- buf.write("\2\2\u08be\u08bc\3\2\2\2\u08be\u08bf\3\2\2\2\u08bf\u08c1")
- buf.write("\3\2\2\2\u08c0\u08be\3\2\2\2\u08c1\u08c2\7!\2\2\u08c2")
- buf.write("\u08c4\3\2\2\2\u08c3\u08b7\3\2\2\2\u08c3\u08c4\3\2\2\2")
- buf.write("\u08c4\u08c5\3\2\2\2\u08c5\u08c6\5\u0124\u0093\2\u08c6")
- buf.write("\u08ca\7 \2\2\u08c7\u08c9\5\u0100\u0081\2\u08c8\u08c7")
- buf.write("\3\2\2\2\u08c9\u08cc\3\2\2\2\u08ca\u08c8\3\2\2\2\u08ca")
- buf.write("\u08cb\3\2\2\2\u08cb\u08cd\3\2\2\2\u08cc\u08ca\3\2\2\2")
- buf.write("\u08cd\u08ce\7s\2\2\u08ce\u08cf\7 \2\2\u08cf\u010d\3\2")
- buf.write("\2\2\u08d0\u08d1\7p\2\2\u08d1\u08d2\7\62\2\2\u08d2\u08d3")
- buf.write("\7\b\2\2\u08d3\u08d4\7\u00ec\2\2\u08d4\u08d5\7\30\2\2")
- buf.write("\u08d5\u08d6\7\u00fa\2\2\u08d6\u08d7\7\31\2\2\u08d7\u08e4")
- buf.write("\7!\2\2\u08d8\u08d9\7@\2\2\u08d9\u08da\7\b\2\2\u08da\u08df")
- buf.write("\5\u009eP\2\u08db\u08dc\7(\2\2\u08dc\u08de\5\u009eP\2")
- buf.write("\u08dd\u08db\3\2\2\2\u08de\u08e1\3\2\2\2\u08df\u08dd\3")
- buf.write("\2\2\2\u08df\u08e0\3\2\2\2\u08e0\u08e2\3\2\2\2\u08e1\u08df")
- buf.write("\3\2\2\2\u08e2\u08e3\7!\2\2\u08e3\u08e5\3\2\2\2\u08e4")
- buf.write("\u08d8\3\2\2\2\u08e4\u08e5\3\2\2\2\u08e5\u08e6\3\2\2\2")
- buf.write("\u08e6\u08e7\5\u0124\u0093\2\u08e7\u08e8\7s\2\2\u08e8")
- buf.write("\u08e9\7 \2\2\u08e9\u010f\3\2\2\2\u08ea\u08ee\5\u0112")
- buf.write("\u008a\2\u08eb\u08ee\5\u0114\u008b\2\u08ec\u08ee\5\u0116")
- buf.write("\u008c\2\u08ed\u08ea\3\2\2\2\u08ed\u08eb\3\2\2\2\u08ed")
- buf.write("\u08ec\3\2\2\2\u08ee\u0111\3\2\2\2\u08ef\u08f0\7m\2\2")
- buf.write("\u08f0\u08f1\7\u0096\2\2\u08f1\u08f2\7\b\2\2\u08f2\u08f3")
- buf.write("\7\u00fa\2\2\u08f3\u08f4\7!\2\2\u08f4\u08f5\7t\2\2\u08f5")
- buf.write("\u08f6\7\b\2\2\u08f6\u08f7\7\u00fa\2\2\u08f7\u08f8\7 ")
- buf.write("\2\2\u08f8\u0113\3\2\2\2\u08f9\u08fa\7N\2\2\u08fa\u08fb")
- buf.write("\7=\2\2\u08fb\u08fc\7\b\2\2\u08fc\u08fd\7\u00ec\2\2\u08fd")
- buf.write("\u08fe\7\30\2\2\u08fe\u08ff\7\u00fa\2\2\u08ff\u0900\7")
- buf.write("\31\2\2\u0900\u0901\7!\2\2\u0901\u0902\7>\2\2\u0902\u0903")
- buf.write("\7\b\2\2\u0903\u0904\7\u00ec\2\2\u0904\u0905\7\30\2\2")
- buf.write("\u0905\u0906\7\u00fa\2\2\u0906\u0907\7\31\2\2\u0907\u090e")
- buf.write("\7!\2\2\u0908\u0909\7>\2\2\u0909\u090a\7\b\2\2\u090a\u090b")
- buf.write("\7\u00ec\2\2\u090b\u090c\7\30\2\2\u090c\u090d\7\u00fa")
- buf.write("\2\2\u090d\u090f\7\31\2\2\u090e\u0908\3\2\2\2\u090e\u090f")
- buf.write("\3\2\2\2\u090f\u0910\3\2\2\2\u0910\u0911\7 \2\2\u0911")
- buf.write("\u0115\3\2\2\2\u0912\u0913\t\b\2\2\u0913\u0914\7\u0087")
- buf.write("\2\2\u0914\u0915\7!\2\2\u0915\u0916\7/\2\2\u0916\u0917")
- buf.write("\7\b\2\2\u0917\u0918\7\u00fa\2\2\u0918\u0919\7!\2\2\u0919")
- buf.write("\u091a\7\62\2\2\u091a\u091b\7\b\2\2\u091b\u091c\7\u00ec")
- buf.write("\2\2\u091c\u091d\7\30\2\2\u091d\u091e\7\u00fa\2\2\u091e")
- buf.write("\u091f\7\31\2\2\u091f\u0920\7!\2\2\u0920\u0921\7=\2\2")
- buf.write("\u0921\u0922\7\b\2\2\u0922\u0923\7\u00ec\2\2\u0923\u0924")
- buf.write("\7\30\2\2\u0924\u0925\7\u00fa\2\2\u0925\u0931\7\31\2\2")
- buf.write("\u0926\u0927\7!\2\2\u0927\u0928\7@\2\2\u0928\u0929\7\b")
- buf.write("\2\2\u0929\u092e\5\u009eP\2\u092a\u092b\7(\2\2\u092b\u092d")
- buf.write("\5\u009eP\2\u092c\u092a\3\2\2\2\u092d\u0930\3\2\2\2\u092e")
- buf.write("\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0932\3\2\2\2")
- buf.write("\u0930\u092e\3\2\2\2\u0931\u0926\3\2\2\2\u0931\u0932\3")
- buf.write("\2\2\2\u0932\u0937\3\2\2\2\u0933\u0934\7!\2\2\u0934\u0935")
- buf.write("\7t\2\2\u0935\u0936\7\b\2\2\u0936\u0938\7\u00fa\2\2\u0937")
- buf.write("\u0933\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u0939\3\2\2\2")
- buf.write("\u0939\u093a\7 \2\2\u093a\u0117\3\2\2\2\u093b\u093c\7")
- buf.write("L\2\2\u093c\u093d\7\u00fa\2\2\u093d\u093e\7 \2\2\u093e")
- buf.write("\u0119\3\2\2\2\u093f\u0941\7\u0088\2\2\u0940\u0942\7!")
- buf.write("\2\2\u0941\u0940\3\2\2\2\u0941\u0942\3\2\2\2\u0942\u0943")
- buf.write("\3\2\2\2\u0943\u0944\7.\2\2\u0944\u0945\7\b\2\2\u0945")
- buf.write("\u0946\7\u00ec\2\2\u0946\u0947\7\30\2\2\u0947\u0948\7")
- buf.write("\u00fa\2\2\u0948\u0949\7\31\2\2\u0949\u0954\7!\2\2\u094a")
- buf.write("\u094b\7\u008d\2\2\u094b\u094c\7\u00fa\2\2\u094c\u094d")
- buf.write("\7!\2\2\u094d\u094e\7\u0089\2\2\u094e\u094f\t\t\2\2\u094f")
- buf.write("\u0955\7 \2\2\u0950\u0951\7M\2\2\u0951\u0952\7\b\2\2\u0952")
- buf.write("\u0953\7\u00fa\2\2\u0953\u0955\7 \2\2\u0954\u094a\3\2")
- buf.write("\2\2\u0954\u0950\3\2\2\2\u0955\u011b\3\2\2\2\u0956\u0957")
- buf.write("\7\u00a7\2\2\u0957\u0958\7[\2\2\u0958\u0959\7\b\2\2\u0959")
- buf.write("\u09a1\5L\'\2\u095a\u095b\7!\2\2\u095b\u095c\7\u00a9\2")
- buf.write("\2\u095c\u0999\7\b\2\2\u095d\u0961\7S\2\2\u095e\u095f")
- buf.write("\7\32\2\2\u095f\u0960\7\u00fa\2\2\u0960\u0962\7\33\2\2")
- buf.write("\u0961\u095e\3\2\2\2\u0961\u0962\3\2\2\2\u0962\u099a\3")
- buf.write("\2\2\2\u0963\u0967\7T\2\2\u0964\u0965\7\32\2\2\u0965\u0966")
- buf.write("\7\u00fa\2\2\u0966\u0968\7\33\2\2\u0967\u0964\3\2\2\2")
- buf.write("\u0967\u0968\3\2\2\2\u0968\u099a\3\2\2\2\u0969\u096d\7")
- buf.write("U\2\2\u096a\u096b\7\32\2\2\u096b\u096c\7\u00fa\2\2\u096c")
- buf.write("\u096e\7\33\2\2\u096d\u096a\3\2\2\2\u096d\u096e\3\2\2")
- buf.write("\2\u096e\u099a\3\2\2\2\u096f\u0973\7V\2\2\u0970\u0971")
- buf.write("\7\32\2\2\u0971\u0972\7\u00fa\2\2\u0972\u0974\7\33\2\2")
- buf.write("\u0973\u0970\3\2\2\2\u0973\u0974\3\2\2\2\u0974\u099a\3")
- buf.write("\2\2\2\u0975\u0979\7R\2\2\u0976\u0977\7\32\2\2\u0977\u0978")
- buf.write("\7\u00fa\2\2\u0978\u097a\7\33\2\2\u0979\u0976\3\2\2\2")
- buf.write("\u0979\u097a\3\2\2\2\u097a\u099a\3\2\2\2\u097b\u097f\7")
- buf.write("W\2\2\u097c\u097d\7\32\2\2\u097d\u097e\7\u00fa\2\2\u097e")
- buf.write("\u0980\7\33\2\2\u097f\u097c\3\2\2\2\u097f\u0980\3\2\2")
- buf.write("\2\u0980\u099a\3\2\2\2\u0981\u0985\7X\2\2\u0982\u0983")
- buf.write("\7\32\2\2\u0983\u0984\7\u00fa\2\2\u0984\u0986\7\33\2\2")
- buf.write("\u0985\u0982\3\2\2\2\u0985\u0986\3\2\2\2\u0986\u099a\3")
- buf.write("\2\2\2\u0987\u098b\7Y\2\2\u0988\u0989\7\32\2\2\u0989\u098a")
- buf.write("\7\u00fa\2\2\u098a\u098c\7\33\2\2\u098b\u0988\3\2\2\2")
- buf.write("\u098b\u098c\3\2\2\2\u098c\u099a\3\2\2\2\u098d\u0991\7")
- buf.write("Z\2\2\u098e\u098f\7\32\2\2\u098f\u0990\7\u00fa\2\2\u0990")
- buf.write("\u0992\7\33\2\2\u0991\u098e\3\2\2\2\u0991\u0992\3\2\2")
- buf.write("\2\u0992\u099a\3\2\2\2\u0993\u0997\7\u00fb\2\2\u0994\u0995")
- buf.write("\7\32\2\2\u0995\u0996\7\u00fa\2\2\u0996\u0998\7\33\2\2")
- buf.write("\u0997\u0994\3\2\2\2\u0997\u0998\3\2\2\2\u0998\u099a\3")
- buf.write("\2\2\2\u0999\u095d\3\2\2\2\u0999\u0963\3\2\2\2\u0999\u0969")
- buf.write("\3\2\2\2\u0999\u096f\3\2\2\2\u0999\u0975\3\2\2\2\u0999")
- buf.write("\u097b\3\2\2\2\u0999\u0981\3\2\2\2\u0999\u0987\3\2\2\2")
- buf.write("\u0999\u098d\3\2\2\2\u0999\u0993\3\2\2\2\u099a\u099e\3")
- buf.write("\2\2\2\u099b\u099d\5\u011e\u0090\2\u099c\u099b\3\2\2\2")
- buf.write("\u099d\u09a0\3\2\2\2\u099e\u099c\3\2\2\2\u099e\u099f\3")
- buf.write("\2\2\2\u099f\u09a2\3\2\2\2\u09a0\u099e\3\2\2\2\u09a1\u095a")
- buf.write("\3\2\2\2\u09a1\u09a2\3\2\2\2\u09a2\u09ab\3\2\2\2\u09a3")
- buf.write("\u09a7\7!\2\2\u09a4\u09a6\5\u011c\u008f\2\u09a5\u09a4")
- buf.write("\3\2\2\2\u09a6\u09a9\3\2\2\2\u09a7\u09a5\3\2\2\2\u09a7")
- buf.write("\u09a8\3\2\2\2\u09a8\u09aa\3\2\2\2\u09a9\u09a7\3\2\2\2")
- buf.write("\u09aa\u09ac\7\u00a8\2\2\u09ab\u09a3\3\2\2\2\u09ab\u09ac")
- buf.write("\3\2\2\2\u09ac\u09ad\3\2\2\2\u09ad\u09ae\7 \2\2\u09ae")
- buf.write("\u011d\3\2\2\2\u09af\u09b0\7!\2\2\u09b0\u09b4\7\u00aa")
- buf.write("\2\2\u09b1\u09b2\7\32\2\2\u09b2\u09b3\7\u00fa\2\2\u09b3")
- buf.write("\u09b5\7\33\2\2\u09b4\u09b1\3\2\2\2\u09b4\u09b5\3\2\2")
- buf.write("\2\u09b5\u09ba\3\2\2\2\u09b6\u09b7\7\34\2\2\u09b7\u09b9")
- buf.write("\5\u015c\u00af\2\u09b8\u09b6\3\2\2\2\u09b9\u09bc\3\2\2")
- buf.write("\2\u09ba\u09b8\3\2\2\2\u09ba\u09bb\3\2\2\2\u09bb\u09bd")
- buf.write("\3\2\2\2\u09bc\u09ba\3\2\2\2\u09bd\u09be\7\b\2\2\u09be")
- buf.write("\u09bf\7\u00fa\2\2\u09bf\u011f\3\2\2\2\u09c0\u09c1\5\u0122")
- buf.write("\u0092\2\u09c1\u09c2\7 \2\2\u09c2\u0121\3\2\2\2\u09c3")
- buf.write("\u09c4\7\u00ab\2\2\u09c4\u0123\3\2\2\2\u09c5\u09ca\5\u0128")
- buf.write("\u0095\2\u09c6\u09c7\7\u00dc\2\2\u09c7\u09c9\5\u0128\u0095")
- buf.write("\2\u09c8\u09c6\3\2\2\2\u09c9\u09cc\3\2\2\2\u09ca\u09c8")
- buf.write("\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb\u0125\3\2\2\2\u09cc")
- buf.write("\u09ca\3\2\2\2\u09cd\u09d2\5\u0128\u0095\2\u09ce\u09cf")
- buf.write("\7\u00dc\2\2\u09cf\u09d1\5\u0128\u0095\2\u09d0\u09ce\3")
- buf.write("\2\2\2\u09d1\u09d4\3\2\2\2\u09d2\u09d0\3\2\2\2\u09d2\u09d3")
- buf.write("\3\2\2\2\u09d3\u0127\3\2\2\2\u09d4\u09d2\3\2\2\2\u09d5")
- buf.write("\u09da\5\u012a\u0096\2\u09d6\u09d7\7\u00db\2\2\u09d7\u09d9")
- buf.write("\5\u012a\u0096\2\u09d8\u09d6\3\2\2\2\u09d9\u09dc\3\2\2")
- buf.write("\2\u09da\u09d8\3\2\2\2\u09da\u09db\3\2\2\2\u09db\u0129")
- buf.write("\3\2\2\2\u09dc\u09da\3\2\2\2\u09dd\u09e2\5\u012c\u0097")
- buf.write("\2\u09de\u09df\7(\2\2\u09df\u09e1\5\u012c\u0097\2\u09e0")
- buf.write("\u09de\3\2\2\2\u09e1\u09e4\3\2\2\2\u09e2\u09e0\3\2\2\2")
- buf.write("\u09e2\u09e3\3\2\2\2\u09e3\u012b\3\2\2\2\u09e4\u09e2\3")
- buf.write("\2\2\2\u09e5\u09ea\5\u012e\u0098\2\u09e6\u09e7\7)\2\2")
- buf.write("\u09e7\u09e9\5\u012e\u0098\2\u09e8\u09e6\3\2\2\2\u09e9")
- buf.write("\u09ec\3\2\2\2\u09ea\u09e8\3\2\2\2\u09ea\u09eb\3\2\2\2")
- buf.write("\u09eb\u012d\3\2\2\2\u09ec\u09ea\3\2\2\2\u09ed\u09f1\5")
- buf.write("\u0132\u009a\2\u09ee\u09f0\5\u0130\u0099\2\u09ef\u09ee")
- buf.write("\3\2\2\2\u09f0\u09f3\3\2\2\2\u09f1\u09ef\3\2\2\2\u09f1")
- buf.write("\u09f2\3\2\2\2\u09f2\u012f\3\2\2\2\u09f3\u09f1\3\2\2\2")
- buf.write("\u09f4\u09f5\7\"\2\2\u09f5\u09f9\5\u0132\u009a\2\u09f6")
- buf.write("\u09f7\7#\2\2\u09f7\u09f9\5\u0132\u009a\2\u09f8\u09f4")
- buf.write("\3\2\2\2\u09f8\u09f6\3\2\2\2\u09f9\u0131\3\2\2\2\u09fa")
- buf.write("\u09fe\5\u0136\u009c\2\u09fb\u09fd\5\u0134\u009b\2\u09fc")
- buf.write("\u09fb\3\2\2\2\u09fd\u0a00\3\2\2\2\u09fe\u09fc\3\2\2\2")
- buf.write("\u09fe\u09ff\3\2\2\2\u09ff\u0133\3\2\2\2\u0a00\u09fe\3")
- buf.write("\2\2\2\u0a01\u0a02\7%\2\2\u0a02\u0a0a\5\u0136\u009c\2")
- buf.write("\u0a03\u0a04\7$\2\2\u0a04\u0a0a\5\u0136\u009c\2\u0a05")
- buf.write("\u0a06\7\'\2\2\u0a06\u0a0a\5\u0136\u009c\2\u0a07\u0a08")
- buf.write("\7&\2\2\u0a08\u0a0a\5\u0136\u009c\2\u0a09\u0a01\3\2\2")
- buf.write("\2\u0a09\u0a03\3\2\2\2\u0a09\u0a05\3\2\2\2\u0a09\u0a07")
- buf.write("\3\2\2\2\u0a0a\u0135\3\2\2\2\u0a0b\u0a0f\5\u013a\u009e")
- buf.write("\2\u0a0c\u0a0e\5\u0138\u009d\2\u0a0d\u0a0c\3\2\2\2\u0a0e")
- buf.write("\u0a11\3\2\2\2\u0a0f\u0a0d\3\2\2\2\u0a0f\u0a10\3\2\2\2")
- buf.write("\u0a10\u0137\3\2\2\2\u0a11\u0a0f\3\2\2\2\u0a12\u0a13\7")
- buf.write("\f\2\2\u0a13\u0a17\5\u013a\u009e\2\u0a14\u0a15\7\r\2\2")
- buf.write("\u0a15\u0a17\5\u013a\u009e\2\u0a16\u0a12\3\2\2\2\u0a16")
- buf.write("\u0a14\3\2\2\2\u0a17\u0139\3\2\2\2\u0a18\u0a1c\5\u013e")
- buf.write("\u00a0\2\u0a19\u0a1b\5\u013c\u009f\2\u0a1a\u0a19\3\2\2")
- buf.write("\2\u0a1b\u0a1e\3\2\2\2\u0a1c\u0a1a\3\2\2\2\u0a1c\u0a1d")
- buf.write("\3\2\2\2\u0a1d\u013b\3\2\2\2\u0a1e\u0a1c\3\2\2\2\u0a1f")
- buf.write("\u0a20\7\16\2\2\u0a20\u0a24\5\u013e\u00a0\2\u0a21\u0a22")
- buf.write("\7\35\2\2\u0a22\u0a24\5\u013e\u00a0\2\u0a23\u0a1f\3\2")
- buf.write("\2\2\u0a23\u0a21\3\2\2\2\u0a24\u013d\3\2\2\2\u0a25\u0a29")
- buf.write("\5\u0142\u00a2\2\u0a26\u0a28\5\u0140\u00a1\2\u0a27\u0a26")
- buf.write("\3\2\2\2\u0a28\u0a2b\3\2\2\2\u0a29\u0a27\3\2\2\2\u0a29")
- buf.write("\u0a2a\3\2\2\2\u0a2a\u013f\3\2\2\2\u0a2b\u0a29\3\2\2\2")
- buf.write("\u0a2c\u0a2d\7\17\2\2\u0a2d\u0a33\5\u0142\u00a2\2\u0a2e")
- buf.write("\u0a2f\7\37\2\2\u0a2f\u0a33\5\u0142\u00a2\2\u0a30\u0a31")
- buf.write("\7\20\2\2\u0a31\u0a33\5\u0142\u00a2\2\u0a32\u0a2c\3\2")
- buf.write("\2\2\u0a32\u0a2e\3\2\2\2\u0a32\u0a30\3\2\2\2\u0a33\u0141")
- buf.write("\3\2\2\2\u0a34\u0a35\7\30\2\2\u0a35\u0a36\t\n\2\2\u0a36")
- buf.write("\u0a38\7\31\2\2\u0a37\u0a34\3\2\2\2\u0a38\u0a3b\3\2\2")
- buf.write("\2\u0a39\u0a37\3\2\2\2\u0a39\u0a3a\3\2\2\2\u0a3a\u0a3c")
- buf.write("\3\2\2\2\u0a3b\u0a39\3\2\2\2\u0a3c\u0a3d\5\u0144\u00a3")
- buf.write("\2\u0a3d\u0143\3\2\2\2\u0a3e\u0a4b\5\u0146\u00a4\2\u0a3f")
- buf.write("\u0a4b\5\u0148\u00a5\2\u0a40\u0a4b\5\u014a\u00a6\2\u0a41")
- buf.write("\u0a4b\5\u014c\u00a7\2\u0a42\u0a4b\5\u014e\u00a8\2\u0a43")
- buf.write("\u0a4b\5\u016c\u00b7\2\u0a44\u0a4b\5\u016e\u00b8\2\u0a45")
- buf.write("\u0a4b\5\u0184\u00c3\2\u0a46\u0a4b\5\u0194\u00cb\2\u0a47")
- buf.write("\u0a48\7\u00dd\2\2\u0a48\u0a4b\5\u0144\u00a3\2\u0a49\u0a4b")
- buf.write("\5\u014a\u00a6\2\u0a4a\u0a3e\3\2\2\2\u0a4a\u0a3f\3\2\2")
- buf.write("\2\u0a4a\u0a40\3\2\2\2\u0a4a\u0a41\3\2\2\2\u0a4a\u0a42")
- buf.write("\3\2\2\2\u0a4a\u0a43\3\2\2\2\u0a4a\u0a44\3\2\2\2\u0a4a")
- buf.write("\u0a45\3\2\2\2\u0a4a\u0a46\3\2\2\2\u0a4a\u0a47\3\2\2\2")
- buf.write("\u0a4a\u0a49\3\2\2\2\u0a4b\u0145\3\2\2\2\u0a4c\u0a4d\7")
- buf.write("\u00e7\2\2\u0a4d\u0a4e\7\30\2\2\u0a4e\u0a4f\5\u0126\u0094")
- buf.write("\2\u0a4f\u0a50\7!\2\2\u0a50\u0a51\5\u0126\u0094\2\u0a51")
- buf.write("\u0a52\7\31\2\2\u0a52\u0147\3\2\2\2\u0a53\u0a54\7\u00e5")
- buf.write("\2\2\u0a54\u0a55\7\30\2\2\u0a55\u0a56\5\u0126\u0094\2")
- buf.write("\u0a56\u0a57\7!\2\2\u0a57\u0a58\5\u0126\u0094\2\u0a58")
- buf.write("\u0a59\7\31\2\2\u0a59\u0149\3\2\2\2\u0a5a\u0a5b\7\u00e6")
- buf.write("\2\2\u0a5b\u0a5c\7\30\2\2\u0a5c\u0a5d\5\u0126\u0094\2")
- buf.write("\u0a5d\u0a5e\7!\2\2\u0a5e\u0a5f\5\u0126\u0094\2\u0a5f")
- buf.write("\u0a60\7!\2\2\u0a60\u0a61\5L\'\2\u0a61\u0a62\7\31\2\2")
- buf.write("\u0a62\u014b\3\2\2\2\u0a63\u0a64\7\30\2\2\u0a64\u0a65")
- buf.write("\5\u0126\u0094\2\u0a65\u0a66\7\31\2\2\u0a66\u014d\3\2")
- buf.write("\2\2\u0a67\u0a73\5\u0150\u00a9\2\u0a68\u0a73\5\u0152\u00aa")
- buf.write("\2\u0a69\u0a73\5\u0154\u00ab\2\u0a6a\u0a73\5\u0156\u00ac")
- buf.write("\2\u0a6b\u0a73\5\u0158\u00ad\2\u0a6c\u0a73\5\u015e\u00b0")
- buf.write("\2\u0a6d\u0a73\5\u0160\u00b1\2\u0a6e\u0a73\5\u0162\u00b2")
- buf.write("\2\u0a6f\u0a73\5\u0164\u00b3\2\u0a70\u0a73\5\u0166\u00b4")
- buf.write("\2\u0a71\u0a73\5\u016a\u00b6\2\u0a72\u0a67\3\2\2\2\u0a72")
- buf.write("\u0a68\3\2\2\2\u0a72\u0a69\3\2\2\2\u0a72\u0a6a\3\2\2\2")
- buf.write("\u0a72\u0a6b\3\2\2\2\u0a72\u0a6c\3\2\2\2\u0a72\u0a6d\3")
- buf.write("\2\2\2\u0a72\u0a6e\3\2\2\2\u0a72\u0a6f\3\2\2\2\u0a72\u0a70")
- buf.write("\3\2\2\2\u0a72\u0a71\3\2\2\2\u0a73\u014f\3\2\2\2\u0a74")
- buf.write("\u0a75\7\u00c7\2\2\u0a75\u0151\3\2\2\2\u0a76\u0a77\7\u00c8")
- buf.write("\2\2\u0a77\u0a78\7\u00c9\2\2\u0a78\u0a79\7\30\2\2\u0a79")
- buf.write("\u0a7a\7\u00fa\2\2\u0a7a\u0a85\7\31\2\2\u0a7b\u0a7c\7")
- buf.write("\"\2\2\u0a7c\u0a86\7\u00fa\2\2\u0a7d\u0a7e\7$\2\2\u0a7e")
- buf.write("\u0a86\7\u00fa\2\2\u0a7f\u0a80\7%\2\2\u0a80\u0a86\7\u00fa")
- buf.write("\2\2\u0a81\u0a82\7&\2\2\u0a82\u0a86\7\u00fa\2\2\u0a83")
- buf.write("\u0a84\7\'\2\2\u0a84\u0a86\7\u00fa\2\2\u0a85\u0a7b\3\2")
- buf.write("\2\2\u0a85\u0a7d\3\2\2\2\u0a85\u0a7f\3\2\2\2\u0a85\u0a81")
- buf.write("\3\2\2\2\u0a85\u0a83\3\2\2\2\u0a86\u0153\3\2\2\2\u0a87")
- buf.write("\u0a88\7\u00ca\2\2\u0a88\u0a93\5\u015a\u00ae\2\u0a89\u0a8a")
- buf.write("\7\"\2\2\u0a8a\u0a94\7\u00fa\2\2\u0a8b\u0a8c\7$\2\2\u0a8c")
- buf.write("\u0a94\7\u00fa\2\2\u0a8d\u0a8e\7%\2\2\u0a8e\u0a94\7\u00fa")
- buf.write("\2\2\u0a8f\u0a90\7&\2\2\u0a90\u0a94\7\u00fa\2\2\u0a91")
- buf.write("\u0a92\7\'\2\2\u0a92\u0a94\7\u00fa\2\2\u0a93\u0a89\3\2")
- buf.write("\2\2\u0a93\u0a8b\3\2\2\2\u0a93\u0a8d\3\2\2\2\u0a93\u0a8f")
- buf.write("\3\2\2\2\u0a93\u0a91\3\2\2\2\u0a94\u0155\3\2\2\2\u0a95")
- buf.write("\u0a96\7\u00cb\2\2\u0a96\u0aa1\5\u015a\u00ae\2\u0a97\u0a98")
- buf.write("\7\"\2\2\u0a98\u0aa2\5\u015a\u00ae\2\u0a99\u0a9a\7$\2")
- buf.write("\2\u0a9a\u0aa2\5\u015a\u00ae\2\u0a9b\u0a9c\7%\2\2\u0a9c")
- buf.write("\u0aa2\5\u015a\u00ae\2\u0a9d\u0a9e\7&\2\2\u0a9e\u0aa2")
- buf.write("\5\u015a\u00ae\2\u0a9f\u0aa0\7\'\2\2\u0aa0\u0aa2\5\u015a")
- buf.write("\u00ae\2\u0aa1\u0a97\3\2\2\2\u0aa1\u0a99\3\2\2\2\u0aa1")
- buf.write("\u0a9b\3\2\2\2\u0aa1\u0a9d\3\2\2\2\u0aa1\u0a9f\3\2\2\2")
- buf.write("\u0aa2\u0157\3\2\2\2\u0aa3\u0aa4\7\u00cc\2\2\u0aa4\u0aa5")
- buf.write("\5\u015a\u00ae\2\u0aa5\u0aa7\7\"\2\2\u0aa6\u0aa8\7\u00fa")
- buf.write("\2\2\u0aa7\u0aa6\3\2\2\2\u0aa8\u0aa9\3\2\2\2\u0aa9\u0aa7")
- buf.write("\3\2\2\2\u0aa9\u0aaa\3\2\2\2\u0aaa\u0159\3\2\2\2\u0aab")
- buf.write("\u0aac\7\u00fb\2\2\u0aac\u0aad\7\32\2\2\u0aad\u0aae\7")
- buf.write("\u00fa\2\2\u0aae\u0ab8\7\33\2\2\u0aaf\u0ab4\7\u00fb\2")
- buf.write("\2\u0ab0\u0ab1\7\34\2\2\u0ab1\u0ab3\5\u015c\u00af\2\u0ab2")
- buf.write("\u0ab0\3\2\2\2\u0ab3\u0ab6\3\2\2\2\u0ab4\u0ab2\3\2\2\2")
- buf.write("\u0ab4\u0ab5\3\2\2\2\u0ab5\u0ab8\3\2\2\2\u0ab6\u0ab4\3")
- buf.write("\2\2\2\u0ab7\u0aab\3\2\2\2\u0ab7\u0aaf\3\2\2\2\u0ab8\u015b")
- buf.write("\3\2\2\2\u0ab9\u0abd\7\u00fb\2\2\u0aba\u0abb\7\32\2\2")
- buf.write("\u0abb\u0abc\7\u00fa\2\2\u0abc\u0abe\7\33\2\2\u0abd\u0aba")
- buf.write("\3\2\2\2\u0abd\u0abe\3\2\2\2\u0abe\u015d\3\2\2\2\u0abf")
- buf.write("\u0ac0\7\u00cd\2\2\u0ac0\u0ac1\7\30\2\2\u0ac1\u0ac2\t")
- buf.write("\13\2\2\u0ac2\u0ac3\7\31\2\2\u0ac3\u015f\3\2\2\2\u0ac4")
- buf.write("\u0ac5\7\u00ce\2\2\u0ac5\u0ac6\7\30\2\2\u0ac6\u0ac7\7")
- buf.write("\u00fb\2\2\u0ac7\u0ac8\7\31\2\2\u0ac8\u0161\3\2\2\2\u0ac9")
- buf.write("\u0aca\7\u00cf\2\2\u0aca\u0ad0\7\30\2\2\u0acb\u0acc\7")
- buf.write("\u00ec\2\2\u0acc\u0acd\7\30\2\2\u0acd\u0ace\7\u00fa\2")
- buf.write("\2\u0ace\u0ad1\7\31\2\2\u0acf\u0ad1\7\u00fa\2\2\u0ad0")
- buf.write("\u0acb\3\2\2\2\u0ad0\u0acf\3\2\2\2\u0ad1\u0ad2\3\2\2\2")
- buf.write("\u0ad2\u0ad3\7\31\2\2\u0ad3\u0163\3\2\2\2\u0ad4\u0ad5")
- buf.write("\7\u00d0\2\2\u0ad5\u0165\3\2\2\2\u0ad6\u0ad7\7\u00d1\2")
- buf.write("\2\u0ad7\u0ad8\7\30\2\2\u0ad8\u0ad9\5L\'\2\u0ad9\u0ada")
- buf.write("\7\31\2\2\u0ada\u0167\3\2\2\2\u0adb\u0adc\t\f\2\2\u0adc")
- buf.write("\u0169\3\2\2\2\u0add\u0ade\7\u00d2\2\2\u0ade\u0adf\7\30")
- buf.write("\2\2\u0adf\u0ae4\5X-\2\u0ae0\u0ae1\7(\2\2\u0ae1\u0ae2")
- buf.write("\7@\2\2\u0ae2\u0ae3\7\b\2\2\u0ae3\u0ae5\5\u0168\u00b5")
- buf.write("\2\u0ae4\u0ae0\3\2\2\2\u0ae4\u0ae5\3\2\2\2\u0ae5\u0ae6")
- buf.write("\3\2\2\2\u0ae6\u0ae7\7\31\2\2\u0ae7\u016b\3\2\2\2\u0ae8")
- buf.write("\u0ae9\t\r\2\2\u0ae9\u016d\3\2\2\2\u0aea\u0af5\5\u0170")
- buf.write("\u00b9\2\u0aeb\u0af5\5\u0172\u00ba\2\u0aec\u0af5\5\u0174")
- buf.write("\u00bb\2\u0aed\u0af5\5\u0176\u00bc\2\u0aee\u0af5\5\u0178")
- buf.write("\u00bd\2\u0aef\u0af5\5\u017a\u00be\2\u0af0\u0af5\5\u017c")
- buf.write("\u00bf\2\u0af1\u0af5\5\u017e\u00c0\2\u0af2\u0af5\5\u0180")
- buf.write("\u00c1\2\u0af3\u0af5\5\u0182\u00c2\2\u0af4\u0aea\3\2\2")
- buf.write("\2\u0af4\u0aeb\3\2\2\2\u0af4\u0aec\3\2\2\2\u0af4\u0aed")
- buf.write("\3\2\2\2\u0af4\u0aee\3\2\2\2\u0af4\u0aef\3\2\2\2\u0af4")
- buf.write("\u0af0\3\2\2\2\u0af4\u0af1\3\2\2\2\u0af4\u0af2\3\2\2\2")
- buf.write("\u0af4\u0af3\3\2\2\2\u0af5\u016f\3\2\2\2\u0af6\u0af7\7")
- buf.write("\u00da\2\2\u0af7\u0af8\7\30\2\2\u0af8\u0af9\5\u0126\u0094")
- buf.write("\2\u0af9\u0afa\7\31\2\2\u0afa\u0171\3\2\2\2\u0afb\u0afc")
- buf.write("\7\u00df\2\2\u0afc\u0afd\7\30\2\2\u0afd\u0afe\5\u0126")
- buf.write("\u0094\2\u0afe\u0aff\7\31\2\2\u0aff\u0173\3\2\2\2\u0b00")
- buf.write("\u0b01\7\u00e8\2\2\u0b01\u0b09\7\30\2\2\u0b02\u0b03\7")
- buf.write("*\2\2\u0b03\u0b04\7\b\2\2\u0b04\u0b05\7\u00ec\2\2\u0b05")
- buf.write("\u0b06\7\30\2\2\u0b06\u0b07\7\u00fa\2\2\u0b07\u0b08\7")
- buf.write("\31\2\2\u0b08\u0b0a\7!\2\2\u0b09\u0b02\3\2\2\2\u0b09\u0b0a")
- buf.write("\3\2\2\2\u0b0a\u0b10\3\2\2\2\u0b0b\u0b0c\7[\2\2\u0b0c")
- buf.write("\u0b0d\7\b\2\2\u0b0d\u0b0e\5L\'\2\u0b0e\u0b0f\7!\2\2\u0b0f")
- buf.write("\u0b11\3\2\2\2\u0b10\u0b0b\3\2\2\2\u0b10\u0b11\3\2\2\2")
- buf.write("\u0b11\u0b12\3\2\2\2\u0b12\u0b13\5\u0126\u0094\2\u0b13")
- buf.write("\u0b14\7\31\2\2\u0b14\u0175\3\2\2\2\u0b15\u0b16\7\u00e9")
- buf.write("\2\2\u0b16\u0b17\7\30\2\2\u0b17\u0b18\5\u0126\u0094\2")
- buf.write("\u0b18\u0b19\7\31\2\2\u0b19\u0177\3\2\2\2\u0b1a\u0b1b")
- buf.write("\7\u00e0\2\2\u0b1b\u0b1c\7\30\2\2\u0b1c\u0b1d\5\u0126")
- buf.write("\u0094\2\u0b1d\u0b1e\7\31\2\2\u0b1e\u0179\3\2\2\2\u0b1f")
- buf.write("\u0b24\7\u00e1\2\2\u0b20\u0b21\7\21\2\2\u0b21\u0b22\7")
- buf.write("\b\2\2\u0b22\u0b23\7\u00fa\2\2\u0b23\u0b25\7!\2\2\u0b24")
- buf.write("\u0b20\3\2\2\2\u0b24\u0b25\3\2\2\2\u0b25\u0b26\3\2\2\2")
- buf.write("\u0b26\u0b27\7\30\2\2\u0b27\u0b28\5\u0126\u0094\2\u0b28")
- buf.write("\u0b29\7\31\2\2\u0b29\u017b\3\2\2\2\u0b2a\u0b2b\7\u00e2")
- buf.write("\2\2\u0b2b\u0b2c\7\30\2\2\u0b2c\u0b2d\5\u0126\u0094\2")
- buf.write("\u0b2d\u0b2e\7\31\2\2\u0b2e\u017d\3\2\2\2\u0b2f\u0b30")
- buf.write("\7\u00e3\2\2\u0b30\u0b31\7\30\2\2\u0b31\u0b32\5\u0126")
- buf.write("\u0094\2\u0b32\u0b33\7\31\2\2\u0b33\u017f\3\2\2\2\u0b34")
- buf.write("\u0b35\7\u00e4\2\2\u0b35\u0b36\7\30\2\2\u0b36\u0b37\5")
- buf.write("\u0126\u0094\2\u0b37\u0b38\7\31\2\2\u0b38\u0181\3\2\2")
- buf.write("\2\u0b39\u0b3a\7\u00de\2\2\u0b3a\u0b3b\7\30\2\2\u0b3b")
- buf.write("\u0b40\5X-\2\u0b3c\u0b3d\7(\2\2\u0b3d\u0b3e\7@\2\2\u0b3e")
- buf.write("\u0b3f\7\b\2\2\u0b3f\u0b41\5\u0168\u00b5\2\u0b40\u0b3c")
- buf.write("\3\2\2\2\u0b40\u0b41\3\2\2\2\u0b41\u0b42\3\2\2\2\u0b42")
- buf.write("\u0b43\7!\2\2\u0b43\u0b44\5\u0126\u0094\2\u0b44\u0b45")
- buf.write("\7\31\2\2\u0b45\u0183\3\2\2\2\u0b46\u0b4c\5\u0186\u00c4")
- buf.write("\2\u0b47\u0b4c\5\u0188\u00c5\2\u0b48\u0b4c\5\u018c\u00c7")
- buf.write("\2\u0b49\u0b4c\5\u018e\u00c8\2\u0b4a\u0b4c\5\u0190\u00c9")
- buf.write("\2\u0b4b\u0b46\3\2\2\2\u0b4b\u0b47\3\2\2\2\u0b4b\u0b48")
- buf.write("\3\2\2\2\u0b4b\u0b49\3\2\2\2\u0b4b\u0b4a\3\2\2\2\u0b4c")
- buf.write("\u0185\3\2\2\2\u0b4d\u0b4e\7\u00c2\2\2\u0b4e\u0b4f\7\30")
- buf.write("\2\2\u0b4f\u0b50\5\u0126\u0094\2\u0b50\u0b51\7\22\2\2")
- buf.write("\u0b51\u0b52\5\u0126\u0094\2\u0b52\u0b53\7\36\2\2\u0b53")
- buf.write("\u0b54\5\u0126\u0094\2\u0b54\u0b55\7\31\2\2\u0b55\u0187")
- buf.write("\3\2\2\2\u0b56\u0b57\7\u00c3\2\2\u0b57\u0b58\7\30\2\2")
- buf.write("\u0b58\u0b5d\5\u018a\u00c6\2\u0b59\u0b5a\7(\2\2\u0b5a")
- buf.write("\u0b5c\5\u018a\u00c6\2\u0b5b\u0b59\3\2\2\2\u0b5c\u0b5f")
- buf.write("\3\2\2\2\u0b5d\u0b5b\3\2\2\2\u0b5d\u0b5e\3\2\2\2\u0b5e")
- buf.write("\u0b60\3\2\2\2\u0b5f\u0b5d\3\2\2\2\u0b60\u0b61\7!\2\2")
- buf.write("\u0b61\u0b62\5\u0126\u0094\2\u0b62\u0b63\7!\2\2\u0b63")
- buf.write("\u0b64\5\u0126\u0094\2\u0b64\u0b65\7!\2\2\u0b65\u0b66")
- buf.write("\5\u0126\u0094\2\u0b66\u0b67\7\31\2\2\u0b67\u0189\3\2")
- buf.write("\2\2\u0b68\u0b69\t\16\2\2\u0b69\u018b\3\2\2\2\u0b6a\u0b6b")
- buf.write("\7\u00c4\2\2\u0b6b\u0b6c\7\30\2\2\u0b6c\u0b6d\5\u0126")
- buf.write("\u0094\2\u0b6d\u0b6e\7!\2\2\u0b6e\u0b6f\5\u0126\u0094")
- buf.write("\2\u0b6f\u0b70\7!\2\2\u0b70\u0b71\5\u0126\u0094\2\u0b71")
- buf.write("\u0b72\7\31\2\2\u0b72\u018d\3\2\2\2\u0b73\u0b74\7\u00c5")
- buf.write("\2\2\u0b74\u0b75\7\30\2\2\u0b75\u0b76\5\u0126\u0094\2")
- buf.write("\u0b76\u0b77\7!\2\2\u0b77\u0b78\5\u0126\u0094\2\u0b78")
- buf.write("\u0b79\7!\2\2\u0b79\u0b7a\5\u0126\u0094\2\u0b7a\u0b7b")
- buf.write("\7\31\2\2\u0b7b\u018f\3\2\2\2\u0b7c\u0b7d\7\u00c6\2\2")
- buf.write("\u0b7d\u0b7e\7\30\2\2\u0b7e\u0b7f\7@\2\2\u0b7f\u0b80\7")
- buf.write("\b\2\2\u0b80\u0b85\5\u0192\u00ca\2\u0b81\u0b82\7(\2\2")
- buf.write("\u0b82\u0b84\5\u0192\u00ca\2\u0b83\u0b81\3\2\2\2\u0b84")
- buf.write("\u0b87\3\2\2\2\u0b85\u0b83\3\2\2\2\u0b85\u0b86\3\2\2\2")
- buf.write("\u0b86\u0b88\3\2\2\2\u0b87\u0b85\3\2\2\2\u0b88\u0b89\7")
- buf.write("!\2\2\u0b89\u0b8a\5\u0126\u0094\2\u0b8a\u0b8b\7!\2\2\u0b8b")
- buf.write("\u0b8c\5\u0126\u0094\2\u0b8c\u0b8d\7!\2\2\u0b8d\u0b8e")
- buf.write("\5\u0126\u0094\2\u0b8e\u0b8f\7\31\2\2\u0b8f\u0191\3\2")
- buf.write("\2\2\u0b90\u0b91\t\17\2\2\u0b91\u0193\3\2\2\2\u0b92\u0b93")
- buf.write("\7\u00ea\2\2\u0b93\u0b94\7\30\2\2\u0b94\u0b95\5\u0126")
- buf.write("\u0094\2\u0b95\u0b9d\7\36\2\2\u0b96\u0b97\5\u0124\u0093")
- buf.write("\2\u0b97\u0b98\7!\2\2\u0b98\u0b99\5\u0124\u0093\2\u0b99")
- buf.write("\u0b9a\7 \2\2\u0b9a\u0b9c\3\2\2\2\u0b9b\u0b96\3\2\2\2")
- buf.write("\u0b9c\u0b9f\3\2\2\2\u0b9d\u0b9b\3\2\2\2\u0b9d\u0b9e\3")
- buf.write("\2\2\2\u0b9e\u0ba0\3\2\2\2\u0b9f\u0b9d\3\2\2\2\u0ba0\u0ba1")
- buf.write("\7\31\2\2\u0ba1\u0195\3\2\2\2\u00f0\u0199\u019b\u01a5")
- buf.write("\u01a9\u01ac\u01b4\u01b9\u01bd\u01c0\u01c6\u01cb\u01cf")
- buf.write("\u01d2\u01d8\u01ea\u01ec\u01f4\u01fd\u0206\u020f\u0218")
- buf.write("\u0221\u022a\u0233\u023c\u0245\u024b\u0253\u025b\u0263")
- buf.write("\u0281\u0288\u028f\u0298\u029c\u02a0\u02a7\u02b1\u02be")
- buf.write("\u02cd\u02e2\u02e8\u0304\u030a\u0313\u0326\u0336\u0341")
- buf.write("\u0372\u0382\u0389\u038f\u03a7\u03b2\u03b5\u03b8\u03df")
- buf.write("\u03e3\u03f0\u03f7\u0409\u041e\u0433\u0439\u044f\u045c")
- buf.write("\u0460\u0465\u046b\u046e\u0472\u0476\u047d\u0497\u04a1")
- buf.write("\u04a9\u04ad\u04b3\u04b7\u04e5\u04e9\u04f0\u04f6\u04fa")
- buf.write("\u0503\u0508\u0514\u051f\u052c\u053d\u0542\u0547\u0558")
- buf.write("\u055d\u0562\u056a\u058a\u058f\u0594\u059e\u05a8\u05b4")
- buf.write("\u05b9\u05be\u05ca\u05cf\u05d4\u05de\u05e4\u05ff\u0605")
- buf.write("\u060f\u061d\u062a\u062f\u0633\u063e\u0644\u064f\u0658")
- buf.write("\u0662\u0674\u0679\u067d\u0688\u068e\u0698\u069f\u06a7")
- buf.write("\u06ae\u06ba\u06c5\u06c8\u06d3\u06d8\u06e2\u06e8\u06fb")
- buf.write("\u0701\u070b\u0711\u071f\u072a\u072f\u0738\u073f\u074a")
- buf.write("\u0751\u075b\u07a6\u07ab\u07ae\u07bf\u07c5\u07cc\u07d9")
- buf.write("\u0824\u0829\u082c\u083d\u0843\u084a\u0853\u0864\u086a")
- buf.write("\u0872\u0880\u0885\u0892\u0897\u08a4\u08a9\u08b0\u08be")
- buf.write("\u08c3\u08ca\u08df\u08e4\u08ed\u090e\u092e\u0931\u0937")
- buf.write("\u0941\u0954\u0961\u0967\u096d\u0973\u0979\u097f\u0985")
- buf.write("\u098b\u0991\u0997\u0999\u099e\u09a1\u09a7\u09ab\u09b4")
- buf.write("\u09ba\u09ca\u09d2\u09da\u09e2\u09ea\u09f1\u09f8\u09fe")
- buf.write("\u0a09\u0a0f\u0a16\u0a1c\u0a23\u0a29\u0a32\u0a39\u0a4a")
- buf.write("\u0a72\u0a85\u0a93\u0aa1\u0aa9\u0ab4\u0ab7\u0abd\u0ad0")
- buf.write("\u0ae4\u0af4\u0b09\u0b10\u0b24\u0b40\u0b4b\u0b5d\u0b85")
- buf.write("\u0b9d")
+ 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\u01d2")
+ 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\u0530")
+ 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\u0634")
+ 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\u09dc")
+ 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.GetDefaultStore(), RefName, DefaultStoreNameId, DefaultId) , Line)
- DSObj.SetDefaultName(DefaultStoreNameId)
- DSObj.SetDefaultId (DefaultId)
- DSObj.SetLineNo(Line)
- else:
- pNode, ReturnCode = gCVfrDefaultStore.ReRegisterDefaultStoreById(DefaultId, RefName, DefaultStoreNameId)
- self.__ErrorHandler(ReturnCode, Line)
- DSObj.SetDefaultStore = pNode.ObjAddr
- DSObj.SetLineNo(Line)
-
- ctx.Node.Data = DSObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreLinear.
- def visitVfrStatementVarStoreLinear(self, ctx:VfrSyntaxParser.VfrStatementVarStoreLinearContext):
- VSObj = CIfrVarStore()
- self.visitChildren(ctx)
- Line = ctx.start.line
- VSObj.SetLineNo(Line)
-
- TypeName = str(ctx.getChild(1))
- if TypeName == 'CHAR16':
- TypeName = 'UINT16'
-
- IsBitVarStore = False
- if ctx.TN != None:
- IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField(ctx.TN.text)
-
- VarStoreId = EFI_VARSTORE_ID_INVALID
- if ctx.VarId() != None:
- VarStoreId = self.__TransNum(ctx.ID.text)
- self.__CompareErrorHandler(VarStoreId!=0, True, ctx.ID.line, ctx.ID.text, 'varid 0 is not allowed.')
- StoreName = ctx.SN.text
- Guid = ctx.guidDefinition().Guid
- self.__ErrorHandler(gCVfrDataStorage.DeclareBufferVarStore(StoreName, Guid, gCVfrVarDataTypeDB, TypeName, VarStoreId, IsBitVarStore), Line)
- VSObj.SetGuid(Guid)
- VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(StoreName, Guid)
- self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
- VSObj.SetVarStoreId(VarStoreId)
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
- self.__ErrorHandler(ReturnCode, Line)
- VSObj.SetSize(Size)
- VSObj.SetName(StoreName)
-
- ctx.Node.Data = VSObj
-
- return VSObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreEfi.
- def visitVfrStatementVarStoreEfi(self, ctx:VfrSyntaxParser.VfrStatementVarStoreEfiContext):
-
- VSEObj = CIfrVarStoreEfi()
- self.visitChildren(ctx)
- Line = ctx.start.line
- VSEObj.SetLineNo(Line)
-
- Guid = ctx.guidDefinition().Guid
-
- CustomizedName = False
- IsBitVarStore = False
- VarStoreId = EFI_VARSTORE_ID_INVALID
- IsUEFI23EfiVarstore = True
- ReturnCode = None
-
- TypeName = str(ctx.getChild(1))
-
- if TypeName == 'CHAR16':
- TypeName = 'UINT16'
-
- elif ctx.TN != None:
- CustomizedName = True
- IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField(TypeName)
-
- if ctx.VarId() != None:
- VarStoreId = self.__TransNum(ctx.ID.text)
- self.__CompareErrorHandler(VarStoreId!=0, True, ctx.ID.line, ctx.ID.text, 'varid 0 is not allowed.')
-
- Attributes = 0
- for AtrCtx in ctx.vfrVarStoreEfiAttr():
- Attributes |= AtrCtx.Attr
- VSEObj.SetAttributes(Attributes)
-
- if ctx.SN != None:
- StoreName = ctx.SN.text
- else:
- IsUEFI23EfiVarstore = False
- NameStringId = self.__TransNum(ctx.VN.text)
- StoreName = gCVfrStringDB.GetVarStoreNameFromStringId(NameStringId) #
- if StoreName == None:
- gCVfrErrorHandle.HandleWarning(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.VN.line, 'Can\'t get varstore name for this StringId!')
- if not(CustomizedName):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, 'Old style efivarstore must have String Identifier!')
- Size = self.__TransNum(ctx.N.text)
- if Size == 1: TypeName = 'UINT8'
- elif Size == 2: TypeName = 'UINT16'
- elif Size == 4: TypeName = 'UINT32'
- elif Size == 8: TypeName = 'UINT64'
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line, ctx.N.text)
-
- if IsUEFI23EfiVarstore:
- self.__ErrorHandler(gCVfrDataStorage.DeclareBufferVarStore(StoreName, Guid, gCVfrVarDataTypeDB, TypeName, VarStoreId, IsBitVarStore, Attributes), Line)
- VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(StoreName, Guid)
- self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
- self.__ErrorHandler(ReturnCode, Line)
- else:
- self.__ErrorHandler(gCVfrDataStorage.DeclareBufferVarStore(self.__GetText(ctx.TN), Guid, gCVfrVarDataTypeDB, TypeName, VarStoreId, IsBitVarStore, Attributes), Line) #
- VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(self.__GetText(ctx.TN), Guid)
- self.__ErrorHandler(ReturnCode, ctx.VN.line, ctx.VN.text)
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(TypeName)
- self.__ErrorHandler(ReturnCode, ctx.N.line)
-
- VSEObj.SetGuid(Guid)
- VSEObj.SetVarStoreId (VarStoreId)
- VSEObj.SetSize(Size)
- VSEObj.SetName(StoreName)
-
- ctx.Node.Data = VSEObj
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrVarStoreEfiAttr.
- def visitVfrVarStoreEfiAttr(self, ctx:VfrSyntaxParser.VfrVarStoreEfiAttrContext):
-
- self.visitChildren(ctx)
- ctx.Attr = self.__TransNum(ctx.Number())
- return ctx.Attr
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarStoreNameValue.
- def visitVfrStatementVarStoreNameValue(self, ctx:VfrSyntaxParser.VfrStatementVarStoreNameValueContext):
-
- VSNVObj = CIfrVarStoreNameValue()
- self.visitChildren(ctx)
-
- Guid = ctx.guidDefinition().Guid
- HasVarStoreId = False
- VarStoreId = EFI_VARSTORE_ID_INVALID
-
- if ctx.VarId() != None:
- HasVarStoreId = True
- VarStoreId = self.__TransNum(ctx.ID.text)
- self.__CompareErrorHandler(VarStoreId !=0, True, ctx.ID.line, ctx.ID.text, 'varid 0 is not allowed')
-
- StoreName = ctx.SN.text
- Created = False
-
- sIndex = 0 if HasVarStoreId == False else 1
- eIndex = len(ctx.Name())
- for i in range(sIndex, eIndex):
- if Created == False:
- self.__ErrorHandler(gCVfrDataStorage.DeclareNameVarStoreBegin(StoreName, VarStoreId), ctx.SN.line, ctx.SN.text)
- Created = True
- Item = self.__TransNum(ctx.Number(i))
- gCVfrDataStorage.NameTableAddItem(Item)
-
- gCVfrDataStorage.DeclareNameVarStoreEnd(Guid)
-
- VSNVObj.SetLineNo(ctx.start.line)
- VSNVObj.SetGuid(Guid)
- VarstoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(StoreName, Guid)
- self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
- VSNVObj.SetVarStoreId(VarstoreId)
-
- ctx.Node.Data = VSNVObj
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDisableIfFormSet.
- def visitVfrStatementDisableIfFormSet(self, ctx:VfrSyntaxParser.VfrStatementDisableIfFormSetContext):
-
- DIObj = CIfrDisableIf()
- DIObj.SetLineNo(ctx.start.line)
- self.__ConstantOnlyInExpression = True
- ctx.Node.Data = DIObj
- Condition = 'disableif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- ctx.Node.Condition = Condition
- self.visitChildren(ctx)
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfFormSet.
- def visitVfrStatementSuppressIfFormSet(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfFormSetContext):
-
- SIObj = CIfrSuppressIf()
- SIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = SIObj
- Condition = 'suppressif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- ctx.Node.Condition = Condition
- self.visitChildren(ctx)
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#guidSubDefinition.
- def visitGuidSubDefinition(self, ctx:VfrSyntaxParser.GuidSubDefinitionContext):
-
- ctx.Guid.Data4[0] = self.__TransNum(ctx.Number(0))
- ctx.Guid.Data4[1] = self.__TransNum(ctx.Number(1))
- ctx.Guid.Data4[2] = self.__TransNum(ctx.Number(2))
- ctx.Guid.Data4[3] = self.__TransNum(ctx.Number(3))
- ctx.Guid.Data4[4] = self.__TransNum(ctx.Number(4))
- ctx.Guid.Data4[5] = self.__TransNum(ctx.Number(5))
- ctx.Guid.Data4[6] = self.__TransNum(ctx.Number(6))
- ctx.Guid.Data4[7] = self.__TransNum(ctx.Number(7))
-
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#guidDefinition.
- def visitGuidDefinition(self, ctx:VfrSyntaxParser.GuidDefinitionContext):
-
- self.visitChildren(ctx)
-
- ctx.Guid.Data1 = self.__TransNum(ctx.Number(0))
- ctx.Guid.Data2 = self.__TransNum(ctx.Number(1))
- ctx.Guid.Data3 = self.__TransNum(ctx.Number(2))
-
- return None
-
-
- # Visit a parse tree produced by VfrSyntaxParser#getStringId.
- def visitGetStringId(self, ctx:VfrSyntaxParser.GetStringIdContext):
-
- ctx.StringId = self.__TransNum(ctx.Number())
-
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementHeader.
- def visitVfrStatementHeader(self, ctx:VfrSyntaxParser.VfrStatementHeaderContext):
-
- ctx.OpObj = ctx.parentCtx.OpObj
- if ctx.OpObj != None:
- Prompt = self.__TransNum(ctx.Number(0))
- ctx.OpObj.SetPrompt(Prompt)
- Help = self.__TransNum(ctx.Number(1))
- ctx.OpObj.SetHelp(Help)
-
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionHeader.
- def visitVfrQuestionHeader(self, ctx:VfrSyntaxParser.VfrQuestionHeaderContext):
-
- ctx.OpObj = ctx.parentCtx.OpObj
-
- return self.visitChildren(ctx)
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionBaseInfo.
- def visitVfrQuestionBaseInfo(self, ctx:VfrSyntaxParser.VfrQuestionBaseInfoContext):
-
- ctx.OpObj = ctx.parentCtx.OpObj
-
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_OTHER
- ctx.BaseInfo.VarTotalSize = 0
- ctx.BaseInfo.Info.VarOffset = EFI_VAROFFSET_INVALID
- ctx.BaseInfo.VarStoreId = EFI_VARSTORE_ID_INVALID
- ctx.BaseInfo.IsBitVar = False
-
- QName = None
- QId = EFI_QUESTION_ID_INVALID
- ReturnCode = None
-
- self.visitChildren(ctx)
- if ctx.Name() != None:
- QName = ctx.QN.text
- ReturnCode = self.__CVfrQuestionDB.FindQuestionByName(QName)
- self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_UNDEFINED, ctx.QN.line, ctx.QN.text, 'has already been used please used anther name')
-
- VarIdStr = '' if ctx.VarId() == None else ctx.vfrStorageVarId().VarIdStr
- if ctx.QuestionId() != None:
- QId = self.__TransNum(ctx.ID.text)
- ReturnCode = self.__CVfrQuestionDB.FindQuestionById(QId)
- self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_UNDEFINED, ctx.ID.line, ctx.ID.text, 'has already been used please used anther number')
-
- if ctx.QType == EFI_QUESION_TYPE.QUESTION_NORMAL:
- if self.__IsCheckBoxOp:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_BOOLEAN
- QId, ReturnCode = self.__CVfrQuestionDB.RegisterQuestion(QName, VarIdStr, QId)
- self.__ErrorHandler(ReturnCode, ctx.start.line)
-
- elif ctx.QType == EFI_QUESION_TYPE.QUESTION_DATE:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
- QId, ReturnCode = self.__CVfrQuestionDB.RegisterNewDateQuestion(QName, VarIdStr, QId)
- self.__ErrorHandler(ReturnCode, ctx.start.line)
-
- elif ctx.QType == EFI_QUESION_TYPE.QUESTION_TIME:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
- QId, ReturnCode = self.__CVfrQuestionDB.RegisterNewTimeQuestion(QName, VarIdStr, QId)
- self.__ErrorHandler(ReturnCode, ctx.start.line)
-
- elif ctx.QType == EFI_QUESION_TYPE.QUESTION_REF:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_REF
- if VarIdStr != '': #stand for question with storage.
- QId, ReturnCode = self.__CVfrQuestionDB.RegisterRefQuestion(QName, VarIdStr, QId)
- self.__ErrorHandler(ReturnCode, ctx.start.line)
- else:
- QId, ReturnCode = self.__CVfrQuestionDB.RegisterQuestion(QName, None, QId)
- self.__ErrorHandler(ReturnCode, ctx.start.line)
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, ctx.start.line)
-
- self.__CurrQestVarInfo = ctx.BaseInfo
-
- if ctx.OpObj != None:
- ctx.OpObj.SetQuestionId(QId)
- if ctx.BaseInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- ctx.OpObj.SetVarStoreInfo(ctx.BaseInfo)
-
- return ctx.OpObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#questionheaderFlagsField.
- def visitQuestionheaderFlagsField(self, ctx:VfrSyntaxParser.QuestionheaderFlagsFieldContext):
-
- self.visitChildren(ctx)
- if ctx.ReadOnlyFlag() != None:
- ctx.QHFlag = 0x01
-
- elif ctx.InteractiveFlag() != None:
- ctx.QHFlag = 0x04
-
- elif ctx.ResetRequiredFlag() != None:
- ctx.QHFlag = 0x10
-
- elif ctx.RestStyleFlag() != None:
- ctx.QHFlag = 0x20
-
- elif ctx.ReconnectRequiredFlag() != None:
- ctx.QHFlag = 0x40
-
- elif ctx.OptionOnlyFlag() != None:
- gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.O.line, ctx.O.text)
-
- elif ctx.NVAccessFlag() != None:
- gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.N.line, ctx.N.text)
-
- elif ctx.LateCheckFlag() != None:
- gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text)
-
- return ctx.QHFlag
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStorageVarIdRule1.
- def visitVfrStorageVarIdRule1(self, ctx:VfrSyntaxParser.VfrStorageVarIdRule1Context):
-
- self.visitChildren(ctx)
-
- SName = ctx.SN1.text
- ctx.VarIdStr += SName
-
- Idx = self.__TransNum(ctx.I.text)
- ctx.VarIdStr += '['
- ctx.VarIdStr += ctx.I.text
- ctx.VarIdStr += ']'
-
- ctx.BaseInfo.VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(SName)
- if ctx.CheckFlag or ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
- self.__ErrorHandler(ReturnCode, ctx.SN1.line, ctx.SN1.text)
- self.__ErrorHandler(gCVfrDataStorage.GetNameVarStoreInfo(ctx.BaseInfo, Idx), ctx.SN1.line, ctx.SN1.text)
-
- return ctx.VarIdStr
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStorageVarIdRule2.
- def visitVfrStorageVarIdRule2(self, ctx:VfrSyntaxParser.VfrStorageVarIdRule2Context):
-
- self.visitChildren(ctx)
-
- VarStr = '' # type.field
- SName = ctx.SN2.text
- ctx.VarIdStr += SName
- ctx.BaseInfo.VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(SName)
- if ctx.CheckFlag or ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
- self.__ErrorHandler(ReturnCode, ctx.SN2.line, ctx.SN2.text)
- VarStoreType = gCVfrDataStorage.GetVarStoreType(ctx.BaseInfo.VarStoreId)
- if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS:
- TName, ReturnCode2 = gCVfrDataStorage.GetBufferVarStoreDataTypeName(ctx.BaseInfo.VarStoreId)
- self.__ErrorHandler(ReturnCode2, ctx.SN2.line, ctx.SN2.text)
- VarStr += TName
-
- Count = len(ctx.Dot())
- for i in range(0, Count):
- if ctx.CheckFlag or ReturnCode == VfrReturnCode.VFR_RETURN_SUCCESS:
- cond = (VarStoreType != EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER) and (VarStoreType != EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS)
- ReturnCode = VfrReturnCode.VFR_RETURN_EFIVARSTORE_USE_ERROR if cond else VfrReturnCode.VFR_RETURN_SUCCESS
- self.__ErrorHandler(ReturnCode, ctx.SN2.line, ctx.SN2.text)
-
- ctx.VarIdStr += '.'
- VarStr += '.'
- ctx.VarIdStr += ctx.arrayName(i).SubStr
- VarStr += ctx.arrayName(i).SubStrZ
-
- if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
- self.__ErrorHandler(gCVfrDataStorage.GetEfiVarStoreInfo(ctx.BaseInfo), ctx.SN2.line, ctx.SN2.text)
-
- elif VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS:
- ctx.BaseInfo.Info.VarOffset, ctx.BaseInfo.VarType, ctx.BaseInfo.VarTotalSize, ctx.BaseInfo.IsBitVar, ReturnCode = gCVfrVarDataTypeDB.GetDataFieldInfo(VarStr)
- self.__ErrorHandler(ReturnCode, ctx.SN2.line, VarStr)
- VarGuid = gCVfrDataStorage.GetVarStoreGuid(ctx.BaseInfo.VarStoreId)
- self.__ErrorHandler(gCVfrBufferConfig.Register(SName, VarGuid), ctx.SN2.line)
- Dummy = self.gZeroEfiIfrTypeValue
- ReturnCode = VfrReturnCode(gCVfrBufferConfig.Write(
- 'a',
- SName,
- VarGuid,
- None,
- ctx.BaseInfo.VarType,
- ctx.BaseInfo.Info.VarOffset,
- ctx.BaseInfo.VarTotalSize,
- Dummy)) #?the definition of dummy is needed to check
- self.__ErrorHandler(ReturnCode, ctx.SN2.line)
- self.__ErrorHandler(gCVfrDataStorage.AddBufferVarStoreFieldInfo(ctx.BaseInfo), ctx.SN2.line)
-
- return ctx.VarIdStr
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrConstantValueField.
- def visitVfrConstantValueField(self, ctx:VfrSyntaxParser.VfrConstantValueFieldContext):
- self.visitChildren(ctx)
-
- IntDecStyle = False
- if self.__CurrentMinMaxData != None and self.__CurrentMinMaxData.IsNumericOpcode():
- NumericQst = CIfrNumeric(self.__CurrentQuestion) #
- IntDecStyle = True if (NumericQst.GetNumericFlags() & EFI_IFR_DISPLAY) == 0 else False #
-
- if ctx.TrueSymbol() != None:
- ctx.Value.b = 1
-
- elif ctx.FalseSymbol() != None:
- ctx.Value.b = 0
-
- elif ctx.One() != None:
- ctx.Value.u8 = int(ctx.getText())
-
- elif ctx.Ones() != None:
- ctx.Value.u64 = int(ctx.getText())
-
- elif ctx.Zero() != None:
- ctx.Value.u8 = int(ctx.getText())
-
- elif ctx.Colon() != []:
- ctx.Value.time.Hour = self.__TransNum(ctx.Number(0))
- ctx.Value.time.Minute = self.__TransNum(ctx.Number(1))
- ctx.Value.time.Second = self.__TransNum(ctx.Number(2))
-
- elif ctx.Slash() != []:
- ctx.Value.date.Year = self.__TransNum(ctx.Number(0))
- ctx.Value.date.Month = self.__TransNum(ctx.Number(1))
- ctx.Value.date.Day = self.__TransNum(ctx.Number(2))
-
- elif ctx.Semicolon() != []:
- ctx.Value.ref.QuestionId = self.__TransNum(ctx.Number(0))
- ctx.Value.ref.FormId = self.__TransNum(ctx.Number(1))
- ctx.Value.ref.DevicePath = self.__TransNum(ctx.Number(2))
- ctx.Value.ref.FormSetGuid = ctx.guidDefinition().Guid
-
- elif ctx.StringToken() != None:
- ctx.Value.string = self.__TransNum(ctx.Number(0))
-
- elif ctx.OpenBrace() != None:
- ctx.ListType = True
- Type = self.__CurrQestVarInfo.VarType
- for i in range(0, len(ctx.Number())):
- TempValue = EFI_IFR_TYPE_VALUE()
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- TempValue.u8 = self.__TransNum(ctx.Number(i))
- ctx.ValueList.append(TempValue)
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- TempValue.u16 = self.__TransNum(ctx.Number(i))
- ctx.ValueList.append(TempValue)
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- TempValue.u32 = self.__TransNum(ctx.Number(i))
- ctx.ValueList.append(TempValue)
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- TempValue.u64 = self.__TransNum(ctx.Number(i))
- ctx.ValueList.append(TempValue)
- else:
- Negative = True if ctx.Negative() != None else False
- # The value stored in bit fields is always set to UINT32 type.
- if self.__CurrQestVarInfo.IsBitVar:
- ctx.Value.u32 = self.__TransNum(ctx.Number(0))
- else:
- Type = self.__CurrQestVarInfo.VarType
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- ctx.Value.u8 = self.__TransNum(ctx.Number(0))
- if IntDecStyle:
- if Negative:
- if ctx.Value.u8 > 0x80:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT8 type can't big than 0x7F, small than -0x80")
- else:
- if ctx.Value.u8 > 0x7F:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT8 type can't big than 0x7F, small than -0x80")
- if Negative:
- ctx.Value.u8 = ~ctx.Value.u8 + 1
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- ctx.Value.u16 = self.__TransNum(ctx.Number(0))
- if IntDecStyle:
- if Negative:
- if ctx.Value.u16 > 0x8000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT16 type can't big than 0x7FFF, small than -0x8000")
- else:
- if ctx.Value.u16 > 0x7FFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT16 type can't big than 0x7FFF, small than -0x8000")
- if Negative:
- ctx.Value.u16 = ~ctx.Value.u16 + 1
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- ctx.Value.u32 = self.__TransNum(ctx.Number(0))
- if IntDecStyle:
- if Negative:
- if ctx.Value.u32 > 0x80000000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT32 type can't big than 0x7FFFFFFF, small than -0x80000000")
- else:
- if ctx.Value.u32 > 0X7FFFFFFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT32 type can't big than 0x7FFFFFFF, small than -0x80000000")
- if Negative:
- ctx.Value.u32 = ~ctx.Value.u32 + 1
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- ctx.Value.u64 = self.__TransNum(ctx.Number(0))
- if IntDecStyle:
- if Negative:
- if ctx.Value.u64 > 0x8000000000000000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000")
- else:
- if ctx.Value.u64 > 0x7FFFFFFFFFFFFFFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, "INT64 type can't big than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000")
- if Negative:
- ctx.Value.u64 = ~ctx.Value.u64 + 1
-
- if Type == EFI_IFR_TYPE_BOOLEAN:
- ctx.Value.b = self.__TransNum(ctx.Number(0))
-
- if Type == EFI_IFR_TYPE_BOOLEAN:
- ctx.Value.string = self.__TransNum(ctx.Number(0))
-
- return ctx.Value, ctx.ValueList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrImageTag.
- def visitVfrImageTag(self, ctx:VfrSyntaxParser.VfrImageTagContext):
-
- IObj = CIfrImage()
- self.visitChildren(ctx)
- IObj.SetLineNo(ctx.start.line)
- IObj.SetImageId(self.__TransNum(ctx.Number()))
- ctx.Node.Data = IObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrLockedTag.
- def visitVfrLockedTag(self, ctx:VfrSyntaxParser.VfrLockedTagContext):
-
- LObj=CIfrLocked()
- self.visitChildren(ctx)
- LObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = LObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatTag.
- def visitVfrStatementStatTag(self, ctx:VfrSyntaxParser.VfrStatementStatTagContext):
-
- self.visitChildren(ctx)
- if ctx.vfrImageTag() != None:
- ctx.Node = ctx.vfrImageTag().Node
- else:
- ctx.Node = ctx.vfrLockedTag().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatTagList.
- def visitVfrStatementStatTagList(self, ctx:VfrSyntaxParser.VfrStatementStatTagListContext):
-
- self.visitChildren(ctx)
- for Ctx in ctx.vfrStatementStatTag():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrFormDefinition.
- def visitVfrFormDefinition(self, ctx:VfrSyntaxParser.VfrFormDefinitionContext):
-
- FObj = CIfrForm()
- self.visitChildren(ctx)
-
- FObj.SetLineNo(ctx.start.line)
- FormId = self.__TransNum(ctx.Number(0))
- FObj.SetFormId(FormId)
- FormTitle = self.__TransNum(ctx.Number(1))
- FObj.SetFormTitle(FormTitle)
-
- ctx.Node.Data = FObj
- for Ctx in ctx.vfrForm():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrForm.
- def visitVfrForm(self, ctx:VfrSyntaxParser.VfrFormContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementImage() != None:
- ctx.Node = ctx.vfrStatementImage().Node
- if ctx.vfrStatementLocked() != None:
- ctx.Node = ctx.vfrStatementLocked().Node
- if ctx.vfrStatementRules() != None:
- ctx.Node = ctx.vfrStatementRules().Node
- if ctx.vfrStatementDefault() != None:
- ctx.Node = ctx.vfrStatementDefault().Node
- if ctx.vfrStatementStat() != None:
- ctx.Node = ctx.vfrStatementStat().Node
- if ctx.vfrStatementQuestions() != None:
- ctx.Node = ctx.vfrStatementQuestions().Node
- if ctx.vfrStatementConditional() != None:
- ctx.Node = ctx.vfrStatementConditional().Node
- if ctx.vfrStatementLabel() != None:
- ctx.Node = ctx.vfrStatementLabel().Node
- if ctx.vfrStatementBanner() != None:
- ctx.Node = ctx.vfrStatementBanner().Node
- if ctx.vfrStatementInvalid() != None:
- ctx.Node = ctx.vfrStatementInvalid().Node
- if ctx.vfrStatementExtension() != None:
- ctx.Node = ctx.vfrStatementExtension().Node
- if ctx.vfrStatementModal() != None:
- ctx.Node = ctx.vfrStatementModal().Node
- if ctx.vfrStatementRefreshEvent() != None:
- ctx.Node = ctx.vfrStatementRefreshEvent().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrFormMapDefinition.
- def visitVfrFormMapDefinition(self, ctx:VfrSyntaxParser.VfrFormMapDefinitionContext):
-
- FMapObj = CIfrFormMap()
- self.visitChildren(ctx)
- Line = ctx.start.line
- FMapObj.SetLineNo(Line)
- self.__ErrorHandler(FMapObj.SetFormId(self.__TransNum(ctx.S1.text)), ctx.S1.line, ctx.S1.line)
- FormMapMethodNumber = len(ctx.MapTitle())
- if FormMapMethodNumber == 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'No MapMethod is set for FormMap!')
- else:
- for i in range(0, FormMapMethodNumber):
- FMapObj.SetFormMapMethod(self.__TransNum(ctx.Number(i+1)), ctx.guidDefinition(i).Guid)
- ctx.Node.Data = FMapObj
- for Ctx in ctx.vfrForm():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementImage.
- def visitVfrStatementImage(self, ctx:VfrSyntaxParser.VfrStatementImageContext):
-
- self.visitChildren(ctx)
- ctx.Node = ctx.vfrImageTag().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementLocked.
- def visitVfrStatementLocked(self, ctx:VfrSyntaxParser.VfrStatementLockedContext):
-
- self.visitChildren(ctx)
- ctx.Node = ctx.vfrLockedTag().Node
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRules.
- def visitVfrStatementRules(self, ctx:VfrSyntaxParser.VfrStatementRulesContext):
-
- RObj = CIfrRule()
- self.visitChildren(ctx)
-
- RObj.SetLineNo(ctx.start.line)
- RuleName = self.__TransId(ctx.StringIdentifier())
- self.__CVfrRulesDB.RegisterRule(RuleName)
- RObj.SetRuleId(self.__CVfrRulesDB.GetRuleId(RuleName))
- ctx.Node.Data = RObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- # expression
- # end rule
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStat.
- def visitVfrStatementStat(self, ctx:VfrSyntaxParser.VfrStatementStatContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementSubTitle() != None:
- ctx.Node = ctx.vfrStatementSubTitle().Node
- if ctx.vfrStatementStaticText() != None:
- ctx.Node = ctx.vfrStatementStaticText().Node
- if ctx.vfrStatementCrossReference() != None:
- ctx.Node = ctx.vfrStatementCrossReference().Node
- return ctx.Node
-
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSubTitle.
- def visitVfrStatementSubTitle(self, ctx:VfrSyntaxParser.VfrStatementSubTitleContext):
-
- SObj = ctx.OpObj
-
- Line = ctx.start.line
- SObj.SetLineNo(Line)
-
- Prompt = self.__TransNum(ctx.Number())
- SObj.SetPrompt(Prompt)
-
- self.visitChildren(ctx)
-
- if ctx.vfrSubtitleFlags() != None:
- SObj.SetFlags(ctx.vfrSubtitleFlags().SubFlags)
-
- ctx.Node.Data = SObj
- self.__InsertChild(ctx.Node, ctx.vfrStatementStatTagList())
- # sequence question
- for Ctx in ctx.vfrStatementSubTitleComponent():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSubTitleComponent.
- def visitVfrStatementSubTitleComponent(self, ctx:VfrSyntaxParser.VfrStatementSubTitleComponentContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementQuestions() != None:
- ctx.Node = ctx.vfrStatementQuestions().Node
- elif ctx.vfrStatementStat() != None:
- ctx.Node = ctx.vfrStatementStat().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrSubtitleFlags.
- def visitVfrSubtitleFlags(self, ctx:VfrSyntaxParser.VfrSubtitleFlagsContext):
-
- self.visitChildren(ctx)
-
- for FlagsFieldCtx in ctx.subtitleFlagsField():
- ctx.SubFlags |= FlagsFieldCtx.Flag
-
- return None
-
-
- # Visit a parse tree produced by VfrSyntaxParser#subtitleFlagsField.
- def visitSubtitleFlagsField(self, ctx:VfrSyntaxParser.SubtitleFlagsFieldContext):
-
- if ctx.Number() != None:
- ctx.Flag = self.__TransNum(ctx.Number())
- else:
- ctx.Flag = 0x01
-
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStaticText.
- def visitVfrStatementStaticText(self, ctx:VfrSyntaxParser.VfrStatementStaticTextContext):
-
- self.visitChildren(ctx)
-
- QId = EFI_QUESTION_ID_INVALID
- Help = self.__TransNum(ctx.S1.text)
- Prompt = self.__TransNum(ctx.S2.text)
- TxtTwo = EFI_STRING_ID_INVALID
- if ctx.S3 != None:
- TxtTwo = self.__TransNum(ctx.S3.text)
-
- TextFlags = 0
- for FlagsFieldCtx in ctx.staticTextFlagsField():
- TextFlags |= FlagsFieldCtx.Flag
-
- if TextFlags & EFI_IFR_FLAG_CALLBACK:
- if TxtTwo != EFI_STRING_ID_INVALID:
- gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_ACTION_WITH_TEXT_TWO, ctx.S3.line, ctx.S3.text)
-
- AObj = CIfrAction()
- QId, _ = self.__CVfrQuestionDB.RegisterQuestion(None, None, QId)
- AObj.SetLineNo(ctx.F.line)
- AObj.SetQuestionId(QId)
- AObj.SetHelp(Help)
- AObj.SetPrompt(Prompt)
- self.__ErrorHandler(AObj.SetFlags(TextFlags), ctx.F.line)
- if ctx.Key() != None:
- Key = self.__TransNum(ctx.S4.text)
- self.__AssignQuestionKey(AObj, Key)
- ctx.Node.Data = AObj
- ctx.Node.OpCode = EFI_IFR_ACTION_OP #
-
- else:
- TObj = CIfrText()
- Line = ctx.start.line
- TObj.SetLineNo(Line)
- TObj.SetHelp(Help)
- TObj.SetPrompt(Prompt)
- TObj.SetTextTwo(TxtTwo)
- ctx.Node.Data = TObj
-
- return ctx.Node
-
-
-
- # Visit a parse tree produced by VfrSyntaxParser#staticTextFlagsField.
- def visitStaticTextFlagsField(self, ctx:VfrSyntaxParser.StaticTextFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- ctx.Flag = self.__TransNum(ctx.N.text)
- if ctx.Flag != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line)
- else:
-
- ctx.Flag = ctx.questionheaderFlagsField().QHFlag
-
- return ctx.Flag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementCrossReference.
- def visitVfrStatementCrossReference(self, ctx:VfrSyntaxParser.VfrStatementCrossReferenceContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementGoto() != None:
- ctx.Node = ctx.vfrStatementGoto().Node
- elif ctx.vfrStatementResetButton() != None:
- ctx.Node = ctx.vfrStatementResetButton().Node
- return ctx.Node
-
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGoto.
- def visitVfrStatementGoto(self, ctx:VfrSyntaxParser.VfrStatementGotoContext):
-
- RefType = 5
- DevPath = EFI_STRING_ID_INVALID
- QId = EFI_QUESTION_ID_INVALID
- BitMask = 0
- Line = ctx.start.line
- R5Obj = CIfrRef5()
- R5Obj.SetLineNo(Line)
- ctx.OpObj = R5Obj
- #ctx.OHObj = R5Obj
-
- if ctx.DevicePath() != None:
- RefType = 4
- DevPath = self.__TransNum(ctx.Number(0))
- FId = self.__TransNum(ctx.Number(1))
- QId = self.__TransNum(ctx.Number(2))
- R4Obj = CIfrRef4()
- R4Obj.SetLineNo(Line)
- R4Obj.SetDevicePath(DevPath)
- R4Obj.SetFormId(FId)
- R4Obj.SetQuestionId(QId)
- ctx.OpObj = R4Obj
- #ctx.OHObj = R4Obj
-
- elif ctx.FormSetGuid() != None:
- RefType = 3
- FId = self.__TransNum(ctx.Number(0))
- QId = self.__TransNum(ctx.Number(1))
- R3Obj = CIfrRef3()
- R3Obj.SetLineNo(Line)
- R3Obj.SetFormId(FId)
- R3Obj.SetQuestionId(QId)
- ctx.OpObj = R3Obj
- #ctx.OHObj = R3Obj
-
- elif ctx.FormId() != None:
- FId = self.__TransNum(ctx.Number(0))
- RefType = 2
- if ctx.QN != None:
- Name = ctx.QN.text
- QId, BitMask, _ = self.__CVfrQuestionDB.GetQuestionId(Name)
- if QId == EFI_QUESTION_ID_INVALID:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNDEFINED, ctx.QN.line)
- else:
- QId = self.__TransNum(ctx.Number(1))
- R2Obj = CIfrRef2()
- R2Obj.SetLineNo(Line)
- R2Obj.SetFormId(FId)
- R2Obj.SetQuestionId(QId)
- ctx.OpObj = R2Obj
- # ctx.OHObj = R2Obj
-
-
- elif str(ctx.getChild(1)) == str(ctx.Number(0)):
- RefType = 1
- FId = self.__TransNum(ctx.Number(0))
- RObj = CIfrRef()
- RObj.SetLineNo(Line)
- RObj.SetFormId(FId)
- ctx.OpObj = RObj
- # ctx.OHObj = RObj
-
- self.visitChildren(ctx)
-
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
- self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_REF
-
- if RefType == 4 or RefType == 3:
- ctx.OpObj.SetFormSetId(ctx.guidDefinition().Guid)
- # ctx.OHObj.SetFormSetId(ctx.guidDefinition().Guid)
-
- if ctx.FLAGS() != None:
- ctx.OpObj.SetFlags(ctx.vfrGotoFlags().GotoFlags)
- # ctx.OHObj.SetFlags(ctx.vfrGotoFlags().GotoFlags)
-
- if ctx.Key() != None:
- index = int(len(ctx.Number())) - 1
- Key = self.__TransNum(ctx.Number(index))
- self.__AssignQuestionKey(ctx.OpObj, Key)
-
- # ctx.OHObj.SetScope(1)
- ctx.OpObj.SetScope(1)
- ctx.Node.Data = ctx.OpObj
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrGotoFlags.
- def visitVfrGotoFlags(self, ctx:VfrSyntaxParser.VfrGotoFlagsContext):
-
- self.visitChildren(ctx)
- for FlagsFieldCtx in ctx.gotoFlagsField():
- ctx.GotoFlags |= FlagsFieldCtx.Flag
-
- return ctx.GotoFlags
-
-
-
- # Visit a parse tree produced by VfrSyntaxParser#gotoFlagsField.
- def visitGotoFlagsField(self, ctx:VfrSyntaxParser.GotoFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.N != None:
- if self.__TransNum(ctx.N.text) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line)
- else:
- ctx.Flag = ctx.questionheaderFlagsField().QHFlag
-
- return ctx.Flag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementResetButton.
- def visitVfrStatementResetButton(self, ctx:VfrSyntaxParser.VfrStatementResetButtonContext):
-
- self.visitChildren(ctx)
-
- RBObj = ctx.OpObj
- Line = ctx.start.line
- RBObj.SetLineNo(Line)
- defaultstore = ctx.N.text
- DefaultId, ReturnCode = gCVfrDefaultStore.GetDefaultId(defaultstore)
- self.__ErrorHandler(ReturnCode, ctx.N.line)
- RBObj.SetDefaultId(DefaultId)
-
- ctx.Node.Data = RBObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestions.
- def visitVfrStatementQuestions(self, ctx:VfrSyntaxParser.VfrStatementQuestionsContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementBooleanType() != None:
- ctx.Node = ctx.vfrStatementBooleanType().Node
- if ctx.vfrStatementDate() != None:
- ctx.Node = ctx.vfrStatementDate().Node
- if ctx.vfrStatementNumericType() != None:
- ctx.Node = ctx.vfrStatementNumericType().Node
- if ctx.vfrStatementStringType() != None:
- ctx.Node = ctx.vfrStatementStringType().Node
- if ctx.vfrStatementOrderedList() != None:
- ctx.Node = ctx.vfrStatementOrderedList().Node
- if ctx.vfrStatementTime() != None:
- ctx.Node = ctx.vfrStatementTime().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionTag.
- def visitVfrStatementQuestionTag(self, ctx:VfrSyntaxParser.VfrStatementQuestionTagContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementStatTag() != None:
- ctx.Node = ctx.vfrStatementStatTag().Node
- if ctx.vfrStatementInconsistentIf() != None:
- ctx.Node = ctx.vfrStatementInconsistentIf().Node
- if ctx.vfrStatementNoSubmitIf() != None:
- ctx.Node = ctx.vfrStatementNoSubmitIf().Node
- if ctx.vfrStatementDisableIfQuest() != None:
- ctx.Node = ctx.vfrStatementDisableIfQuest().Node
- if ctx.vfrStatementRefresh() != None:
- ctx.Node = ctx.vfrStatementRefresh().Node
- if ctx.vfrStatementVarstoreDevice() != None:
- ctx.Node = ctx.vfrStatementVarstoreDevice().Node
- if ctx.vfrStatementExtension() != None:
- ctx.Node = ctx.vfrStatementExtension().Node
- if ctx.vfrStatementRefreshEvent() != None:
- ctx.Node = ctx.vfrStatementRefreshEvent().Node
- if ctx.vfrStatementWarningIf() != None:
- ctx.Node = ctx.vfrStatementWarningIf().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInconsistentIf.
- def visitVfrStatementInconsistentIf(self, ctx:VfrSyntaxParser.VfrStatementInconsistentIfContext):
-
- IIObj = CIfrInconsistentIf()
- self.visitChildren(ctx)
-
- IIObj.SetLineNo(ctx.start.line)
- IIObj.SetError(self.__TransNum(ctx.Number()))
-
- ctx.Node.Data = IIObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementNoSubmitIf.
- def visitVfrStatementNoSubmitIf(self, ctx:VfrSyntaxParser.VfrStatementNoSubmitIfContext):
- NSIObj = CIfrNoSubmitIf()
- self.visitChildren(ctx)
-
- NSIObj.SetLineNo(ctx.start.line)
- NSIObj.SetError(self.__TransNum(ctx.Number()))
- ctx.Node.Data = NSIObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDisableIfQuest.
- def visitVfrStatementDisableIfQuest(self, ctx:VfrSyntaxParser.VfrStatementDisableIfQuestContext):
- DIObj = CIfrDisableIf()
- self.visitChildren(ctx)
-
- DIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = DIObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRefresh.
- def visitVfrStatementRefresh(self, ctx:VfrSyntaxParser.VfrStatementRefreshContext):
- RObj = CIfrRefresh()
- self.visitChildren(ctx)
-
- RObj.SetLineNo(ctx.start.line)
- RObj.SetRefreshInterval(self.__TransNum(ctx.Number()))
- ctx.Node.Data = RObj
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementVarstoreDevice.
- def visitVfrStatementVarstoreDevice(self, ctx:VfrSyntaxParser.VfrStatementVarstoreDeviceContext):
- VDObj = CIfrVarStoreDevice()
- self.visitChildren(ctx)
-
- VDObj.SetLineNo(ctx.start.line)
- VDObj.SetDevicePath(self.__TransNum(ctx.Number()))
- ctx.Node.Data = VDObj
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRefreshEvent.
- def visitVfrStatementRefreshEvent(self, ctx:VfrSyntaxParser.VfrStatementRefreshEventContext):
- RiObj = CIfrRefreshId()
- self.visitChildren(ctx)
-
- RiObj.SetLineNo(ctx.start.line)
- RiObj.SetRefreshEventGroutId(ctx.guidDefinition().Guid)
- ctx.Node.Data = RiObj
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementWarningIf.
- def visitVfrStatementWarningIf(self, ctx:VfrSyntaxParser.VfrStatementWarningIfContext):
- WIObj = CIfrWarningIf()
- self.visitChildren(ctx)
-
- WIObj.SetLineNo(ctx.start.line)
- WIObj.SetWarning(self.__TransNum(ctx.Number(0)))
- WIObj.SetTimeOut(self.__TransNum(ctx.Number(1)))
- ctx.Node.Data = WIObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionTagList.
- def visitVfrStatementQuestionTagList(self, ctx:VfrSyntaxParser.VfrStatementQuestionTagListContext):
-
- self.visitChildren(ctx)
- for Ctx in ctx.vfrStatementQuestionTag():
- self.__InsertChild(ctx.Node, Ctx)
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionOptionTag.
- def visitVfrStatementQuestionOptionTag(self, ctx:VfrSyntaxParser.VfrStatementQuestionOptionTagContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementSuppressIfQuest() != None:
- ctx.Node = ctx.vfrStatementSuppressIfQuest().Node
-
- if ctx.vfrStatementGrayOutIfQuest() != None:
- ctx.Node = ctx.vfrStatementGrayOutIfQuest().Node
-
- if ctx.vfrStatementValue() != None:
- ctx.Node = ctx.vfrStatementValue().Node
-
- if ctx.vfrStatementDefault() != None:
- ctx.Node = ctx.vfrStatementDefault().Node
-
- if ctx.vfrStatementOptions() != None:
- ctx.Node = ctx.vfrStatementOptions().Node
-
- if ctx.vfrStatementRead() != None:
- ctx.Node = ctx.vfrStatementRead().Node
-
- if ctx.vfrStatementWrite() != None:
- ctx.Node = ctx.vfrStatementWrite().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfQuest.
- def visitVfrStatementSuppressIfQuest(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfQuestContext):
-
- SIObj = CIfrSuppressIf()
- SIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = SIObj
- ctx.Node.Condition = 'suppressif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- self.visitChildren(ctx)
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGrayOutIfQuest.
- def visitVfrStatementGrayOutIfQuest(self, ctx:VfrSyntaxParser.VfrStatementGrayOutIfQuestContext):
- GOIObj = CIfrGrayOutIf()
- GOIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = GOIObj
- ctx.Node.Condition = 'grayoutif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- self.visitChildren(ctx)
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#flagsField.
- def visitFlagsField(self, ctx:VfrSyntaxParser.FlagsFieldContext):
-
- if ctx.N != None:
- CVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.N.line, ctx.N.text)
- if ctx.L != None:
- CVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text)
-
- return self.visitChildren(ctx)
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDefault.
- def visitVfrStatementDefault(self, ctx:VfrSyntaxParser.VfrStatementDefaultContext):
-
- self.visitChildren(ctx)
- IsExp = False
- DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD
- Line = ctx.start.line
-
- if ctx.vfrConstantValueField() != None:
- Value = ctx.vfrConstantValueField().Value
- ValueList = ctx.vfrConstantValueField().ValueList
- Type = self.__CurrQestVarInfo.VarType
- Size = 0
-
- if self.__CurrentMinMaxData != None and self.__CurrentMinMaxData.IsNumericOpcode():
- # check default value is valid for Numeric Opcode
- if ValueList == []:
- ValueList.append(Value)
- for i in range(0, len(ValueList)):
- Value = ValueList[i]
- NumericQst = CIfrNumeric (self.__CurrentQuestion) #
- if (NumericQst.GetNumericFlags() & EFI_IFR_DISPLAY) == 0 and self.__CurrQestVarInfo.IsBitVar == False: #
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- if Value.u8 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u8 > self.__CurrentMinMaxData.GetMaxData(Type, False):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- if Value.u16 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u16 > self.__CurrentMinMaxData.GetMaxData(Type, False):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- if Value.u32 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u32 > self.__CurrentMinMaxData.GetMaxData(Type, False):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- if Value.u64 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u64 > self.__CurrentMinMaxData.GetMaxData(Type, False):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
-
- else:
- # Value for question stored in bit fields is always set to UINT32 type.
- if self.__CurrQestVarInfo.IsBitVar:
- if Value.u32 < self.__CurrentMinMaxData.GetMinData(Type, True) or Value.u32 > self.__CurrentMinMaxData.GetMaxData(Type, True):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
- else:
- if Value.u64 < self.__CurrentMinMaxData.GetMinData(Type, False) or Value.u64 > self.__CurrentMinMaxData.GetMaxData(Type, False):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "Numeric default value must be between MinValue and MaxValue.")
-
- if Type == EFI_IFR_TYPE_OTHER:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, "Default data type error.")
- Size = sizeof(EFI_IFR_TYPE_VALUE)
-
- elif ctx.vfrConstantValueField().ListType:
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- Size = sizeof(c_ubyte) * len(ValueList)
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- Size = sizeof(c_ushort) * len(ValueList)
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- Size = sizeof(c_ulong) * len(ValueList)
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- Size = sizeof(c_ulonglong) * len(ValueList)
-
- else:
- if self.__CurrQestVarInfo.IsBitVar:
- Size = sizeof(c_ulong)
- else:
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(Type)
- self.__ErrorHandler(ReturnCode, Line)
-
- Size += EFI_IFR_DEFAULT.Value.offset
- if not ctx.vfrConstantValueField().ListType:
- DObj = CIfrDefault(Size)
- DObj.SetLineNo(Line)
- DObj.SetValue(Value)
-
- if self.__IsStringOp:
- DObj.SetType(EFI_IFR_TYPE_STRING)
- else:
- if self.__CurrQestVarInfo.IsBitVar:
- DObj.SetType(EFI_IFR_TYPE_NUM_SIZE_32)
- else:
- DObj.SetType(self.__CurrQestVarInfo.VarType)
- else:
- DObj = CIfrDefault3(Size, len(ValueList), Type)
- DObj.SetLineNo(Line)
- DObj.SetValue(ValueList)
- DObj.SetType(EFI_IFR_TYPE_BUFFER)
-
- else:
- IsExp = True
- DObj = CIfrDefault2()
- DObj.SetLineNo(Line)
- DObj.SetScope(1)
-
- if ctx.DefaultStore() != None:
- DefaultId, ReturnCode = gCVfrDefaultStore.GetDefaultId(ctx.SN.text)
- self.__ErrorHandler(ReturnCode, ctx.SN.line, ctx.SN.text)
- DObj.SetDefaultId(DefaultId)
-
- self.__CheckDuplicateDefaultValue(DefaultId, ctx.D.line, ctx.D.text)
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- VarStoreName, ReturnCode = gCVfrDataStorage.GetVarStoreName(self.__CurrQestVarInfo.VarStoreId)
- self.__ErrorHandler(ReturnCode, Line)
- VarGuid = gCVfrDataStorage.GetVarStoreGuid(self.__CurrQestVarInfo.VarStoreId)
- VarStoreType = gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId)
- if (IsExp == False) and (VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER):
- self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(DefaultId, self.__CurrQestVarInfo, VarStoreName, VarGuid, self.__CurrQestVarInfo.VarType, Value), Line)
- ctx.Node.Data = DObj
- self.__InsertChild(ctx.Node, ctx.vfrStatementValue())
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementValue.
- def visitVfrStatementValue(self, ctx:VfrSyntaxParser.VfrStatementValueContext):
-
- VObj = CIfrValue()
- self.visitChildren(ctx)
-
- VObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = VObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOptions.
- def visitVfrStatementOptions(self, ctx:VfrSyntaxParser.VfrStatementOptionsContext):
-
- self.visitChildren(ctx)
- ctx.Node = ctx.vfrStatementOneOfOption().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOneOfOption.
- def visitVfrStatementOneOfOption(self, ctx:VfrSyntaxParser.VfrStatementOneOfOptionContext):
-
- Line = ctx.start.line
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, "Get data type error.")
-
- self.visitChildren(ctx)
-
- Value = ctx.vfrConstantValueField().Value
- ValueList = ctx.vfrConstantValueField().ValueList
- Type = self.__CurrQestVarInfo.VarType
- Size = 0
- if self.__CurrentMinMaxData != None:
- #set min/max value for oneof opcode
- Step = self.__CurrentMinMaxData.GetStepData(self.__CurrQestVarInfo.VarType, self.__CurrQestVarInfo.IsBitVar)
- if self.__CurrQestVarInfo.IsBitVar:
- self.__CurrentMinMaxData.SetMinMaxStepData(Value.u32, Value.u32, Step, EFI_IFR_TYPE_NUM_SIZE_32)
- else:
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- self.__CurrentMinMaxData.SetMinMaxStepData(Value.u64, Value.u64, Step, EFI_IFR_TYPE_NUM_SIZE_64)
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- self.__CurrentMinMaxData.SetMinMaxStepData(Value.u32, Value.u32, Step, EFI_IFR_TYPE_NUM_SIZE_32)
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- self.__CurrentMinMaxData.SetMinMaxStepData(Value.u16, Value.u16, Step, EFI_IFR_TYPE_NUM_SIZE_16)
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- self.__CurrentMinMaxData.SetMinMaxStepData(Value.u8, Value.u8, Step, EFI_IFR_TYPE_NUM_SIZE_8)
-
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
- Size = sizeof(EFI_IFR_TYPE_VALUE)
- elif ctx.vfrConstantValueField().ListType:
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- Size = sizeof(c_ubyte) * len(ValueList)
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- Size = sizeof(c_ushort) * len(ValueList)
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- Size = sizeof(c_ulong) * len(ValueList)
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- Size = sizeof(c_ulonglong) * len(ValueList)
- else:
- # For the oneof stored in bit fields, set the option type as UINT32.
- if self.__CurrQestVarInfo.IsBitVar:
- Size = sizeof(c_long)
- else:
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(Type)
- self.__ErrorHandler(ReturnCode, Line)
-
- Size += EFI_IFR_ONE_OF_OPTION.Value.offset
- OOOObj = None
- if not ctx.vfrConstantValueField().ListType:
- OOOObj = CIfrOneOfOption(Size)
- if self.__CurrQestVarInfo.IsBitVar:
- OOOObj.SetType(EFI_IFR_TYPE_NUM_SIZE_32)
- else:
- OOOObj.SetType(Type)
- OOOObj.SetValue(Value)
- else:
- OOOObj = CIfrOneOfOption2(Size, len(ValueList), Type)
- OOOObj.SetType(EFI_IFR_TYPE_BUFFER)
- OOOObj.SetValue(ValueList)
-
-
- OOOObj.SetLineNo(Line)
- OOOObj.SetOption(self.__TransNum(ctx.Number(0)))
-
-
- self.__ErrorHandler(OOOObj.SetFlags(ctx.vfrOneOfOptionFlags().LFlags), ctx.F.line)
- self.__ErrorHandler(self.__CurrentQuestion.SetQHeaderFlags(ctx.vfrOneOfOptionFlags().HFlags), ctx.F.line)
-
- # Array type only for default type OneOfOption.
- if (OOOObj.GetFlags() & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) == 0 and (ctx.vfrConstantValueField().ListType):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, "Default keyword should with array value type!")
-
- # Clear the default flag if the option not use array value but has default flag.
- if (OOOObj.GetFlags() & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) != 0 and (ctx.vfrConstantValueField().ListType == False) and (self.__IsOrderedList):
- OOOObj.SetFlags(OOOObj.GetFlags() & ~(EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG))
-
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- VarStoreName, ReturnCode = gCVfrDataStorage.GetVarStoreName(self.__CurrQestVarInfo.VarStoreId)
- self.__ErrorHandler(ReturnCode, Line)
- VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(self.__CurrQestVarInfo.VarStoreId)
- if OOOObj.GetFlags() & EFI_IFR_OPTION_DEFAULT:
- self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_STANDARD, ctx.F.line, ctx.F.text)
- self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_STANDARD, self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, Value), Line)
- if OOOObj.GetFlags() & EFI_IFR_OPTION_DEFAULT_MFG:
- self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_MANUFACTURING, ctx.F.line, ctx.F.text)
- self.__ErrorHandler(gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_MANUFACTURING, self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, Value), Line)
-
- if ctx.Key() != None:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.KN.line, ctx.KN.text)
- #?Guid Option Key
- IfrOptionKey = CIfrOptionKey(self.__CurrentQuestion.GetQuestionId(), Value, self.__TransNum(ctx.KN.text))
- IfrOptionKey.SetLineNo()
- if ctx.vfrImageTag() != None:
- OOOObj.SetScope(1) #
- ctx.Node.Data = OOOObj
- for Ctx in ctx.vfrImageTag():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrOneOfOptionFlags.
- def visitVfrOneOfOptionFlags(self, ctx:VfrSyntaxParser.VfrOneOfOptionFlagsContext):
-
- self.visitChildren(ctx)
-
- ctx.LFlags = self.__CurrQestVarInfo.VarType
- for FlagsFieldCtx in ctx.oneofoptionFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
- ctx.LFlags |= FlagsFieldCtx.LFlag
-
- return ctx.HFlags, ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#oneofoptionFlagsField.
- def visitOneofoptionFlagsField(self, ctx:VfrSyntaxParser.OneofoptionFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- ctx.LFlag = self.__TransNum(ctx.Number())
- if ctx.OptionDefault() != None:
- ctx.LFlag = 0x10
- if ctx.OptionDefaultMfg() != None:
- ctx.LFlag = 0x20
- if ctx.InteractiveFlag() != None:
- ctx.HFlag = 0x04
- if ctx.ResetRequiredFlag() != None:
- ctx.HFlag = 0x10
- if ctx.RestStyleFlag() != None:
- ctx.HFlag = 0x20
- if ctx.ReconnectRequiredFlag() != None:
- ctx.HFlag = 0x40
- if ctx.ManufacturingFlag() != None:
- ctx.LFlag = 0x20
- if ctx.DefaultFlag() != None:
- ctx.LFlag = 0x10
- if ctx.NVAccessFlag() != None:
- gCVfrErrorHandle.HandleWarning (EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.A.line, ctx.A.text)
- if ctx.LateCheckFlag() != None:
- gCVfrErrorHandle.HandleWarning (EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text)
-
- return ctx.HFlag, ctx.LFlag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRead.
- def visitVfrStatementRead(self, ctx:VfrSyntaxParser.VfrStatementReadContext):
-
- RObj = CIfrRead()
- self.visitChildren(ctx)
-
- RObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = RObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementWrite.
- def visitVfrStatementWrite(self, ctx:VfrSyntaxParser.VfrStatementWriteContext):
-
- WObj = CIfrWrite()
- self.visitChildren(ctx)
-
- WObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = WObj
- ctx.Node.Expression = self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionOptionList.
- def visitVfrStatementQuestionOptionList(self, ctx:VfrSyntaxParser.VfrStatementQuestionOptionListContext):
-
- self.visitChildren(ctx)
- for Ctx in ctx.vfrStatementQuestionOption():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementQuestionOption.
- def visitVfrStatementQuestionOption(self, ctx:VfrSyntaxParser.VfrStatementQuestionOptionContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementQuestionTag() != None:
- ctx.Node = ctx.vfrStatementQuestionTag().Node
-
- elif ctx.vfrStatementQuestionOptionTag() != None:
- ctx.Node = ctx.vfrStatementQuestionOptionTag().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementBooleanType.
- def visitVfrStatementBooleanType(self, ctx:VfrSyntaxParser.VfrStatementBooleanTypeContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementCheckBox() != None:
- ctx.Node = ctx.vfrStatementCheckBox().Node
- else:
- ctx.Node = ctx.vfrStatementAction().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementCheckBox.
- def visitVfrStatementCheckBox(self, ctx:VfrSyntaxParser.VfrStatementCheckBoxContext):
-
- CBObj = ctx.OpObj
- Line = ctx.start.line
- CBObj.SetLineNo(Line)
- self.__CurrentQuestion = CBObj.GetQuestion()
- self.__IsCheckBoxOp = True
-
- self.visitChildren(ctx)
-
- # Create a GUID opcode to wrap the checkbox opcode, if it refer to bit varstore.
- if self.__CurrQestVarInfo.IsBitVar:
- GuidObj = CIfrGuid(0)
- GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
- GuidObj.SetLineNo(Line)
- GuidObj.SetScope(1) #
-
- # check dataType
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
- self.__CurrQestVarInfo.VarType = EFI_IFR_TYPE_BOOLEAN
-
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- # Check whether the question refers to a bit field, if yes. create a Guid to indicate the question refers to a bit field.
- if self.__CurrQestVarInfo.IsBitVar:
- _, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, "CheckBox varid is not the valid data type")
- if gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER_BITS and self.__CurrQestVarInfo.VarTotalSize != 1:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "CheckBox varid only occupy 1 bit in Bit Varstore")
- else:
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, "CheckBox varid is not the valid data type")
- if Size != 0 and Size != self.__CurrQestVarInfo.VarTotalSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "CheckBox varid doesn't support array")
- elif gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER and self.__CurrQestVarInfo.VarTotalSize != sizeof(ctypes.c_bool):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, "CheckBox varid only support BOOLEAN data type")
-
- if ctx.FLAGS() != None:
- CBObj.SetFlags(ctx.vfrCheckBoxFlags().HFlags, ctx.vfrCheckBoxFlags().LFlags)
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- VarStoreName, ReturnCode = gCVfrDataStorage.GetVarStoreName(self.__CurrQestVarInfo.VarStoreId)
- self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_SUCCESS, Line, ctx.L.text, "Failed to retrieve varstore name")
-
- VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(self.__CurrQestVarInfo.VarStoreId)
- self.gZeroEfiIfrTypeValue.b = True
- if CBObj.GetFlags() & 0x01:
- self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_STANDARD, ctx.F.line, ctx.F.text)
- ReturnCode = gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_STANDARD,self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, self.gZeroEfiIfrTypeValue)
- self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_SUCCESS, Line, ctx.L.text, "No standard default storage found")
- if CBObj.GetFlags() & 0x02:
- self.__CheckDuplicateDefaultValue(EFI_HII_DEFAULT_CLASS_MANUFACTURING, ctx.F.line, ctx.F.text)
- ReturnCode = gCVfrDefaultStore.BufferVarStoreAltConfigAdd(EFI_HII_DEFAULT_CLASS_MANUFACTURING, self.__CurrQestVarInfo, VarStoreName, VarStoreGuid, self.__CurrQestVarInfo.VarType, self.gZeroEfiIfrTypeValue)
- self.__CompareErrorHandler(ReturnCode, VfrReturnCode.VFR_RETURN_SUCCESS, Line, ctx.L.text, "No manufacturing default storage found")
- if ctx.Key() != None:
- Key = self.__TransNum(ctx.Number())
- self.__AssignQuestionKey(CBObj, Key)
-
- ctx.Node.Data = CBObj
- self.__IsCheckBoxOp = False
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrCheckBoxFlags.
- def visitVfrCheckBoxFlags(self, ctx:VfrSyntaxParser.VfrCheckBoxFlagsContext):
-
- self.visitChildren(ctx)
- for FlagsFieldCtx in ctx.checkboxFlagsField():
- ctx.LFlags |= FlagsFieldCtx.LFlag
- ctx.HFlags |= FlagsFieldCtx.HFlag
-
- return ctx.HFlags, ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#checkboxFlagsField.
- def visitCheckboxFlagsField(self, ctx:VfrSyntaxParser.CheckboxFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- if self.__TransNum(ctx.Number()) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
- elif ctx.DefaultFlag() != None:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.D.line, ctx.D.text)
- elif ctx.ManufacturingFlag() != None:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.M.line, ctx.M.text)
- elif ctx.CheckBoxDefaultFlag() != None:
- ctx.LFlag = 0x01
- elif ctx.CheckBoxDefaultMfgFlag() != None:
- ctx.LFlag = 0x02
- else:
- ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
-
- return ctx.HFlag, ctx.LFlag
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementAction.
- def visitVfrStatementAction(self, ctx:VfrSyntaxParser.VfrStatementActionContext):
-
- self.visitChildren(ctx)
- AObj = ctx.OpObj
- AObj.SetLineNo(ctx.start.line)
- AObj.SetQuestionConfig(self.__TransNum(ctx.Number()))
- ctx.Node.Data = AObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrActionFlags.
- def visitVfrActionFlags(self, ctx:VfrSyntaxParser.VfrActionFlagsContext):
-
- self.visitChildren(ctx)
- for FlagsFieldCtx in ctx.actionFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
-
- return ctx.HFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#actionFlagsField.
- def visitActionFlagsField(self, ctx:VfrSyntaxParser.ActionFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- if self.__TransNum(ctx.Number()) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.N.line)
- else:
- ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
- return ctx.HFlag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementNumericType.
- def visitVfrStatementNumericType(self, ctx:VfrSyntaxParser.VfrStatementNumericTypeContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementNumeric() != None:
- ctx.Node = ctx.vfrStatementNumeric().Node
- elif ctx.vfrStatementOneOf() != None:
- ctx.Node = ctx.vfrStatementOneOf().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxP-arser#vfrStatementNumeric.
- def visitVfrStatementNumeric(self, ctx:VfrSyntaxParser.VfrStatementNumericContext):
-
- self.visitChildren(ctx)
- NObj = ctx.OpObj
- NObj.SetLineNo(ctx.start.line)
- self.__CurrentQuestion = NObj.GetQuestion()
- Line = ctx.start.line
-
- if self.__CurrQestVarInfo.IsBitVar:
- GuidObj = CIfrGuid(0)
- GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
- GuidObj.SetLineNo(Line)
- GuidObj.SetScope(1) # pos
-
- # check data type
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- if self.__CurrQestVarInfo.IsBitVar:
- LFlags = EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
- self.__ErrorHandler(NObj.SetFlagsForBitField(NObj.GetFlags(),LFlags), Line)
- else:
- DataTypeSize, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, 'Numeric varid is not the valid data type')
- if DataTypeSize != 0 and DataTypeSize != self.__CurrQestVarInfo.VarTotalSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric varid doesn\'t support array')
- self.__ErrorHandler(NObj.SetFlags(NObj.GetFlags(), self.__CurrQestVarInfo.VarType), Line)
-
-
- if ctx.FLAGS() != None:
- if self.__CurrQestVarInfo.IsBitVar:
- self.__ErrorHandler(NObj.SetFlagsForBitField(ctx.vfrNumericFlags().HFlags,ctx.vfrNumericFlags().LFlags, ctx.vfrNumericFlags().IsDisplaySpecified), ctx.F.line)
- else:
- self.__ErrorHandler(NObj.SetFlags(ctx.vfrNumericFlags().HFlags,ctx.vfrNumericFlags().LFlags, ctx.vfrNumericFlags().IsDisplaySpecified), ctx.F.line)
-
- if ctx.Key() != None:
- Key = self.__TransNum(ctx.Number())
- self.__AssignQuestionKey(NObj,Key)
-
- ShrinkSize = 0
- IsSupported = True
- if self.__CurrQestVarInfo.IsBitVar == False:
- Type = self.__CurrQestVarInfo.VarType
- # Base on the type to know the actual used size, shrink the buffer size allocate before.
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- ShrinkSize = 21
- elif Type == EFI_IFR_TYPE_NUM_SIZE_16:
- ShrinkSize = 18
- elif Type == EFI_IFR_TYPE_NUM_SIZE_32:
- ShrinkSize = 12
- elif Type == EFI_IFR_TYPE_NUM_SIZE_64:
- ShrinkSize = 0
- else:
- IsSupported = False
- else:
- #?Question stored in bit fields saved as UINT32 type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
- ShrinkSize = 12
-
- #######?NObj->ShrinkBinSize (ShrinkSize);
- if IsSupported == False:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type.')
-
- ctx.Node.Data = NObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrSetMinMaxStep.
- def visitVfrSetMinMaxStep(self, ctx:VfrSyntaxParser.VfrSetMinMaxStepContext):
- IntDecStyle = False
- if ((self.__CurrQestVarInfo.IsBitVar) and (ctx.OpObj.GetOpCode() == EFI_IFR_NUMERIC_OP) and ((ctx.OpObj.GetNumericFlags() & EDKII_IFR_DISPLAY_BIT) == 0)) or \
- ((self.__CurrQestVarInfo.IsBitVar == False) and (ctx.OpObj.GetOpCode() == EFI_IFR_NUMERIC_OP) and ((ctx.OpObj.GetNumericFlags() & EFI_IFR_DISPLAY) == 0)):
- IntDecStyle = True
- MinNegative = False
- MaxNegative = False
-
- self.visitChildren(ctx)
-
- Min = self.__TransNum(ctx.I.text)
- Max = self.__TransNum(ctx.A.text)
- Step = self.__TransNum(ctx.S.text) if ctx.Step() != None else 0
-
- if ctx.N1 !=None:
- MinNegative = True
-
- if IntDecStyle == False and MinNegative == True:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, '\'-\' can\'t be used when not in int decimal type.')
- if self.__CurrQestVarInfo.IsBitVar:
- if (IntDecStyle == False) and (Min > (1 << self.__CurrQestVarInfo.VarTotalSize) - 1): #
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'BIT type minimum can\'t small than 0, bigger than 2^BitWidth -1')
- else:
- Type = self.__CurrQestVarInfo.VarType
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- if IntDecStyle:
- if MinNegative:
- if Min > 0x8000000000000000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
- else:
- if Min > 0x7FFFFFFFFFFFFFFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
- if MinNegative:
- Min = ~Min + 1
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- if IntDecStyle:
- if MinNegative:
- if Min > 0x80000000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
- else:
- if Min > 0x7FFFFFFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
- if MinNegative:
- Min = ~Min + 1
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- if IntDecStyle:
- if MinNegative:
- if Min > 0x8000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
- else:
- if Min > 0x7FFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
- if MinNegative:
- Min = ~Min + 1
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- if IntDecStyle:
- if MinNegative:
- if Min > 0x80:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
- else:
- if Min > 0x7F:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.I.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
- if MinNegative:
- Min = ~Min + 1
-
- if ctx.N2 != None:
- MaxNegative = True
- if IntDecStyle == False and MaxNegative == True:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, ' \'-\' can\'t be used when not in int decimal type.')
- if self.__CurrQestVarInfo.IsBitVar:
- if (IntDecStyle == False) and (Max > (1 << self.__CurrQestVarInfo.VarTotalSize) - 1):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'BIT type maximum can\'t be bigger than 2^BitWidth -1')
- else:
- Type = self.__CurrQestVarInfo.VarType
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- if IntDecStyle:
- if MaxNegative:
- if Max > 0x8000000000000000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
- else:
- if Max > 0x7FFFFFFFFFFFFFFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT64 type minimum can\'t small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF')
- if MaxNegative:
- Max = ~Max + 1
-
- if Max < Min: #
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
-
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- if IntDecStyle:
- if MaxNegative:
- if Max > 0x80000000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
- else:
- if Max > 0x7FFFFFFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT32 type minimum can\'t small than -0x80000000, big than 0x7FFFFFFF')
- if MaxNegative:
- Max = ~Max + 1
-
- if Max < Min: #
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
-
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- if IntDecStyle:
- if MaxNegative:
- if Max > 0x8000:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
- else:
- if Max > 0x7FFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT16 type minimum can\'t small than -0x8000, big than 0x7FFF')
- if MaxNegative:
- Max = ~Max + 1
-
- if Max < Min: #
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
-
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- if IntDecStyle:
- if MaxNegative:
- if Max > 0x80:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
- else:
- if Max > 0x7F:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'INT8 type minimum can\'t small than -0x80, big than 0x7F')
- if MaxNegative:
- Max = ~Max + 1
-
- if Max < Min: #
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.A.line, 'Maximum can\'t be less than Minimum')
-
- if self.__CurrQestVarInfo.IsBitVar:
- ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_32)
- else:
- Type = self.__CurrQestVarInfo.VarType
- if Type == EFI_IFR_TYPE_NUM_SIZE_64:
- ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_64)
- if Type == EFI_IFR_TYPE_NUM_SIZE_32:
- ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_32)
- if Type == EFI_IFR_TYPE_NUM_SIZE_16:
- ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_16)
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- ctx.OpObj.SetMinMaxStepData(Min, Max, Step, EFI_IFR_TYPE_NUM_SIZE_8)
-
- return ctx.OpObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrNumericFlags.
- def visitVfrNumericFlags(self, ctx:VfrSyntaxParser.VfrNumericFlagsContext):
-
- ctx.LFlags = self.__CurrQestVarInfo.VarType & EFI_IFR_NUMERIC_SIZE
- VarStoreType = gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId)
- Line = ctx.start.line
- IsSetType = False
- self.visitChildren(ctx)
-
- for FlagsFieldCtx in ctx.numericFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
- ctx.IsDisplaySpecified = FlagsFieldCtx.IsDisplaySpecified
- IsSetType |= FlagsFieldCtx.IsSetType
- if FlagsFieldCtx.NumericSizeOne() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1
-
- if FlagsFieldCtx.NumericSizeTwo() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2
-
- if FlagsFieldCtx.NumericSizeFour() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4
-
- if FlagsFieldCtx.NumericSizeEight() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8
-
- if FlagsFieldCtx.DisPlayIntDec() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC
- else:
- ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_INT_DEC_BIT
-
- if FlagsFieldCtx.DisPlayUIntHex() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC
- else:
- ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_DEC_BIT
-
- if FlagsFieldCtx.DisPlayUIntHex() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX
- else:
- ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_HEX_BIT
-
- if self.__CurrQestVarInfo.IsBitVar == False:
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
- if self.__CurrQestVarInfo.VarType != (ctx.LFlags & EFI_IFR_NUMERIC_SIZE):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric Flag is not same to Numeric VarData type')
- else:
- # update data type for name/value store
- self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
- Size, _ = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
- self.__CurrQestVarInfo.VarTotalSize = Size
- elif IsSetType:
- self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
-
- elif self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID and self.__CurrQestVarInfo.IsBitVar:
- ctx.LFlags &= EDKII_IFR_DISPLAY_BIT
- ctx.LFlags |= EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
-
- return ctx.HFlags, ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#numericFlagsField.
- def visitNumericFlagsField(self, ctx:VfrSyntaxParser.NumericFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- Line = ctx.start.line
- if ctx.Number() != None:
- if self.__TransNum(ctx.N.text) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line)
-
- if ctx.NumericSizeOne() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.IsSetType = True
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
-
- if ctx.NumericSizeTwo() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.IsSetType = True
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
-
- if ctx.NumericSizeFour() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.IsSetType = True
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
-
- if ctx.NumericSizeEight() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.IsSetType = True
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Can not specify the size of the numeric value for BIT field')
-
- if ctx.DisPlayIntDec() != None:
- ctx.IsDisplaySpecified = True
-
- if ctx.DisPlayUIntHex() != None:
- ctx.IsDisplaySpecified = True
-
- if ctx.DisPlayUIntHex() != None:
- ctx.IsDisplaySpecified = True
-
- if ctx.questionheaderFlagsField() != None:
- ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
-
- return ctx.HFlag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOneOf.
- def visitVfrStatementOneOf(self, ctx:VfrSyntaxParser.VfrStatementOneOfContext):
-
- OObj = ctx.OpObj
- Line = ctx.start.line
- OObj.SetLineNo(Line)
- self.__CurrentQuestion = OObj.GetQuestion()
- self.visitChildren(ctx)
- if self.__CurrQestVarInfo.IsBitVar:
- GuidObj = CIfrGuid(0)
- GuidObj.SetGuid(EDKII_IFR_BIT_VARSTORE_GUID)
- GuidObj.SetLineNo(ctx.start.line)
- GuidObj.SetScope(1) # pos
-
- # check data type
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- if self.__CurrQestVarInfo.IsBitVar:
- LFlags = EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
- self.__ErrorHandler(OObj.SetFlagsForBitField(OObj.GetFlags(),LFlags), Line)
- else:
- DataTypeSize, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, 'OneOf varid is not the valid data type')
- if DataTypeSize != 0 and DataTypeSize != self.__CurrQestVarInfo.VarTotalSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'OneOf varid doesn\'t support array')
- self.__ErrorHandler(OObj.SetFlags(OObj.GetFlags(), self.__CurrQestVarInfo.VarType), Line)
-
- if ctx.FLAGS() != None:
- if self.__CurrQestVarInfo.IsBitVar:
- self.__ErrorHandler(OObj.SetFlagsForBitField(ctx.vfrOneofFlagsField().HFlags,ctx.vfrOneofFlagsField().LFlags), ctx.F.line)
- else:
- self.__ErrorHandler(OObj.SetFlags(ctx.vfrOneofFlagsField().HFlags, ctx.vfrOneofFlagsField().LFlags), ctx.F.line)
-
- ShrinkSize = 0
- IsSupported = True
- if self.__CurrQestVarInfo.IsBitVar == False:
- Type = self.__CurrQestVarInfo.VarType
- # Base on the type to know the actual used size, shrink the buffer size allocate before.
- if Type == EFI_IFR_TYPE_NUM_SIZE_8:
- ShrinkSize = 21
- elif Type == EFI_IFR_TYPE_NUM_SIZE_16:
- ShrinkSize = 18
- elif Type == EFI_IFR_TYPE_NUM_SIZE_32:
- ShrinkSize = 12
- elif Type == EFI_IFR_TYPE_NUM_SIZE_64:
- ShrinkSize = 0 #
- else:
- IsSupported = False
- else:
- #?Question stored in bit fields saved as UINT32 type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
- ShrinkSize = 12
-
- # OObj.ShrinkBinSize(ShrinkSize)
- if IsSupported == False:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type.')
-
- ctx.Node.Data = OObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrOneofFlagsField.
- def visitVfrOneofFlagsField(self, ctx:VfrSyntaxParser.VfrOneofFlagsFieldContext):
-
- ctx.LFlags = self.__CurrQestVarInfo.VarType & EFI_IFR_NUMERIC_SIZE
- VarStoreType = gCVfrDataStorage.GetVarStoreType(self.__CurrQestVarInfo.VarStoreId)
- Line = ctx.start.line
- IsSetType = False
- self.visitChildren(ctx)
-
- for FlagsFieldCtx in ctx.numericFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
- ctx.IsDisplaySpecified = FlagsFieldCtx.IsDisplaySpecified
- IsSetType |= FlagsFieldCtx.IsSetType
- if FlagsFieldCtx.NumericSizeOne() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1
-
- if FlagsFieldCtx.NumericSizeTwo() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2
-
- if FlagsFieldCtx.NumericSizeFour() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4
-
- if FlagsFieldCtx.NumericSizeEight() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8
-
- if FlagsFieldCtx.DisPlayIntDec() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC
- else:
- ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_INT_DEC_BIT
-
- if FlagsFieldCtx.DisPlayUIntHex() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC
- else:
- ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_DEC_BIT
-
- if FlagsFieldCtx.DisPlayUIntHex() != None:
- if self.__CurrQestVarInfo.IsBitVar == False:
- ctx.LFlags = (ctx.LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX
- else:
- ctx.LFlags = (ctx.LFlags & ~EDKII_IFR_DISPLAY_BIT) | EDKII_IFR_DISPLAY_UINT_HEX_BIT
-
- if self.__CurrQestVarInfo.IsBitVar == False:
- if self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- if VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_BUFFER or VarStoreType == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_EFI:
- if self.__CurrQestVarInfo.VarType != (ctx.LFlags & EFI_IFR_NUMERIC_SIZE):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, Line, 'Numeric Flag is not same to Numeric VarData type')
- else:
- # update data type for name/value store
- self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
- Size, _ = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(self.__CurrQestVarInfo.VarType)
- self.__CurrQestVarInfo.VarTotalSize = Size
- elif IsSetType:
- self.__CurrQestVarInfo.VarType = ctx.LFlags & EFI_IFR_NUMERIC_SIZE
-
- elif self.__CurrQestVarInfo.VarStoreId != EFI_VARSTORE_ID_INVALID:
- ctx.LFlags &= EDKII_IFR_DISPLAY_BIT
- ctx.LFlags |= EDKII_IFR_NUMERIC_SIZE_BIT & self.__CurrQestVarInfo.VarTotalSize
-
- return ctx.HFlags, ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStringType.
- def visitVfrStatementStringType(self, ctx:VfrSyntaxParser.VfrStatementStringTypeContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementPassword() != None:
- ctx.Node = ctx.vfrStatementPassword().Node
- elif ctx.vfrStatementString() != None:
- ctx.Node = ctx.vfrStatementString().Node
- return ctx.Node
-
- def _GET_CURRQEST_ARRAY_SIZE(self):
-
- Size = 1
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_8:
- Size = 1
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_16:
- Size = 2
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_32:
- Size = 4
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_NUM_SIZE_64:
- Size = 8
-
- return int(self.__CurrQestVarInfo.VarTotalSize / Size)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementString.
- def visitVfrStatementString(self, ctx:VfrSyntaxParser.VfrStatementStringContext):
-
- self.__IsStringOp = True
- SObj = ctx.OpObj
- SObj.SetLineNo(ctx.start.line)
- self.__CurrentQuestion = SObj.GetQuestion()
-
- self.visitChildren(ctx)
-
- if ctx.FLAGS() != None:
- HFlags = ctx.vfrStringFlagsField().HFlags
- LFlags = ctx.vfrStringFlagsField().LFlags
- self.__ErrorHandler(SObj.SetFlags(HFlags, LFlags), ctx.F.line)
-
- if ctx.Key() != None:
- Key = self.__TransNum(ctx.Number(0))
- self.__AssignQuestionKey(SObj, Key)
- StringMinSize = self.__TransNum(ctx.Number(1))
- StringMaxSize = self.__TransNum(ctx.Number(2))
- else:
- StringMinSize = self.__TransNum(ctx.Number(0))
- StringMaxSize = self.__TransNum(ctx.Number(1))
-
- VarArraySize = self._GET_CURRQEST_ARRAY_SIZE()
- if StringMinSize > 0xFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize takes only one byte, which can't be larger than 0xFF.")
- if VarArraySize != 0 and StringMinSize > VarArraySize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize can't be larger than the max number of elements in string array.")
- SObj.SetMinSize(StringMinSize)
-
- if StringMaxSize > 0xFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize takes only one byte, which can't be larger than 0xFF.")
- elif VarArraySize != 0 and StringMaxSize > VarArraySize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be larger than the max number of elements in string array.")
- elif StringMaxSize < StringMinSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be less than String MinSize.")
- SObj.SetMaxSize(StringMaxSize)
-
- ctx.Node.Data = SObj
-
- self.__IsStringOp = False
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStringFlagsField.
- def visitVfrStringFlagsField(self, ctx:VfrSyntaxParser.VfrStringFlagsFieldContext):
-
- self.visitChildren(ctx)
- for FlagsFieldCtx in ctx.stringFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
- ctx.LFlags |= FlagsFieldCtx.LFlag
-
- return ctx.HFlags, ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#stringFlagsField.
- def visitStringFlagsField(self, ctx:VfrSyntaxParser.StringFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- if self.__TransNum(ctx.Number()) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
- elif ctx.questionheaderFlagsField() != None:
-
- ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
- else:
- ctx.LFlag = 0x01
-
- return ctx.HFlag, ctx.LFlag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementPassword.
- def visitVfrStatementPassword(self, ctx:VfrSyntaxParser.VfrStatementPasswordContext):
-
- PObj = ctx.OpObj
- PObj.SetLineNo(ctx.start.line)
- self.__CurrentQuestion = PObj.GetQuestion()
-
- self.visitChildren(ctx)
-
- if ctx.Key() != None:
- Key = self.__TransNum(ctx.Number(0))
- self.__AssignQuestionKey(PObj, Key)
- PassWordMinSize = self.__TransNum(ctx.Number(1))
- PasswordMaxSize = self.__TransNum(ctx.Number(2))
- else:
- PassWordMinSize = self.__TransNum(ctx.Number(0))
- PasswordMaxSize = self.__TransNum(ctx.Number(1))
-
- if ctx.FLAGS() != None:
- HFlags = ctx.vfrPasswordFlagsField().HFlags
- self.__ErrorHandler(PObj.SetFlags(HFlags), ctx.F.line)
-
- VarArraySize = self._GET_CURRQEST_ARRAY_SIZE()
- if PassWordMinSize > 0xFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize takes only one byte, which can't be larger than 0xFF.")
- if VarArraySize != 0 and PassWordMinSize > VarArraySize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Min.line, "String MinSize can't be larger than the max number of elements in string array.")
- PObj.SetMinSize(PassWordMinSize)
-
- if PasswordMaxSize > 0xFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize takes only one byte, which can't be larger than 0xFF.")
- elif VarArraySize != 0 and PasswordMaxSize > VarArraySize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be larger than the max number of elements in string array.")
- elif PasswordMaxSize < PassWordMinSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.Max.line, "String MaxSize can't be less than String MinSize.")
- PObj.SetMaxSize(PasswordMaxSize)
-
- ctx.Node.Data = PObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrPasswordFlagsField.
- def visitVfrPasswordFlagsField(self, ctx:VfrSyntaxParser.VfrPasswordFlagsFieldContext):
-
- self.visitChildren(ctx)
- for FlagsFieldCtx in ctx.passwordFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
-
- return ctx.HFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#passwordFlagsField.
- def visitPasswordFlagsField(self, ctx:VfrSyntaxParser.PasswordFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- if self.__TransNum(ctx.Number()) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
- else:
- ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
-
- return ctx.HFlag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementOrderedList.
- def visitVfrStatementOrderedList(self, ctx:VfrSyntaxParser.VfrStatementOrderedListContext):
-
- OLObj = ctx.OpObj
- OLObj.SetLineNo(ctx.start.line)
- self.__CurrentQuestion = OLObj.GetQuestion()
- self.__IsOrderedList = True
-
- self.visitChildren(ctx)
-
- VarArraySize = self._GET_CURRQEST_ARRAY_SIZE()
- if VarArraySize > 0xFF:
- OLObj.SetMaxContainers(0xFF)
- else:
- OLObj.SetMaxContainers(VarArraySize)
-
- if ctx.MaxContainers() != None:
- MaxContainers = self.__TransNum(ctx.Number())
- if MaxContainers > 0xFF:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.M.line, "OrderedList MaxContainers takes only one byte, which can't be larger than 0xFF.")
- elif VarArraySize != 0 and MaxContainers > VarArraySize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.M.line,"OrderedList MaxContainers can't be larger than the max number of elements in array.")
- OLObj.SetMaxContainers(MaxContainers)
-
- if ctx.FLAGS() != None:
- HFlags = ctx.vfrOrderedListFlags().HFlags
- LFlags = ctx.vfrOrderedListFlags().LFlags
- self.__ErrorHandler(OLObj.SetFlags(HFlags, LFlags), ctx.F.line)
-
- ctx.Node.Data = OLObj
-
- self.__IsOrderedList = False
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrOrderedListFlags.
- def visitVfrOrderedListFlags(self, ctx:VfrSyntaxParser.VfrOrderedListFlagsContext):
-
- self.visitChildren(ctx)
-
- for FlagsFieldCtx in ctx.orderedlistFlagsField():
- ctx.HFlags |= FlagsFieldCtx.HFlag
- ctx.LFlags |= FlagsFieldCtx.LFlag
-
- return ctx.HFlags, ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#orderedlistFlagsField.
- def visitOrderedlistFlagsField(self, ctx:VfrSyntaxParser.OrderedlistFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- if self.__TransNum(ctx.Number()) != 0:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
- elif ctx.questionheaderFlagsField() != None:
- ctx.HFlag = ctx.questionheaderFlagsField().QHFlag
- elif ctx.UniQueFlag() != None:
- ctx.LFlag = 0x01
- elif ctx.NoEmptyFlag() != None:
- ctx.LFlag = 0x02
-
- return ctx.HFlag, ctx.LFlag
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDate.
- def visitVfrStatementDate(self, ctx:VfrSyntaxParser.VfrStatementDateContext):
-
- DObj = ctx.OpObj
- Line = ctx.start.line
- DObj.SetLineNo(Line)
-
- self.visitChildren(ctx)
-
- if ctx.vfrQuestionHeader() != None:
-
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
- self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_DATE
-
- if ctx.FLAGS() != None:
- self.__ErrorHandler(DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrDateFlags().LFlags), ctx.F1.line)
-
- else:
-
- Year = self.__TransId(ctx.StringIdentifier(0))
- Year += '.'
- Year += self.__TransId(ctx.StringIdentifier(1))
-
- Month = self.__TransId(ctx.StringIdentifier(2))
- Month += '.'
- Month += self.__TransId(ctx.StringIdentifier(3))
-
- Day = self.__TransId(ctx.StringIdentifier(4))
- Day += '.'
- Day += self.__TransId(ctx.StringIdentifier(5))
-
- if ctx.FLAGS() != None:
- self.__ErrorHandler(DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrDateFlags().LFlags), ctx.F2.line)
-
- QId, _ = self.__CVfrQuestionDB.RegisterOldDateQuestion(Year, Month, Day, EFI_QUESTION_ID_INVALID)
- DObj.SetQuestionId(QId)
- DObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, QF_DATE_STORAGE_TIME)
- DObj.SetPrompt(self.__TransNum(ctx.Number(0)))
- DObj.SetHelp(self.__TransNum(ctx.Number(1)))
-
- Size = EFI_IFR_DEFAULT.Value.offset + sizeof (EFI_HII_DATE)
- DefaultObj = CIfrDefault(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, ctx.Val)
- DefaultObj.SetLineNo(Line)
-
- ctx.Node.Data = DObj
- for Ctx in ctx.vfrStatementInconsistentIf():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#minMaxDateStepDefault.
- def visitMinMaxDateStepDefault(self, ctx:VfrSyntaxParser.MinMaxDateStepDefaultContext):
-
- if ctx.Default() != None:
- Minimum = self.__TransNum(ctx.Number(0))
- Maximum = self.__TransNum(ctx.Number(1))
- if ctx.KeyValue == 0:
- ctx.Date.Year = self.__TransNum(ctx.N.text)
- if ctx.Date.Year < Minimum or ctx.Date.Year > Maximum:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Year default value must be between Min year and Max year.")
- if ctx.KeyValue == 1:
- ctx.Date.Month = self.__TransNum(ctx.N.text)
- if ctx.Date.Month < 1 or ctx.Date.Month > 12:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.D.line, "Month default value must be between Min 1 and Max 12.")
- if ctx.KeyValue == 2:
- ctx.Date.Day = self.__TransNum(ctx.N.text)
- if ctx.Date.Day < 1 or ctx.Date.Day > 31:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.D.line, "Day default value must be between Min 1 and Max 31.")
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrDateFlags.
- def visitVfrDateFlags(self, ctx:VfrSyntaxParser.VfrDateFlagsContext):
-
- self.visitChildren(ctx)
-
- for FlagsFieldCtx in ctx.dateFlagsField():
- ctx.LFlags |= FlagsFieldCtx.LFlag
-
- return ctx.LFlags
-
-
- # Visit a parse tree produced by VfrSyntaxParser#dateFlagsField.
- def visitDateFlagsField(self, ctx:VfrSyntaxParser.DateFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- ctx.LFlag = self.__TransNum(ctx.Number())
- if ctx.YearSupppressFlag() != None:
- ctx.LFlag = 0x01
- if ctx.MonthSuppressFlag() != None:
- ctx.LFlag = 0x02
- if ctx.DaySuppressFlag() != None:
- ctx.LFlag = 0x04
- if ctx.StorageNormalFlag() != None:
- ctx.LFlag = 0x00
- if ctx.StorageTimeFlag() != None:
- ctx.LFlag = 0x010
- if ctx.StorageWakeUpFlag() != None:
- ctx.LFlag = 0x20
-
- return ctx.LFlag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementTime.
- def visitVfrStatementTime(self, ctx:VfrSyntaxParser.VfrStatementTimeContext):
-
- TObj = ctx.OpObj
- Line = ctx.start.line
- TObj.SetLineNo(Line)
-
- self.visitChildren(ctx)
-
- if ctx.vfrQuestionHeader() != None:
-
- if self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_OTHER:
- self.__CurrQestVarInfo.VarType == EFI_IFR_TYPE_TIME
-
- if ctx.FLAGS() != None:
- self.__ErrorHandler(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrTimeFlags().LFlags), ctx.F1.line)
- else:
-
- Hour = self.__TransId(ctx.StringIdentifier(0))
- Hour += '.'
- Hour += self.__TransId(ctx.StringIdentifier(1))
-
- Minute = self.__TransId(ctx.StringIdentifier(2))
- Minute += '.'
- Minute += self.__TransId(ctx.StringIdentifier(3))
-
- Second = self.__TransId(ctx.StringIdentifier(4))
- Second += '.'
- Second += self.__TransId(ctx.StringIdentifier(5))
-
- if ctx.FLAGS() != None:
- self.__ErrorHandler(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, ctx.vfrTimeFlags().LFlags), ctx.F2.line)
-
- QId, _ = self.__CVfrQuestionDB.RegisterOldTimeQuestion(Hour, Minute, Second, EFI_QUESTION_ID_INVALID)
- TObj.SetQuestionId(QId)
- TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, QF_TIME_STORAGE_TIME)
- TObj.SetPrompt(self.__TransNum(ctx.Number(0)))
- TObj.SetHelp(self.__TransNum(ctx.Number(1)))
-
- Size = EFI_IFR_DEFAULT.Value.offset + sizeof (EFI_HII_TIME)
- DefaultObj = CIfrDefault(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, ctx.Val)
- DefaultObj.SetLineNo(Line)
-
- ctx.Node.Data = TObj
- for Ctx in ctx.vfrStatementInconsistentIf():
- self.__InsertChild(ctx.Node, Ctx)
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#minMaxTimeStepDefault.
- def visitMinMaxTimeStepDefault(self, ctx:VfrSyntaxParser.MinMaxTimeStepDefaultContext):
-
- if ctx.Default() != None:
- Minimum = self.__TransNum(ctx.Number(0))
- Maximum = self.__TransNum(ctx.Number(1))
- if ctx.KeyValue == 0:
- ctx.Time.Hour = self.__TransNum(ctx.Number(len(ctx.Number())-1))
- if ctx.Time.Hour > 23:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Hour default value must be between 0 and 23.")
- if ctx.KeyValue == 1:
- ctx.Time.Minute = self.__TransNum(ctx.Number(len(ctx.Number())-1))
- if ctx.Time.Minute > 59:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Minute default value must be between 0 and 59.")
- if ctx.KeyValue == 2:
- ctx.Time.Second = self.__TransNum(ctx.Number(len(ctx.Number())-1))
- if ctx.Time.Second > 59:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.N.line, "Second default value must be between 0 and 59.")
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrTimeFlags.
- def visitVfrTimeFlags(self, ctx:VfrSyntaxParser.VfrTimeFlagsContext):
-
- self.visitChildren(ctx)
-
- for FlagsFieldCtx in ctx.timeFlagsField():
- ctx.LFlags |= FlagsFieldCtx.LFlag
-
- return ctx.LFlags
-
- # Visit a parse tree produced by VfrSyntaxParser#timeFlagsField.
- def visitTimeFlagsField(self, ctx:VfrSyntaxParser.TimeFlagsFieldContext):
-
- self.visitChildren(ctx)
-
- if ctx.Number() != None:
- ctx.LFlag = self.__TransNum(ctx.Number())
- if ctx.HourSupppressFlag() != None:
- ctx.LFlag = 0x01
- if ctx.MinuteSuppressFlag() != None:
- ctx.LFlag = 0x02
- if ctx.SecondSuppressFlag() != None:
- ctx.LFlag = 0x04
- if ctx.StorageNormalFlag() != None:
- ctx.LFlag = 0x00
- if ctx.StorageTimeFlag() != None:
- ctx.LFlag = 0x10
- if ctx.StorageWakeUpFlag() != None:
- ctx.LFlag = 0x20
-
- return ctx.LFlag
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementConditional.
- def visitVfrStatementConditional(self, ctx:VfrSyntaxParser.VfrStatementConditionalContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementDisableIfStat()!= None:
- ctx.Node = ctx.vfrStatementDisableIfStat().Node
- if ctx.vfrStatementSuppressIfStat()!= None:
- ctx.Node = ctx.vfrStatementSuppressIfStat().Node
- if ctx.vfrStatementGrayOutIfStat()!= None:
- ctx.Node = ctx.vfrStatementGrayOutIfStat().Node
- if ctx.vfrStatementInconsistentIfStat()!= None:
- ctx.Node = ctx.vfrStatementInconsistentIfStat().Node
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementConditionalNew.
- def visitVfrStatementConditionalNew(self, ctx:VfrSyntaxParser.VfrStatementConditionalNewContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfStat.
- def visitVfrStatementSuppressIfStat(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfStatContext):
-
- self.visitChildren(ctx)
- ctx.Node = ctx.vfrStatementSuppressIfStatNew().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGrayOutIfStat.
- def visitVfrStatementGrayOutIfStat(self, ctx:VfrSyntaxParser.VfrStatementGrayOutIfStatContext):
-
- self.visitChildren(ctx)
- ctx.Node = ctx.vfrStatementGrayOutIfStatNew().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatList.
- def visitVfrStatementStatList(self, ctx:VfrSyntaxParser.VfrStatementStatListContext):
-
- self.visitChildren(ctx)
- if ctx.vfrStatementStat() != None:
- ctx.Node = ctx.vfrStatementStat().Node
- if ctx.vfrStatementQuestions() != None:
- ctx.Node = ctx.vfrStatementQuestions().Node
- if ctx.vfrStatementConditional() != None:
- ctx.Node = ctx.vfrStatementConditional().Node
- if ctx.vfrStatementLabel() != None:
- ctx.Node = ctx.vfrStatementLabel().Node
- if ctx.vfrStatementExtension() != None:
- ctx.Node = ctx.vfrStatementExtension().Node
- if ctx.vfrStatementInvalid() != None:
- ctx.Node = ctx.vfrStatementInvalid().Node
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementStatListOld.
- def visitVfrStatementStatListOld(self, ctx:VfrSyntaxParser.VfrStatementStatListOldContext):
- return self.visitChildren(ctx)
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementDisableIfStat.
- def visitVfrStatementDisableIfStat(self, ctx:VfrSyntaxParser.VfrStatementDisableIfStatContext):
-
- DIObj = CIfrDisableIf()
- DIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = DIObj
- ctx.Node.Condition = 'disableif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- self.visitChildren(ctx)
- for Ctx in ctx.vfrStatementStatList():
- self.__InsertChild(ctx.Node, Ctx)
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementSuppressIfStatNew.
- def visitVfrStatementSuppressIfStatNew(self, ctx:VfrSyntaxParser.VfrStatementSuppressIfStatNewContext):
-
- SIObj = CIfrSuppressIf()
- SIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = SIObj
- ctx.Node.Condition = 'suppressif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- self.visitChildren(ctx)
- for Ctx in ctx.vfrStatementStatList():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementGrayOutIfStatNew.
- def visitVfrStatementGrayOutIfStatNew(self, ctx:VfrSyntaxParser.VfrStatementGrayOutIfStatNewContext):
-
- GOIObj = CIfrGrayOutIf()
- GOIObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = GOIObj
- ctx.Node.Condition = 'grayoutif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
- self.visitChildren(ctx)
- for Ctx in ctx.vfrStatementStatList():
- self.__InsertChild(ctx.Node, Ctx)
-
- return ctx.Node
-
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInconsistentIfStat.
- def visitVfrStatementInconsistentIfStat(self, ctx:VfrSyntaxParser.VfrStatementInconsistentIfStatContext):
-
- IIObj = CIfrInconsistentIf()
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, ctx.start.line)
- IIObj.SetLineNo(ctx.start.line)
- self.visitChildren(ctx)
- IIObj.SetError(self.__TransNum(ctx.Number()))
- ctx.Node.Data = IIObj
- ctx.Node.Condition = 'inconsistentif' + ' ' + self.__ExtractOriginalText(ctx.vfrStatementExpression())
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalid.
- def visitVfrStatementInvalid(self, ctx:VfrSyntaxParser.VfrStatementInvalidContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalidHidden.
- def visitVfrStatementInvalidHidden(self, ctx:VfrSyntaxParser.VfrStatementInvalidHiddenContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalidInventory.
- def visitVfrStatementInvalidInventory(self, ctx:VfrSyntaxParser.VfrStatementInvalidInventoryContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementInvalidSaveRestoreDefaults.
- def visitVfrStatementInvalidSaveRestoreDefaults(self, ctx:VfrSyntaxParser.VfrStatementInvalidSaveRestoreDefaultsContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementLabel.
- def visitVfrStatementLabel(self, ctx:VfrSyntaxParser.VfrStatementLabelContext):
-
- LObj = CIfrLabel()
- self.visitChildren(ctx)
- LObj.SetLineNo(ctx.start.line)
- LObj.SetNumber(self.__TransNum(ctx.Number()))
- ctx.Node.Data = LObj
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatemex.BObjntBanner.
- def visitVfrStatementBanner(self, ctx:VfrSyntaxParser.VfrStatementBannerContext):
-
- self.visitChildren(ctx)
-
- if ctx.Line() != None:
- BObj = CIfrBanner()
- BObj.SetLineNo(ctx.start.line)
- BObj.SetTitle(self.__TransNum(ctx.Number(0)))
- BObj.SetLine(self.__TransNum(ctx.Number(1)))
- if ctx.Left() != None: BObj.SetAlign(0)
- if ctx.Center() != None: BObj.SetAlign(1)
- if ctx.Right() != None: BObj.SetAlign(2)
- ctx.Node.Data = BObj
- elif ctx.Timeout() != None:
- TObj = CIfrTimeout()
- TObj.SetLineNo(ctx.start.line)
- TObj.SetTimeout(self.__TransNum(ctx.Number(2)))
- ctx.Node.Data = TObj
-
- return ctx.Node
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementExtension.
- def visitVfrStatementExtension(self, ctx:VfrSyntaxParser.VfrStatementExtensionContext):
-
- ctx.IsStruct = False
- if ctx.DataType() != None:
- if ctx.Uint64() != None:
- ctx.TypeName = 'UINT64'
- elif ctx.Uint32() != None:
- ctx.TypeName = 'UINT32'
- elif ctx.Uint16() != None:
- ctx.TypeName = 'UINT16'
- elif ctx.Uint8() != None:
- ctx.TypeName = 'UINT8'
- elif ctx.Boolean() != None:
- ctx.TypeName = 'BOOLEAN'
- elif ctx.EFI_STRING_ID() != None:
- ctx.TypeName = 'EFI_STRING_ID'
- elif ctx.EFI_HII_DATE() != None:
- ctx.TypeName = 'EFI_HII_DATE'
- ctx.IsStruct = True
- elif ctx.EFI_HII_TIME() != None:
- ctx.TypeName = 'EFI_HII_TIME'
- ctx.IsStruct = True
- elif ctx.EFI_HII_REF() != None:
- ctx.TypeName = 'EFI_HII_REF'
- ctx.IsStruct = True
- else:
- ctx.TypeName = self.__TransId(ctx.StringIdentifier())
- ctx.IsStruct = True
- ctx.ArrayNum = self.__TransNum(ctx.Number())
- ctx.TypeSize, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByTypeName(ctx.TypeName)
- self.__ErrorHandler(ReturnCode, ctx.D.line)
- ctx.Size = ctx.TypeSize * ctx.ArrayNum if ctx.ArrayNum > 0 else ctx.TypeSize
- ArrayType = ctypes.c_ubyte * ctx.Size
- ctx.DataBuff = ArrayType()
- for i in range(0, ctx.Size):
- ctx.DataBuff[i] = 0
- self.visitChildren(ctx)
-
- Line = ctx.start.line
- GuidObj = CIfrGuid(ctx.Size)
- GuidObj.SetLineNo(Line)
- GuidObj.SetGuid(ctx.guidDefinition().Guid)
- if ctx.TypeName != None:
- GuidObj.SetData(ctx.DataBuff)
- # vfrStatementExtension
- GuidObj.SetScope(1)
- ctx.Node.Data = GuidObj
- for Ctx in ctx.vfrStatementExtension():
- self.__InsertChild(ctx.Node, Ctx)
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExtensionData.
- def visitVfrExtensionData(self, ctx:VfrSyntaxParser.VfrExtensionDataContext):
- '''
- TFName = ''
- IsArray = False if ctx.OpenBracket() == None else True
- ArrayIdx = 0
- ctx.IsStruct = ctx.parentCtx.IsStruct
- ctx.DataBuff = ctx.parentCtx.DataBuff
-
- self.visitChildren(ctx)
-
- Data = self.__TransNum(ctx.N.text)
- if IsArray == True:
- ArrayIdx = self.__TransNum(self.__TransNum(ctx.Number(0)))
- ByteOffset = ArrayIdx * ctx.parentCtx.TypeSize
- if ctx.IsStruct == True:
- TFName += ctx.parentCtx.TypeName
- for i in range(0, len(ctx.arrayName())):
- TFName += '.'
- TFName += ctx.arrayName(i).SubStrZ
- FieldOffset, FieldType, FieldSize, BitField, _ = gCVfrVarDataTypeDB.GetDataFieldInfo(TFName)
- if BitField:
- Mask = (1 << FieldSize) - 1
- Offset = int(FieldOffset / 8)
- PreBits = FieldOffset % 8
- Mask <<= PreBits
- Begin = 0
- End = 0
- if FieldType == EFI_IFR_TYPE_NUM_SIZE_8:
- Data = ctypes.c_ubyte(Data)
- if BitField:
- # Set the value to the bit fileds.
- Data <<= PreBits
- Value = (Value & (~Mask)) | Data
- Begin = ByteOffset + Offset
- End = ByteOffset + Offset + sizeof (ctypes.c_ubyte)
- ctx.DataBuff[Begin: End] = Value
- else:
- Begin = ByteOffset + FieldOffset
- End = ByteOffset + FieldOffset + FieldSize
- ctx.DataBuff[Begin: End] = Data
-
-
- if FieldType == EFI_IFR_TYPE_NUM_SIZE_16:
- Data = ctypes.c_ushort(Data)
- if BitField:
- # Set the value to the bit fileds.
- Data <<= PreBits
- Value = (Value & (~Mask)) | Data
- Begin = ByteOffset + Offset
- End = ByteOffset + Offset + sizeof (ctypes.c_ushort)
- ctx.DataBuff[Begin: End] = Value
- else:
- Begin = ByteOffset + FieldOffset
- End = ByteOffset + FieldOffset + FieldSize
- ctx.DataBuff[Begin: End] = Data
-
-
- if FieldType == EFI_IFR_TYPE_NUM_SIZE_32:
- Data = ctypes.c_ulong(Data)
- if BitField:
- # Set the value to the bit fileds.
- Data <<= PreBits
- Value = (Value & (~Mask)) | Data
- Begin = ByteOffset + Offset
- End = ByteOffset + Offset + sizeof (ctypes.c_ulong)
- ctx.DataBuff[Begin: End] = Value
- else:
- Begin = ByteOffset + FieldOffset
- End = ByteOffset + FieldOffset + FieldSize
- ctx.DataBuff[Begin: End] = Data
-
- if FieldType == EFI_IFR_TYPE_NUM_SIZE_64:
- Data = ctypes.c_ulonglong(Data)
- if BitField:
- # Set the value to the bit fileds.
- Data <<= PreBits
- Value = (Value & (~Mask)) | Data
- Begin = ByteOffset + Offset
- End = ByteOffset + Offset + sizeof (ctypes.c_ulonglong)
- ctx.DataBuff[Begin: End] = Value
- else:
- Begin = ByteOffset + FieldOffset
- End = ByteOffset + FieldOffset + FieldSize
- ctx.DataBuff[Begin: End] = Data
-
- else:
- ctx.DataBuff[ByteOffset, ByteOffset + ctx.parentCtx.TypeSize] = Data
- '''
- return self.visitChildren(ctx)
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementModal.
- def visitVfrStatementModal(self, ctx:VfrSyntaxParser.VfrStatementModalContext):
-
- self.visitChildren(ctx)
- ctx.Node = ctx.vfrModalTag().Node
- return ctx.Node
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrModalTag.
- def visitVfrModalTag(self, ctx:VfrSyntaxParser.VfrModalTagContext):
-
- MObj = CIfrModal()
- self.visitChildren(ctx)
- MObj.SetLineNo(ctx.start.line)
- ctx.Node.Data = MObj
-
- return ctx.Node
-
- def __SaveOpHdrCond(self, OpHdr, Cond, LineNo=0):
- if Cond == True:
- if self.__CIfrOpHdr[self.__CIfrOpHdrIndex] != None:
- return
- self.__CIfrOpHdr[self.__CIfrOpHdrIndex] = CIfrOpHeader(OpHdr) #
- self.__CIfrOpHdrLineNo[self.__CIfrOpHdrIndex] = LineNo
-
-
- def __InitOpHdrCond(self):
- self.__CIfrOpHdr.append(None)
- self.__CIfrOpHdrLineNo.append(0)
-
- def __SetSavedOpHdrScope(self):
- if self.__CIfrOpHdr[self.__CIfrOpHdrIndex] != None:
- self.__CIfrOpHdr[self.__CIfrOpHdrIndex].SetScope(1)
- return True
- return False
-
- def __ClearSavedOPHdr(self):
- self.__CIfrOpHdr[self.__CIfrOpHdrIndex] = None
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementExpression.
- def visitVfrStatementExpression(self, ctx:VfrSyntaxParser.VfrStatementExpressionContext):
-
- # Root expression extension function called by other function. ##
- if ctx.ExpInfo.RootLevel == 0:
- self.__CIfrOpHdrIndex += 1
- if self.__CIfrOpHdrIndex >= MAX_IFR_EXPRESSION_DEPTH:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_INVALID_PARAMETER, ctx.start.line, 'The depth of expression exceeds the max supported level 8!')
- self.__InitOpHdrCond()
-
- self.visitChildren(ctx)
- Line = ctx.start.line
- for i in range(0, len(ctx.OR())):
- ctx.ExpInfo.ExpOpCount += 1
- OObj = CIfrOr(Line)
-
- # Extend OpCode Scope only for the root expression.
- if ctx.ExpInfo.ExpOpCount > 1 and ctx.ExpInfo.RootLevel == 0:
- if self.__SetSavedOpHdrScope():
- EObj = CIfrEnd()
- if self.__CIfrOpHdrLineNo[self.__CIfrOpHdrIndex] != 0:
- EObj.SetLineNo(self.__CIfrOpHdrLineNo[self.__CIfrOpHdrIndex])
-
- if ctx.ExpInfo.RootLevel == 0:
- self.__ClearSavedOPHdr()
- self.__CIfrOpHdrIndex = self.__CIfrOpHdrIndex - 1
-
- self.__ConstantOnlyInExpression = False
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrStatementExpressionSub.
- def visitVfrStatementExpressionSub(self, ctx:VfrSyntaxParser.VfrStatementExpressionSubContext):
-
- ctx.ExpInfo.RootLevel = ctx.parentCtx.ExpInfo.RootLevel + 1
- ctx.ExpInfo.ExpOpCount = ctx.parentCtx.ExpInfo.ExpOpCount
-
- self.visitChildren(ctx)
-
- ctx.parentCtx.ExpInfo.ExpOpCount = ctx.ExpInfo.ExpOpCount
-
- return ctx.ExpInfo
-
- # Visit a parse tree produced by VfrSyntaxParser#andTerm.
- def visitAndTerm(self, ctx:VfrSyntaxParser.AndTermContext):
- self.visitChildren(ctx)
- Line = ctx.start.line
- for i in range(0, len(ctx.AND())):
- ctx.ExpInfo.ExpOpCount += 1
- AObj = CIfrAnd(Line)
- ctx.CIfrAndList.append(AObj)
-
- return ctx.ExpInfo, ctx.CIfrAndList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#bitwiseorTerm.
- def visitBitwiseorTerm(self, ctx:VfrSyntaxParser.BitwiseorTermContext):
- self.visitChildren(ctx)
- Line = ctx.start.line
- for i in range(0, len(ctx.BitWiseOr())):
- ctx.ExpInfo.ExpOpCount += 1
- BWOObj = CIfrBitWiseOr(Line)
- ctx.CIfrBitWiseOrList.append(BWOObj)
-
- return ctx.ExpInfo, ctx.CIfrBitWiseOrList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#bitwiseandTerm.
- def visitBitwiseandTerm(self, ctx:VfrSyntaxParser.BitwiseandTermContext):
- self.visitChildren(ctx)
- Line = ctx.start.line
- for i in range(0, len(ctx.BitWiseAnd())):
- ctx.ExpInfo.ExpOpCount += 1
- BWAObj = CIfrBitWiseAnd(Line)
- ctx.CIfrBitWiseAndList.append(BWAObj)
-
- return ctx.ExpInfo, ctx.CIfrBitWiseAndList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#equalTerm.
- def visitEqualTerm(self, ctx:VfrSyntaxParser.EqualTermContext):
- self.visitChildren(ctx)
- for i in range(0, len(ctx.equalTermSupplementary())):
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo, ctx.CIfrEqualList, ctx.CIfrNotEqualList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#equalTermEqualRule.
- def visitEqualTermEqualRule(self, ctx:VfrSyntaxParser.EqualTermEqualRuleContext):
- self.visitChildren(ctx)
- EObj = CIfrEqual(ctx.start.line)
- ctx.CIfrEqualList.append(EObj)
-
- return EObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#equalTermNotEqualRule.
- def visitEqualTermNotEqualRule(self, ctx:VfrSyntaxParser.EqualTermNotEqualRuleContext):
- self.visitChildren(ctx)
- NEObj = CIfrNotEqual(ctx.start.line)
- ctx.CIfrNotEqualList.append(NEObj)
- return NEObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#compareTerm.
- def visitCompareTerm(self, ctx:VfrSyntaxParser.CompareTermContext):
- self.visitChildren(ctx)
- for i in range(0, len(ctx.compareTermSupplementary())):
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.ExpInfo, ctx.CIfrLessThanList, ctx.CIfrLessEqualList, ctx.CIfrGreaterThanList, ctx.CIfrGreaterEqualList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#compareTermLessRule.
- def visitCompareTermLessRule(self, ctx:VfrSyntaxParser.CompareTermLessRuleContext):
- self.visitChildren(ctx)
- LTObj = CIfrLessThan(ctx.start.line)
- ctx.CIfrLessThanList.append(LTObj)
- return LTObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#compareTermLessEqualRule.
- def visitCompareTermLessEqualRule(self, ctx:VfrSyntaxParser.CompareTermLessEqualRuleContext):
- self.visitChildren(ctx)
- LEObj = CIfrLessEqual(ctx.start.line)
- ctx.CIfrLessEqualList.append(LEObj)
- return LEObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#compareTermGreaterRule.
- def visitCompareTermGreaterRule(self, ctx:VfrSyntaxParser.CompareTermGreaterRuleContext):
- self.visitChildren(ctx)
- GTObj = CIfrGreaterThan(ctx.start.line)
- ctx.CIfrGreaterThanList.append(GTObj)
- return GTObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#compareTermGreaterEqualRule.
- def visitCompareTermGreaterEqualRule(self, ctx:VfrSyntaxParser.CompareTermGreaterEqualRuleContext):
- self.visitChildren(ctx)
- GEObj = CIfrGreaterEqual(ctx.start.line)
- ctx.CIfrGreaterEqualList.append(GEObj)
- return GEObj
-
- # Visit a parse tree produced by VfrSyntaxParser#shiftTerm.
- def visitShiftTerm(self, ctx:VfrSyntaxParser.ShiftTermContext):
- self.visitChildren(ctx)
- for i in range(0, len(ctx.shiftTermSupplementary())):
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.ExpInfo, ctx.CIfrShiftLeftList, ctx.CIfrShiftRightList
-
- # Visit a parse tree produced by VfrSyntaxParser#shiftTermLeft.
- def visitShiftTermLeft(self, ctx:VfrSyntaxParser.ShiftTermLeftContext):
- self.visitChildren(ctx)
- SLObj = CIfrShiftLeft(ctx.start.line)
- ctx.CIfrShiftLeftList.append(SLObj)
- return SLObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#shiftTermRight.
- def visitShiftTermRight(self, ctx:VfrSyntaxParser.ShiftTermRightContext):
- self.visitChildren(ctx)
- SRObj = CIfrShiftRight(ctx.start.line)
- ctx.CIfrShiftRightList.append(SRObj)
- return SRObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#addMinusTerm.
- def visitAddMinusTerm(self, ctx:VfrSyntaxParser.AddMinusTermContext):
- self.visitChildren(ctx)
- for i in range(0, len(ctx.addMinusTermSupplementary())):
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.ExpInfo, ctx.CIfrAddList, ctx.CIfrSubtractList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#addMinusTermpAdd.
- def visitAddMinusTermpAdd(self, ctx:VfrSyntaxParser.AddMinusTermpAddContext):
- self.visitChildren(ctx)
- AObj = CIfrAdd(ctx.start.line)
- ctx.CIfrAddList.append(AObj)
- return AObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#addMinusTermSubtract.
- def visitAddMinusTermSubtract(self, ctx:VfrSyntaxParser.AddMinusTermSubtractContext):
- self.visitChildren(ctx)
- SObj = CIfrSubtract(ctx.start.line)
- ctx.CIfrSubtractList.append(SObj)
- return SObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#multdivmodTerm.
- def visitMultdivmodTerm(self, ctx:VfrSyntaxParser.MultdivmodTermContext):
- self.visitChildren(ctx)
- for i in range(0, len(ctx.multdivmodTermSupplementary())):
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.ExpInfo, ctx.CIfrMultiplyList, ctx.CIfrDivideList, ctx.CIfrModuloList
-
-
- # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermMul.
- def visitMultdivmodTermMul(self, ctx:VfrSyntaxParser.MultdivmodTermMulContext):
- self.visitChildren(ctx)
- MObj = CIfrMultiply(ctx.start.line)
- ctx.CIfrMultiplyList.append(MObj)
- return MObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermDiv.
- def visitMultdivmodTermDiv(self, ctx:VfrSyntaxParser.MultdivmodTermDivContext):
- self.visitChildren(ctx)
- DObj = CIfrDivide(ctx.start.line)
- ctx.CIfrDivideList.append(DObj)
- return DObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#multdivmodTermRound.
- def visitMultdivmodTermModulo(self, ctx:VfrSyntaxParser.MultdivmodTermModuloContext):
- self.visitChildren(ctx)
- ctx.Line = ctx.start.line
- MObj = CIfrModulo(ctx.Line)
- ctx.CIfrModuloList.append(MObj)
- return MObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#castTerm.
- def visitCastTerm(self, ctx:VfrSyntaxParser.CastTermContext):
- self.visitChildren(ctx) ##
- CastType = 0xFF
- if ctx.Boolean() != []:
- CastType = 0
- elif ctx.Uint64() != []:
- CastType = 1
- elif ctx.Uint32() != []:
- CastType = 1
- elif ctx.Uint16() != []:
- CastType = 1
- elif ctx.Uint8() != []:
- CastType = 1
-
- Line = ctx.start.line
- if CastType == 0:
- ctx.TBObj = CIfrToBoolean(Line)
- elif CastType == 1:
- ctx.TUObj = CIfrToUint(Line)
-
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TBObj, ctx.TUObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#atomTerm.
- def visitAtomTerm(self, ctx:VfrSyntaxParser.AtomTermContext):
- self.visitChildren(ctx)
- if ctx.NOT() != None:
- Line = ctx.start.line
- NObj = CIfrNot(Line)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionCatenate.
- def visitVfrExpressionCatenate(self, ctx:VfrSyntaxParser.VfrExpressionCatenateContext):
- ctx.ExpInfo.RootLevel += 1
- self.visitChildren(ctx)
-
- Line = ctx.start.line
- ctx.CObj = CIfrCatenate(Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.CObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionMatch.
- def visitVfrExpressionMatch(self, ctx:VfrSyntaxParser.VfrExpressionMatchContext):
- ctx.ExpInfo.RootLevel += 1
- self.visitChildren(ctx)
-
- Line = ctx.start.line
- ctx.MObj = CIfrMatch(Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.MObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionMatch2.
- def visitVfrExpressionMatch2(self, ctx:VfrSyntaxParser.VfrExpressionMatch2Context):
- self.visitChildren(ctx)
-
- Line = ctx.start.line
- Guid = ctx.guidDefinition().Guid
- ctx.M2Obj = CIfrMatch2(Line, Guid)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.M2Obj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionParen.
- def visitVfrExpressionParen(self, ctx:VfrSyntaxParser.VfrExpressionParenContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionBuildInFunction.
- def visitVfrExpressionBuildInFunction(self, ctx:VfrSyntaxParser.VfrExpressionBuildInFunctionContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#dupExp.
- def visitDupExp(self, ctx:VfrSyntaxParser.DupExpContext):
-
- self.visitChildren(ctx)
- Line = ctx.start.line
- DObj = CIfrDup(Line)
- self.__SaveOpHdrCond(DObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line) #
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vareqvalExp.
- def visitVareqvalExp(self, ctx:VfrSyntaxParser.VareqvalExpContext):
-
- Line = ctx.start.line
- self.visitChildren(ctx)
-
- ReturnCode = VfrReturnCode.VFR_RETURN_UNSUPPORTED
- VarIdStr = 'var'
- VarIdStr += str(ctx.Number(0))
- VarStoreId, ReturnCode = gCVfrDataStorage.GetVarStoreId(VarIdStr)
- if ReturnCode == VfrReturnCode.VFR_RETURN_UNDEFINED:
- pass
- else:
- pass
- QId, Mask, _ = self.__CVfrQuestionDB.GetQuestionId(None, VarIdStr)
- ConstVal = self.__TransNum(ctx.Number(1))
- if ctx.Equal() != None:
- if Mask == 0:
- EIVObj = CIfrEqIdVal(Line)
- self.__SaveOpHdrCond(EIVObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- EIVObj.SetQuestionId(QId, VarIdStr, Line)
- EIVObj.SetValue(ConstVal)
- ctx.ExpInfo.ExpOpCount += 1
- else:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.EQUAL)
- elif ctx.LessEqual() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_EQUAL)
-
- elif ctx.Less() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_THAN)
-
- elif ctx.GreaterEqual() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_EQUAL)
-
- elif ctx.Greater() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_THAN)
-
-
- return ctx.ExpInfo
-
-
- def ConvertIdExpr(self, ExpInfo, LineNo, QId, VarIdStr, BitMask):
-
- QR1Obj = CIfrQuestionRef1(LineNo)
- QR1Obj.SetQuestionId(QId, VarIdStr, LineNo)
- self.__SaveOpHdrCond(QR1Obj.GetHeader(), (ExpInfo.ExpOpCount == 0))
- if BitMask != 0:
- U32Obj = CIfrUint32(LineNo)
- U32Obj.SetValue(BitMask)
-
- BWAObj = CIfrBitWiseAnd(LineNo)
-
- U8Obj = CIfrUint8(LineNo)
- if BitMask == DATE_YEAR_BITMASK:
- U8Obj.SetValue (0)
- elif BitMask == TIME_SECOND_BITMASK:
- U8Obj.SetValue (0x10)
- elif BitMask == DATE_DAY_BITMASK:
- U8Obj.SetValue (0x18)
- elif BitMask == TIME_HOUR_BITMASK:
- U8Obj.SetValue (0)
- elif BitMask == TIME_MINUTE_BITMASK:
- U8Obj.SetValue (0x8)
-
- SRObj = CIfrShiftRight(LineNo)
-
- ExpInfo.ExpOpCount += 4
-
-
- def IdEqValDoSpecial(self, ExpInfo, LineNo, QId, VarIdStr, BitMask, ConstVal, CompareType):
-
- self.ConvertIdExpr(ExpInfo, LineNo, QId, VarIdStr, BitMask)
- if ConstVal > 0xFF:
- U16Obj = CIfrUint16(LineNo)
- U16Obj.SetValue(ConstVal)
- else:
- U8Obj = CIfrUint8(LineNo)
- U8Obj.SetValue(ConstVal)
-
-
- if CompareType == EFI_COMPARE_TYPE.EQUAL:
- EObj = CIfrEqual(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.LESS_EQUAL:
- LEObj = CIfrLessEqual(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.LESS_THAN:
- LTObj = CIfrLessThan(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.GREATER_EQUAL:
- GEObj = CIfrGreaterEqual(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.GREATER_THAN:
- GTObj = CIfrGreaterThan(LineNo)
-
- ExpInfo.ExpOpCount += 2
-
-
- # Visit a parse tree produced by VfrSyntaxParser#ideqvalExp.
- def visitIdeqvalExp(self, ctx:VfrSyntaxParser.IdeqvalExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- Mask = ctx.vfrQuestionDataFieldName().Mask
- QId = ctx.vfrQuestionDataFieldName().QId
- VarIdStr = ctx.vfrQuestionDataFieldName().VarIdStr
- LineNo = ctx.vfrQuestionDataFieldName().Line
- ConstVal = self.__TransNum(ctx.Number())
- if ctx.Equal() != None:
- if Mask == 0:
- EIVObj = CIfrEqIdVal(Line)
- self.__SaveOpHdrCond(EIVObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- EIVObj.SetQuestionId(QId, VarIdStr, LineNo)
- EIVObj.SetValue(ConstVal)
- ctx.ExpInfo.ExpOpCount += 1
- else:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.EQUAL)
-
- elif ctx.LessEqual() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_EQUAL)
-
- elif ctx.Less() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.LESS_THAN)
-
- elif ctx.GreaterEqual() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_EQUAL)
-
- elif ctx.Greater() != None:
- self.IdEqValDoSpecial(ctx.ExpInfo, Line, QId, VarIdStr, Mask, ConstVal, EFI_COMPARE_TYPE.GREATER_THAN)
-
- return ctx.ExpInfo
-
-
- def IdEqIdDoSpecial(self, ExpInfo, LineNo, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, CompareType):
-
- self.ConvertIdExpr(ExpInfo, LineNo, QId1, VarIdStr1, Mask1)
- self.ConvertIdExpr(ExpInfo, LineNo, QId2, VarIdStr2, Mask2)
-
- if CompareType == EFI_COMPARE_TYPE.EQUAL:
- EObj = CIfrEqual(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.LESS_EQUAL:
- LEObj = CIfrLessEqual(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.LESS_THAN:
- LTObj = CIfrLessThan(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.GREATER_EQUAL:
- GEObj = CIfrGreaterEqual(LineNo)
-
- if CompareType == EFI_COMPARE_TYPE.GREATER_THAN:
- GTObj = CIfrGreaterThan(LineNo)
-
- ExpInfo.ExpOpCount += 1
-
-
- # Visit a parse tree produced by VfrSyntaxParser#ideqidExp.
- def visitIdeqidExp(self, ctx:VfrSyntaxParser.IdeqidExpContext):
- self.visitChildren(ctx)
- Line = ctx.start.line
- Mask1 = ctx.vfrQuestionDataFieldName(0).Mask
- QId1 = ctx.vfrQuestionDataFieldName(0).QId
- VarIdStr1 = ctx.vfrQuestionDataFieldName(0).VarIdStr
- LineNo1 = ctx.vfrQuestionDataFieldName(0).Line
-
- Mask2 = ctx.vfrQuestionDataFieldName(1).Mask
- QId2 = ctx.vfrQuestionDataFieldName(1).QId
- VarIdStr2 = ctx.vfrQuestionDataFieldName(1).VarIdStr
- LineNo2 = ctx.vfrQuestionDataFieldName(1).Line
-
- if ctx.Equal() != None:
- if Mask1 & Mask2:
- self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.EQUAL)
- else:
- EIIObj = CIfrEqIdId(Line)
- self.__SaveOpHdrCond(EIIObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- EIIObj.SetQuestionId1(QId1, VarIdStr1, LineNo1)
- EIIObj.SetQuestionId1(QId2, VarIdStr2, LineNo2)
- ctx.ExpInfo.ExpOpCount += 1
-
- elif ctx.LessEqual() != None:
- self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.LESS_EQUAL)
-
- elif ctx.Less() != None:
- self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.LESS_THAN)
-
- elif ctx.GreaterEqual() != None:
- self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.GREATER_EQUAL)
-
- elif ctx.Greater() != None:
- self.IdEqIdDoSpecial(ctx.ExpInfo, Line, QId1, VarIdStr1, Mask1, QId2, VarIdStr2, Mask2, EFI_COMPARE_TYPE.GREATER_THAN)
- return ctx.ExpInfo
-
-
- def IdEqListDoSpecial(self, ExpInfo, LineNo, QId, VarIdStr, Mask, ListLen, ValueList):
- if ListLen == 0:
- return
-
- self.IdEqValDoSpecial(ExpInfo, LineNo, QId, VarIdStr, Mask, ValueList[0], EFI_COMPARE_TYPE.EQUAL)
- for i in range(1, ListLen):
- self.IdEqValDoSpecial(ExpInfo, LineNo, QId, VarIdStr, Mask, ValueList[i], EFI_COMPARE_TYPE.EQUAL)
- OObj = CIfrOr(LineNo)
- ExpInfo.ExpOpCount += 1
-
-
- # Visit a parse tree produced by VfrSyntaxParser#ideqvallistExp.
- def visitIdeqvallistExp(self, ctx:VfrSyntaxParser.IdeqvallistExpContext):
- self.visitChildren(ctx)
- Line = ctx.start.line
- Mask = ctx.vfrQuestionDataFieldName().Mask
- QId = ctx.vfrQuestionDataFieldName().QId
- VarIdStr = ctx.vfrQuestionDataFieldName().VarIdStr
- LineNo = ctx.vfrQuestionDataFieldName().Line
- ValueList = []
- for i in range(0, len(ctx.Number())):
- ValueList.append(self.__TransNum(ctx.Number(i)))
-
- ListLen = len(ValueList)
-
- if Mask != 0:
- self.IdEqListDoSpecial(ctx.ExpInfo, LineNo, QId, VarIdStr, Mask, ListLen, ValueList)
- else:
- EILObj = CIfrEqIdList(Line, ListLen)
- if QId != EFI_QUESTION_ID_INVALID:
- EILObj.SetQuestionId(QId, VarIdStr, LineNo)
- EILObj.SetListLength(ListLen)
- EILObj.SetValueList(ValueList)
- self.__SaveOpHdrCond(EILObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- if QId == EFI_QUESTION_ID_INVALID:
- EILObj.SetQuestionId(QId, VarIdStr, LineNo)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.ExpInfo
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionDataFieldNameRule1.
- def visitVfrQuestionDataFieldNameRule1(self, ctx:VfrSyntaxParser.VfrQuestionDataFieldNameRule1Context):
- ctx.Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.VarIdStr += ctx.SN1.text
- ctx.VarIdStr += '['
- ctx.VarIdStr += ctx.I.text
- ctx.VarIdStr += ']'
- ctx.QId, ctx.Mask, _ = self.__CVfrQuestionDB.GetQuestionId(None, ctx.VarIdStr)
- if self.__ConstantOnlyInExpression:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_CONSTANT_ONLY, ctx.SN1.line)
- return ctx.QId, ctx.Mask, ctx.VarIdStr
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrQuestionDataFieldNameRule2.
- def visitVfrQuestionDataFieldNameRule2(self, ctx:VfrSyntaxParser.VfrQuestionDataFieldNameRule2Context):
- ctx.Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.VarIdStr += ctx.SN2.text
- for i in range(0, len(ctx.arrayName())):
- ctx.VarIdStr += '.'
- if self.__ConstantOnlyInExpression:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_CONSTANT_ONLY, ctx.SN2.line)
- ctx.VarIdStr += ctx.arrayName(i).SubStrZ
-
- ctx.QId, ctx.Mask, _ = self.__CVfrQuestionDB.GetQuestionId(None, ctx.VarIdStr)
- return ctx.QId, ctx.Mask, ctx.VarIdStr
-
-
- # Visit a parse tree produced by VfrSyntaxParser#arrayName.
- def visitArrayName(self, ctx:VfrSyntaxParser.ArrayNameContext):
-
- self.visitChildren(ctx)
- ctx.SubStr += self.__TransId(ctx.StringIdentifier())
- ctx.SubStrZ += self.__TransId(ctx.StringIdentifier())
- if ctx.N != None:
- Idx = self.__TransNum(ctx.N.text)
- if Idx > 0:
- ctx.SubStr += '['
- ctx.SubStr += str(Idx)
- ctx.SubStr += ']'
-
- ctx.SubStrZ += '['
- ctx.SubStrZ += str(Idx)
- ctx.SubStrZ += ']'
-
- return ctx.SubStr, ctx.SubStrZ
-
-
- # Visit a parse tree produced by VfrSyntaxParser#questionref1Exp.
- def visitQuestionref1Exp(self, ctx:VfrSyntaxParser.Questionref1ExpContext):
- Line = ctx.start.line #
- QName = None #
- QId = EFI_QUESTION_ID_INVALID
- self.visitChildren(ctx)
- if ctx.StringIdentifier() != None:
- QName = self.__TransId(ctx.StringIdentifier())
- QId, _ , _ = self.__CVfrQuestionDB.GetQuestionId(QName)
-
- elif ctx.Number() != None:
- QId = self.__TransNum(ctx.Number())
-
- QR1Obj = CIfrQuestionRef1(Line)
- self.__SaveOpHdrCond(QR1Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- QR1Obj.SetQuestionId(QId, QName, Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#rulerefExp.
- def visitRulerefExp(self, ctx:VfrSyntaxParser.RulerefExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- RRObj = CIfrRuleRef(Line)
- self.__SaveOpHdrCond(RRObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- RuleId = self.__CVfrRulesDB.GetRuleId(self.__TransId(ctx.StringIdentifier()))
- RRObj.SetRuleId(RuleId)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#stringref1Exp.
- def visitStringref1Exp(self, ctx:VfrSyntaxParser.Stringref1ExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- RefStringId = self.__TransNum(ctx.Number())
- SR1Obj = CIfrStringRef1(Line)
- self.__SaveOpHdrCond(SR1Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- SR1Obj.SetStringId(RefStringId)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#pushthisExp.
- def visitPushthisExp(self, ctx:VfrSyntaxParser.PushthisExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- TObj = CIfrThis(Line)
- self.__SaveOpHdrCond(TObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
- # Visit a parse tree produced by VfrSyntaxParser#securityExp.
- def visitSecurityExp(self, ctx:VfrSyntaxParser.SecurityExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- SObj = CIfrSecurity(Line)
- self.__SaveOpHdrCond(SObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- SObj.SetPermissions(ctx.guidDefinition().Guid)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
- # Visit a parse tree produced by VfrSyntaxParser#numericVarStoreType.
- def visitNumericVarStoreType(self, ctx:VfrSyntaxParser.NumericVarStoreTypeContext):
- self.visitChildren(ctx)
- if ctx.NumericSizeOne() != None:
- ctx.VarType = EFI_IFR_NUMERIC_SIZE_1
- if ctx.NumericSizeTwo() != None:
- ctx.VarType = EFI_IFR_NUMERIC_SIZE_2
- if ctx.NumericSizeFour() != None:
- ctx.VarType = EFI_IFR_NUMERIC_SIZE_4
- if ctx.NumericSizeEight() != None:
- ctx.VarType = EFI_IFR_NUMERIC_SIZE_8
-
- return ctx.VarType
-
-
- # Visit a parse tree produced by VfrSyntaxParser#getExp.
- def visitGetExp(self, ctx:VfrSyntaxParser.GetExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- if ctx.BaseInfo.VarStoreId == 0:
- # support Date/Time question
- VarIdStr = ctx.vfrStorageVarId().VarIdStr
- QId, Mask, QType = self.__CVfrQuestionDB.GetQuestionId(None, VarIdStr, EFI_QUESION_TYPE.QUESTION_NORMAL)
- if (QId == EFI_QUESTION_ID_INVALID) or (Mask == 0) or (QType == EFI_QUESION_TYPE.QUESTION_NORMAL):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
- if QType == EFI_QUESION_TYPE.QUESTION_DATE:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
- elif QType == EFI_QUESION_TYPE.QUESTION_TIME:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
-
- if Mask == DATE_YEAR_BITMASK:
- ctx.BaseInfo.VarOffset = 0
- elif Mask == DATE_DAY_BITMASK:
- ctx.BaseInfo.VarOffset = 3
- elif Mask == TIME_HOUR_BITMASK:
- ctx.BaseInfo.VarOffset = 0
- elif Mask == TIME_MINUTE_BITMASK:
- ctx.BaseInfo.VarOffset = 1
- elif Mask == TIME_SECOND_BITMASK:
- ctx.BaseInfo.VarOffset = 2
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
-
- else:
- VarType = EFI_IFR_TYPE_UNDEFINED
- if ctx.FLAGS() != None:
- VarType = ctx.numericVarStoreType().VarType
-
- if (gCVfrDataStorage.GetVarStoreType(ctx.BaseInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_NAME) and (VarType == EFI_IFR_TYPE_UNDEFINED):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support name string")
-
- if VarType != EFI_IFR_TYPE_UNDEFINED:
- ctx.BaseInfo.VarType = VarType
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
- ctx.BaseInfo.VarTotalSize = Size
-
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
-
- if Size != ctx.BaseInfo.VarTotalSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support data array")
-
- ctx.GObj = CIfrGet(Line)
- self.__SaveOpHdrCond(ctx.GObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.GObj.SetVarInfo(ctx.BaseInfo)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.GObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionConstant.
- def visitVfrExpressionConstant(self, ctx:VfrSyntaxParser.VfrExpressionConstantContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- if ctx.TrueSymbol() != None:
- TObj = CIfrTrue(Line)
- self.__SaveOpHdrCond(TObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.FalseSymbol() != None:
- FObj = CIfrFalse(Line)
- self.__SaveOpHdrCond(FObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.One() != None:
- OObj = CIfrOne(Line)
- self.__SaveOpHdrCond(OObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.Ones() != None:
- OObj = CIfrOnes(Line)
- self.__SaveOpHdrCond(OObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.Zero() != None:
- ZObj = CIfrZero(Line)
- self.__SaveOpHdrCond(ZObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.Undefined() != None:
- UObj = CIfrUndefined(Line)
- self.__SaveOpHdrCond(UObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.Version() != None:
- VObj = CIfrVersion(Line)
- self.__SaveOpHdrCond(VObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- if ctx.Number() != None:
- U64Obj = CIfrUint64(Line)
- U64Obj.SetValue(self.__TransNum(ctx.Number()))
- self.__SaveOpHdrCond(U64Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionUnaryOp.
- def visitVfrExpressionUnaryOp(self, ctx:VfrSyntaxParser.VfrExpressionUnaryOpContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#lengthExp.
- def visitLengthExp(self, ctx:VfrSyntaxParser.LengthExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.LObj = CIfrLength(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.LObj
-
- # Visit a parse tree produced by VfrSyntaxParser#bitwisenotExp.
- def visitBitwisenotExp(self, ctx:VfrSyntaxParser.BitwisenotExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.BWNObj = CIfrBitWiseNot(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.BWNObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#question23refExp.
- def visitQuestion23refExp(self, ctx:VfrSyntaxParser.Question23refExpContext):
- Line = ctx.start.line
- Type = 0x1
- DevicePath = EFI_STRING_ID_INVALID
- self.visitChildren(ctx)
- if ctx.DevicePath() != None:
- Type = 0x2
- DevicePath = self.__TransNum(ctx.Number())
-
- if ctx.Uuid() != None:
- Type = 0x3
-
- if Type == 0x1:
- QR2Obj = CIfrQuestionRef2(Line)
- self.__SaveOpHdrCond(QR2Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
-
- if Type == 0x2:
- QR3_2Obj = CIfrQuestionRef3_2(Line)
- self.__SaveOpHdrCond(QR3_2Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- QR3_2Obj.SetDevicePath(DevicePath)
-
- if Type == 0x3:
- QR3_3Obj = CIfrQuestionRef3_3(Line)
- self.__SaveOpHdrCond(QR3_3Obj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- QR3_3Obj.SetDevicePath(DevicePath)
- QR3_3Obj.SetGuid(ctx.guidDefinition().Guid)
-
- ctx.ExpInfo.ExpOpCount += 1
-
-
- return ctx.ExpInfo
-
-
- # Visit a parse tree produced by VfrSyntaxParser#stringref2Exp.
- def visitStringref2Exp(self, ctx:VfrSyntaxParser.Stringref2ExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.SR2Obj = CIfrStringRef2(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.SR2Obj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#toboolExp.
- def visitToboolExp(self, ctx:VfrSyntaxParser.ToboolExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.TBObj = CIfrToBoolean(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TBObj
-
- # Visit a parse tree produced by VfrSyntaxParser#tostringExp.
- def visitTostringExp(self, ctx:VfrSyntaxParser.TostringExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.TSObj = CIfrToString(Line)
- Fmt = self.__TransNum(ctx.Number())
- ctx.TSObj.SetFormat(Fmt)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TSObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#unintExp.
- def visitUnintExp(self, ctx:VfrSyntaxParser.UnintExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.TUObj = CIfrToUint(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TUObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#toupperExp.
- def visitToupperExp(self, ctx:VfrSyntaxParser.ToupperExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.TUObj = CIfrToUpper(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TUObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#tolwerExp.
- def visitTolwerExp(self, ctx:VfrSyntaxParser.TolwerExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.TLObj = CIfrToLower(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TLObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#setExp.
- def visitSetExp(self, ctx:VfrSyntaxParser.SetExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- if ctx.BaseInfo.VarStoreId == 0:
- # support Date/Time question
- VarIdStr = ctx.vfrStorageVarId().VarIdStr
- QId, Mask, QType = self.__CVfrQuestionDB.GetQuestionId(None, VarIdStr, EFI_QUESION_TYPE.QUESTION_NORMAL)
- if (QId == EFI_QUESTION_ID_INVALID) or (Mask == 0) or (QType == EFI_QUESION_TYPE.QUESTION_NORMAL):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
- if QType == EFI_QUESION_TYPE.QUESTION_DATE:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_DATE
- elif QType == EFI_QUESION_TYPE.QUESTION_TIME:
- ctx.BaseInfo.VarType = EFI_IFR_TYPE_TIME
-
- if Mask == DATE_YEAR_BITMASK:
- ctx.BaseInfo.VarOffset = 0
- elif Mask == DATE_DAY_BITMASK:
- ctx.BaseInfo.VarOffset = 3
- elif Mask == TIME_HOUR_BITMASK:
- ctx.BaseInfo.VarOffset = 0
- elif Mask == TIME_MINUTE_BITMASK:
- ctx.BaseInfo.VarOffset = 1
- elif Mask == TIME_SECOND_BITMASK:
- ctx.BaseInfo.VarOffset = 2
- else:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode can't get the enough varstore information")
-
- else:
- VarType = EFI_IFR_TYPE_UNDEFINED
- if ctx.FLAGS() != None:
- VarType = ctx.numericVarStoreType().VarType
-
- if (gCVfrDataStorage.GetVarStoreType(ctx.BaseInfo.VarStoreId) == EFI_VFR_VARSTORE_TYPE.EFI_VFR_VARSTORE_NAME) and (VarType == EFI_IFR_TYPE_UNDEFINED):
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support name string")
-
- if VarType != EFI_IFR_TYPE_UNDEFINED:
- ctx.BaseInfo.VarType = VarType
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
- ctx.BaseInfo.VarTotalSize = Size
-
- Size, ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSizeByDataType(ctx.BaseInfo.VarType)
- self.__ErrorHandler(ReturnCode, Line, "Get/Set opcode can't get var type size")
-
- if Size != ctx.BaseInfo.VarTotalSize:
- self.__ErrorHandler(VfrReturnCode.VFR_RETURN_UNSUPPORTED, Line, "Get/Set opcode don't support data array")
-
- ctx.TSObj = CIfrSet(Line)
- self.__SaveOpHdrCond(ctx.TSObj.GetHeader(), (ctx.ExpInfo.ExpOpCount == 0), Line)
- ctx.TSObj.SetVarInfo(ctx.BaseInfo)
- ctx.ExpInfo.ExpOpCount += 1
-
- return ctx.TSObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionTernaryOp.
- def visitVfrExpressionTernaryOp(self, ctx:VfrSyntaxParser.VfrExpressionTernaryOpContext):
- return self.visitChildren(ctx)
-
-
- # Visit a parse tree produced by VfrSyntaxParser#conditionalExp.
- def visitConditionalExp(self, ctx:VfrSyntaxParser.ConditionalExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.CObj = CIfrConditional(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.CObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#findExp.
- def visitFindExp(self, ctx:VfrSyntaxParser.FindExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- FObj = CIfrFind(Line)
- Format = 0
- for i in range(0, len(ctx.findFormat())):
- Format = ctx.findFormat(i).Format
-
- FObj.SetFormat(Format)
- ctx.ExpInfo.ExpOpCount += 1
- return FObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#findFormat.
- def visitFindFormat(self, ctx:VfrSyntaxParser.FindFormatContext):
- self.visitChildren(ctx)
- if ctx.Sensitive() != None:
- ctx.Format = 0x00
- elif ctx.Insensitive() != None:
- ctx.Format = 0x01
- return ctx.Format
-
-
- # Visit a parse tree produced by VfrSyntaxParser#midExp.
- def visitMidExp(self, ctx:VfrSyntaxParser.MidExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.MObj = CIfrMid(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.MObj
-
- # Visit a parse tree produced by VfrSyntaxParser#tokenExp.
- def visitTokenExp(self, ctx:VfrSyntaxParser.TokenExpContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.TObj = CIfrToken(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.TObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#spanExp.
- def visitSpanExp(self, ctx:VfrSyntaxParser.SpanExpContext):
- Line = ctx.start.line
- Flags = 0
- self.visitChildren(ctx)
- for FlagsCtx in ctx.spanFlags():
- Flags |= FlagsCtx.Flag
- ctx.SObj = CIfrSpan(Line)
- ctx.SObj.SetFlags(Flags)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.SObj
-
-
- # Visit a parse tree produced by VfrSyntaxParser#spanFlags.
- def visitSpanFlags(self, ctx:VfrSyntaxParser.SpanFlagsContext):
- self.visitChildren(ctx)
- if ctx.Number() != None:
- ctx.Flag = self.__TransNum(ctx.Number())
- elif ctx.LastNonMatch() != None:
- ctx.Flag = 0x00
- elif ctx.FirstNonMatch() != None:
- ctx.Flag = 0x01
- return ctx.Flag
-
-
- # Visit a parse tree produced by VfrSyntaxParser#vfrExpressionMap.
- def visitVfrExpressionMap(self, ctx:VfrSyntaxParser.VfrExpressionMapContext):
- Line = ctx.start.line
- self.visitChildren(ctx)
- ctx.MObj = CIfrMap(Line)
- EObj = CIfrEnd()
- Line = (None if ctx.stop is None else ctx.stop).line
- EObj.SetLineNo(Line)
- ctx.ExpInfo.ExpOpCount += 1
- return ctx.MObj
-
- def __GetText(self, ctx):
- if ctx == None:
- return None
- else:
- return ctx.text
-
- def __TransId(self, StringIdentifierToken, DefaultValue=None):
- if StringIdentifierToken == None:
- return DefaultValue
- else:
- return str(StringIdentifierToken)
-
- def __TransNum(self, NumberToken, DefaultValue=0):
- if NumberToken == None:
- return DefaultValue
- else:
- StrToken = str(NumberToken)
- if '0x' in StrToken:
- NumberToken = int(StrToken, 0)
- else:
- NumberToken = int(StrToken)
- # error handle , value is too large to store
- return NumberToken
-
- def __AssignQuestionKey(self, OpObj, Key):
-
- if Key == None:
- return
- if OpObj.GetFlags() & EFI_IFR_FLAG_CALLBACK:
- # if the question is not CALLBACK ignore the key.
- self.__CVfrQuestionDB.UpdateQuestionId(OpObj.GetQuestionId(), Key)
- OpObj.SetQuestionId(Key)
- return
-
- def __ExtractOriginalText(self, ctx):
- Source = ctx.start.getTokenSource()
- InputStream = Source.inputStream
- start, stop = ctx.start.start, ctx.stop.stop
- Text = InputStream.getText(start, stop)
- return Text.replace('\n', '')
-
- def __CheckDuplicateDefaultValue(self, DefaultId, Line, TokenValue):
- for i in range(0, len(self.__UsedDefaultArray)):
- if self.__UsedDefaultArray[i] == DefaultId:
- gCVfrErrorHandle.HandleWarning(EFI_VFR_WARNING_CODE.VFR_WARNING_DEFAULT_VALUE_REDEFINED, Line, TokenValue)
-
- if len(self.__UsedDefaultArray) >= EFI_IFR_MAX_DEFAULT_TYPE - 1:
- gCVfrErrorHandle.HandleError(VfrReturnCode.VFR_RETURN_FATAL_ERROR, Line, TokenValue)
-
- self.__UsedDefaultArray.append(DefaultId)
-
- def __ErrorHandler(self, ReturnCode, LineNum, TokenValue=None):
- self.__ParserStatus += gCVfrErrorHandle.HandleError(ReturnCode, LineNum, TokenValue)
-
- def __CompareErrorHandler(self, ReturnCode, ExpectedCode, LineNum, TokenValue=None, ErrorMsg=None):
- if ReturnCode != ExpectedCode:
- self.__ParserStatus += 1
- gCVfrErrorHandle.PrintMsg(LineNum, 'Error', ErrorMsg, TokenValue)
-
- def __InsertChild(self, ParentNode: VfrTreeNode, ChildCtx):
- if ChildCtx != None and ChildCtx.Node != None:
- ParentNode.insertChild(ChildCtx.Node)
-
- def GetRoot(self):
- return self.__Root
-
- def GetQuestionDB(self):
- return self.__CVfrQuestionDB
-
- def DumpJson(self, FileName):
- try:
- with open(FileName, 'w') as f:
- f.write('{\n')
- f.write(' \"DataStruct\" : {\n')
- pNode = gCVfrVarDataTypeDB.GetDataTypeList()
- while pNode != None:
- f.write(' \"{}\" : [\n'.format(str(pNode.TypeName)))
- FNode = pNode.Members
- while FNode != None:
- f.write(' {\n')
- f.write(' \"Name\": \"{}\",\n'.format(str(FNode.FieldName)))
- if FNode.ArrayNum > 0:
- f.write(' \"Type\": \"{}[{}]\",\n'.format(str(FNode.FieldType.TypeName),str(FNode.ArrayNum)))
- else:
- f.write(' \"Type\": \"{}\",\n'.format(str(FNode.FieldType.TypeName)))
- f.write(' \"Offset\": {}\n'.format(str(FNode.Offset)))
- if FNode.Next == None:
- f.write(' }\n')
- else:
- f.write(' }, \n')
- FNode = FNode.Next
- if pNode.Next == None:
- f.write(' ]\n')
- else:
- f.write(' ],\n')
- pNode = pNode.Next
- f.write(' },\n')
- f.write(' \"DataStructAttribute\": {\n')
- pNode = gCVfrVarDataTypeDB.GetDataTypeList()
- while pNode != None:
- f.write(' \"{}\"'.format(str(pNode.TypeName)) + ': {\n')
- f.write(' \"Alignment\": {},\n'.format(str(pNode.Align)))
- f.write(' \"TotalSize\": {}\n'.format(str(pNode.TotalSize)))
- if pNode.Next == None:
- f.write(' }\n')
- else:
- f.write(' },\n')
- pNode = pNode.Next
- f.write(' },\n')
- f.write(' \"VarDefine\" : {\n')
- pVsNode = gCVfrDataStorage.GetBufferVarStoreList()
- while pVsNode != None:
- f.write(' \"{}\"'.format(str(pVsNode.VarStoreName)) + ': {\n')
- f.write(' \"Type\": \"{}\",\n'.format(str(pVsNode.DataType.TypeName)))
- f.write(' \"Attributes\": {},\n'.format(str(pVsNode.Attributes)))
- f.write(' \"VarStoreId\": {},\n'.format(str(pVsNode.VarStoreId)))
- f.write(' \"VendorGuid\": ' + '\"{}, {}, {},'.format('0x%x'%(pVsNode.Guid.Data1),'0x%x'%(pVsNode.Guid.Data2), '0x%x'%(pVsNode.Guid.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(pVsNode.Guid.Data4[0]), '0x%x'%(pVsNode.Guid.Data4[1]), '0x%x'%(pVsNode.Guid.Data4[2]), '0x%x'%(pVsNode.Guid.Data4[3]), \
- '0x%x'%(pVsNode.Guid.Data4[4]), '0x%x'%(pVsNode.Guid.Data4[5]), '0x%x'%(pVsNode.Guid.Data4[6]), '0x%x'%(pVsNode.Guid.Data4[7])) + ' }}\"\n')
- if pVsNode.Next == None:
- f.write(' }\n')
- else:
- f.write(' },\n')
-
- pVsNode = pVsNode.Next
- f.write(' },\n')
- f.write(' \"Data\" : [\n')
- pVsNode = gCVfrBufferConfig.GetVarItemList()
- while pVsNode != None:
- if pVsNode.Id == None:
- pVsNode = pVsNode.Next
- continue
- pInfoNode = pVsNode.InfoStrList
- while pInfoNode != None:
- f.write(' {\n')
- f.write(' \"VendorGuid\": ' + '\"{}, {}, {},'.format('0x%x'%(pVsNode.Guid.Data1),'0x%x'%(pVsNode.Guid.Data2), '0x%x'%(pVsNode.Guid.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(pVsNode.Guid.Data4[0]), '0x%x'%(pVsNode.Guid.Data4[1]), '0x%x'%(pVsNode.Guid.Data4[2]), '0x%x'%(pVsNode.Guid.Data4[3]), \
- '0x%x'%(pVsNode.Guid.Data4[4]), '0x%x'%(pVsNode.Guid.Data4[5]), '0x%x'%(pVsNode.Guid.Data4[6]), '0x%x'%(pVsNode.Guid.Data4[7])) + ' }}\",\n')
- f.write(' \"VarName\": \"{}\",\n'.format(str(pVsNode.Name)))
- f.write(' \"DefaultStore\": \"{}\",\n'.format(str(pVsNode.Id)))
- f.write(' \"Size\": {},\n'.format(str(pInfoNode.Width)))
- f.write(' \"Offset\": {},\n'.format(str(pInfoNode.Offset)))
- #f.write(' \"Value\": \"{}\"\n'.format(str(pInfoNode.Value)))
- if pInfoNode.Type == EFI_IFR_TYPE_DATE:
- f.write(' \"Value\": \"{}/{}/{}\"\n'.format(pInfoNode.Value.date.Year, pInfoNode.Value.date.Month, pInfoNode.Value.date.Day))
- if pInfoNode.Type == EFI_IFR_TYPE_TIME:
- f.write(' \"Value\": \"{}:{}:{}\"\n'.format(pInfoNode.Value.time.Hour, pInfoNode.Value.time.Minute, pInfoNode.Value.time.Second))
- if pInfoNode.Type == EFI_IFR_TYPE_REF:
- f.write(' \"Value\": \"{};{};'.format(pInfoNode.Value.ref.QuestionId, pInfoNode.Value.ref.FormId) + '{' + '{}, {}, {},'.format('0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data1),'0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data2), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[0]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[1]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[2]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[3]), \
- '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[4]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[5]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[6]), '0x%x'%(pInfoNode.Value.ref.FormSetGuid.Data4[7])) + ' }}' + ';{}\n'.format(pInfoNode.Value.ref.DevicePath))
- if pInfoNode.Type == EFI_IFR_TYPE_STRING:
- f.write(' \"Value\": \"{}\"\n'.format(pInfoNode.Value.string))
- if pInfoNode.Type == EFI_IFR_TYPE_NUM_SIZE_8:
- f.write(' \"Value\": \"{}\"\n'.format(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'%(MethodMap.MethodIdentifier.Data2), '0x%x'%(MethodMap.MethodIdentifier.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(MethodMap.MethodIdentifier.Data4[0]), '0x%x'%(MethodMap.MethodIdentifier.Data4[1]), '0x%x'%(MethodMap.MethodIdentifier.Data4[2]), '0x%x'%(MethodMap.MethodIdentifier.Data4[3]), \
- '0x%x'%(MethodMap.MethodIdentifier.Data4[4]), '0x%x'%(MethodMap.MethodIdentifier.Data4[5]), '0x%x'%(MethodMap.MethodIdentifier.Data4[6]), '0x%x'%(MethodMap.MethodIdentifier.Data4[7])) + ' }}\n')
-
- if Root.OpCode == EFI_IFR_IMAGE_OP:
- Info = Root.Data.GetInfo()
- f.write(' - image:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' Id: {} # ImageId\n'.format(Info.Id))
-
- if Root.OpCode == EFI_IFR_RULE_OP:
- Info = Root.Data.GetInfo()
- f.write(' - rule:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' RuleId: {} # RuleId\n'.format(Info.RuleId))
-
- if Root.OpCode == EFI_IFR_SUBTITLE_OP:
- Info = Root.Data.GetInfo()
- f.write(' - subtitle:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Statement.Prompt))
-
- if Root.OpCode == EFI_IFR_TEXT_OP:
- Info = Root.Data.GetInfo()
- f.write(' - text:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Statement.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Statement.Help))
- f.write(' text: {} # Statement Help STRING_ID\n'.format(Info.TextTwo))
-
- if Root.OpCode == EFI_IFR_ACTION_OP:
- Info = Root.Data.GetInfo()
- f.write(' - action:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
- f.write(' questionconfig: {} # QuestionConfig\n'.format(Info.QuestionConfig))
-
- if Root.OpCode == EFI_IFR_ONE_OF_OP:
- Info = Root.Data.GetInfo()
- f.write(' - oneof:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
-
- if Root.OpCode == EFI_IFR_ONE_OF_OPTION_OP:
- Info = Root.Data.GetInfo()
- f.write(' - option: {}\n'.format(Info.Option))
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- f.write(' option flag: {}\n'.format(Info.Flags))
- f.write(' option type: {}\n'.format(Info.Type))
-
- if type(Root.Data) == CIfrOneOfOption:
- if Info.Type == EFI_IFR_TYPE_DATE:
- f.write(' option value: {}/{}/{}\n'.format(Info.Value.date.Year, Info.Value.date.Month, Info.Value.date.Day))
- if Info.Type == EFI_IFR_TYPE_TIME:
- f.write(' option value: {}:{}:{}\n'.format(Info.Value.time.Hour, Info.Value.time.Minute, Info.Value.time.Second))
- if Info.Type == EFI_IFR_TYPE_REF:
- f.write(' option value: {};{};'.format(Info.Value.ref.QuestionId, Info.Value.ref.FormId) + '{' + '{}, {}, {},'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data1),'0x%x'%(Info.Value.ref.FormSetGuid.Data2), '0x%x'%(Info.Value.ref.FormSetGuid.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data4[0]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[1]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[2]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[3]), \
- '0x%x'%(Info.Value.ref.FormSetGuid.Data4[4]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[5]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[6]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[7])) + ' }}' + ';{}\n'.format(Info.Value.ref.DevicePath))
- if Info.Type == EFI_IFR_TYPE_STRING:
- f.write(' option value: {}\n'.format(Info.Value.string))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_8:
- f.write(' option value: {}\n'.format(Info.Value.u8))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_16:
- f.write(' option value: {}\n'.format(Info.Value.u16))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_32:
- f.write(' option value: {}\n'.format(Info.Value.u32))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_64:
- f.write(' option value: {}\n'.format(Info.Value.u64))
- if Info.Type == EFI_IFR_TYPE_BOOLEAN:
- f.write(' option value: {}\n'.format(Info.Value.b))
-
- if type(Root.Data) == CIfrOneOfOption2:
- f.write(' value: {')
- ValueType = Root.Data.GetValueType()
- if ValueType == EFI_IFR_TYPE_STRING:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].string))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].string) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_8:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u8))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u8) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_16:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u16))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u16) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_32:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u32))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u32) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_64:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u64))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u64) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_BOOLEAN:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].b))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].b) + '}\n')
-
-
- if Root.OpCode == EFI_IFR_DEFAULT_OP:
- Info = Root.Data.GetInfo()
- f.write(' - default:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' type: {}\n'.format(Info.Type))
- f.write(' defaultId: {}\n'.format(Info.DefaultId))
- if type(Root.Data) == CIfrDefault:
- if Info.Type == EFI_IFR_TYPE_DATE:
- f.write(' value: {}/{}/{}\n'.format(Info.Value.date.Year, Info.Value.date.Month, Info.Value.date.Day))
- if Info.Type == EFI_IFR_TYPE_TIME:
- f.write(' value: {}:{}:{}\n'.format(Info.Value.time.Hour, Info.Value.time.Minute, Info.Value.time.Second))
- if Info.Type == EFI_IFR_TYPE_REF:
- f.write(' option value: {};{};'.format(Info.Value.ref.QuestionId, Info.Value.ref.FormId) + '{' + '{}, {}, {},'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data1),'0x%x'%(Info.Value.ref.FormSetGuid.Data2), '0x%x'%(Info.Value.ref.FormSetGuid.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Value.ref.FormSetGuid.Data4[0]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[1]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[2]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[3]), \
- '0x%x'%(Info.Value.ref.FormSetGuid.Data4[4]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[5]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[6]), '0x%x'%(Info.Value.ref.FormSetGuid.Data4[7])) + ' }}' + ';{}\n'.format(Info.Value.ref.DevicePath))
- if Info.Type == EFI_IFR_TYPE_STRING:
- f.write(' value: {}\n'.format(Info.Value.string))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_8:
- f.write(' value: {}\n'.format(Info.Value.u8))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_16:
- f.write(' value: {}\n'.format(Info.Value.u16))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_32:
- f.write(' value: {}\n'.format(Info.Value.u32))
- if Info.Type == EFI_IFR_TYPE_NUM_SIZE_64:
- f.write(' value: {}\n'.format(Info.Value.u64))
- if Info.Type == EFI_IFR_TYPE_BOOLEAN:
- f.write(' value: {}\n'.format(Info.Value.b))
-
- if type(Root.Data) == CIfrDefault3:
- f.write(' value: {')
- ValueType = Root.Data.GetValueType()
- if ValueType == EFI_IFR_TYPE_STRING:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].string))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].string) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_8:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u8))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u8) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_16:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u16))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u16) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_32:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u32))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u32) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_NUM_SIZE_64:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].u64))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].u64) + '}\n')
-
- if ValueType == EFI_IFR_TYPE_BOOLEAN:
- for i in range(0, len(Info.Value)-1):
- f.write('{},'.format(Info.Value[i].b))
- f.write('{}'.format(Info.Value[len(Info.Value)-1].b) + '}\n')
-
- if Root.OpCode == EFI_IFR_ORDERED_LIST_OP:
- Info = Root.Data.GetInfo()
- f.write(' - orderedlist:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' maxContainers: {}\n'.format(Info.MaxContainers))
- f.write(' flags: {}\n'.format(Info.Question.Flags))
-
- if Root.OpCode == EFI_IFR_NUMERIC_OP:
- Info = Root.Data.GetInfo()
- f.write(' - numeric:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
-
- if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_64:
- f.write(' maxvalue: {}\n'.format(Info.Data.u64.MaxValue))
- f.write(' minvalue: {}\n'.format(Info.Data.u64.MinValue))
- f.write(' step: {}\n'.format(Info.Data.u64.Step))
-
- if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_32:
- f.write(' maxvalue: {}\n'.format(Info.Data.u32.MaxValue))
- f.write(' minvalue: {}\n'.format(Info.Data.u32.MinValue))
- f.write(' step: {}\n'.format(Info.Data.u32.Step))
-
- if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_16:
- f.write(' maxvalue: {}\n'.format(Info.Data.u16.MaxValue))
- f.write(' minvalue: {}\n'.format(Info.Data.u16.MinValue))
- f.write(' step: {}\n'.format(Info.Data.u16.Step))
-
- if Root.Data.GetVarType() == EFI_IFR_TYPE_NUM_SIZE_8:
- f.write(' maxvalue: {}\n'.format(Info.Data.u8.MaxValue))
- f.write(' minvalue: {}\n'.format(Info.Data.u8.MinValue))
- f.write(' step: {}\n'.format(Info.Data.u8.Step))
-
- if Root.OpCode == EFI_IFR_CHECKBOX_OP:
- Info = Root.Data.GetInfo()
- f.write(' - checkbox:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' flags: {} # Flags\n'.format(Info.Flags))
-
- if Root.OpCode == EFI_IFR_TIME_OP:
- Info = Root.Data.GetInfo()
- f.write(' - time:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' questionid: {} # Statement Prompt STRING_ID\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {}\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {}\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' flags: {}\n'.format(Info.Flags))
-
- if Root.OpCode == EFI_IFR_DATE_OP:
- Info = Root.Data.GetInfo()
- f.write(' - date:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' questionid: {} # Statement Prompt STRING_ID\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {}\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {}\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' flags: {}\n'.format(Info.Flags))
-
-
- if Root.OpCode == EFI_IFR_STRING_OP:
- Info = Root.Data.GetInfo()
- f.write(' - string:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
- f.write(' stringflags: {}\n'.format(Info.Flags))
- f.write(' stringminsize: {}\n'.format(Info.MinSize))
- f.write(' stringmaxsize: {}\n'.format(Info.MaxSize))
-
- if Root.OpCode == EFI_IFR_PASSWORD_OP:
- Info = Root.Data.GetInfo()
- f.write(' - password:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Question.Header.Help))
- f.write(' questionid: {} # Question QuestionId\n'.format(Info.Question.QuestionId))
- f.write(' varstoreid: {} # Question VarStoreId\n'.format(Info.Question.VarStoreId))
- f.write(' varname: {} # Question VarName STRING_ID\n'.format(Info.Question.VarStoreInfo.VarName))
- f.write(' varoffset: {} # Question VarOffset\n'.format(Info.Question.VarStoreInfo.VarOffset))
- f.write(' flags: {} # Question Flags\n'.format(Info.Question.Flags))
- f.write(' minsize: {}\n'.format(Info.MinSize))
- f.write(' maxsize: {}\n'.format(Info.MaxSize))
-
-
- if Root.OpCode == EFI_IFR_RESET_BUTTON_OP:
- Info = Root.Data.GetInfo()
- f.write(' - resetbutton:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' prompt: {} # Statement Prompt STRING_ID\n'.format(Info.Statement.Prompt))
- f.write(' help: {} # Statement Help STRING_ID\n'.format(Info.Statement.Help))
- f.write(' defaultid: {}\n'.format(Info.DefaultId))
-
- if Root.OpCode == EFI_IFR_REF_OP:
- Info = Root.Data.GetInfo()
- f.write(' - goto:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- if type(Root.Data) == CIfrRef4:
- f.write(' formid: {}\n'.format(Info.FormId))
- f.write(' formsetid: {' + '{}, {}, {},'.format('0x%x'%(Info.FormSetId.Data1),'0x%x'%(Info.FormSetId.Data2), '0x%x'%(Info.FormSetId.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.FormSetId.Data4[0]), '0x%x'%(Info.FormSetId.Data4[1]), '0x%x'%(Info.FormSetId.Data4[2]), '0x%x'%(Info.FormSetId.Data4[3]), \
- '0x%x'%(Info.FormSetId.Data4[4]), '0x%x'%(Info.FormSetId.Data4[5]), '0x%x'%(Info.FormSetId.Data4[6]), '0x%x'%(Info.FormSetId.Data4[7])) + ' }}\n')
- f.write(' questionid: {}\n'.format(Info.QuestionId))
- f.write(' devicepath: {}\n'.format(Info.DevicePath))
-
- if type(Root.Data) == CIfrRef3:
- f.write(' formid: {}\n'.format(Info.FormId))
- f.write(' formsetid: {' + '{}, {}, {},'.format('0x%x'%(Info.FormSetId.Data1),'0x%x'%(Info.FormSetId.Data2), '0x%x'%(Info.FormSetId.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.FormSetId.Data4[0]), '0x%x'%(Info.FormSetId.Data4[1]), '0x%x'%(Info.FormSetId.Data4[2]), '0x%x'%(Info.FormSetId.Data4[3]), \
- '0x%x'%(Info.FormSetId.Data4[4]), '0x%x'%(Info.FormSetId.Data4[5]), '0x%x'%(Info.FormSetId.Data4[6]), '0x%x'%(Info.FormSetId.Data4[7])) + ' }}\n')
- f.write(' questionid: {}\n'.format(Info.QuestionId))
-
- if type(Root.Data) == CIfrRef2:
- f.write(' formid: {}\n'.format(Info.FormId))
- f.write(' questionid: {}\n'.format(Info.QuestionId))
-
- if type(Root.Data) == CIfrRef:
- f.write(' formid: {}\n'.format(Info.FormId))
- f.write(' questionid: {}\n'.format(Info.Question.QuestionId))
-
- f.write(' prompt: {}\n'.format(Info.Question.Header.Prompt))
- f.write(' help: {}\n'.format(Info.Question.Header.Help))
-
- if Root.OpCode == EFI_IFR_REFRESH_OP:
- Info = Root.Data.GetInfo()
- f.write(' - refresh:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' interval: {} # RefreshInterval\n'.format(Info.RefreshInterval))
-
- if Root.OpCode == EFI_IFR_VARSTORE_DEVICE_OP:
- Info = Root.Data.GetInfo()
- f.write(' - varstoredevice:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' devicepath: {} # DevicePath\n'.format(Info.DevicePath))
-
- if Root.OpCode == EFI_IFR_REFRESH_ID_OP:
- Info = Root.Data.GetInfo()
- f.write(' - refreshguid:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' eventgroupid: {' + '{}, {}, {},'.format('0x%x'%(Info.RefreshEventGroupId.Data1),'0x%x'%(Info.RefreshEventGroupId.Data2), '0x%x'%(Info.RefreshEventGroupId.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.RefreshEventGroupId.Data4[0]), '0x%x'%(Info.RefreshEventGroupId.Data4[1]), '0x%x'%(Info.RefreshEventGroupId.Data4[2]), '0x%x'%(Info.RefreshEventGroupId.Data4[3]), \
- '0x%x'%(Info.RefreshEventGroupId.Data4[4]), '0x%x'%(Info.RefreshEventGroupId.Data4[5]), '0x%x'%(Info.RefreshEventGroupId.Data4[6]), '0x%x'%(Info.RefreshEventGroupId.Data4[7])) + ' }}\n')
-
- if Root.OpCode == EFI_IFR_WARNING_IF_OP:
- Info = Root.Data.GetInfo()
- f.write(' - warningif:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' warning: {}\n'.format(Info.Warning))
- f.write(' timeOut: {}\n'.format(Info.TimeOut))
-
- if Root.OpCode == EFI_IFR_GUID_OP:
- Info = Root.Data.GetInfo()
- if type(Root.Data) == CIfrLabel: # type(Info) == EFI_IFR_GUID_LABEL
- f.write(' - label:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- f.write(' labelnumber: {} # LabelNumber\n'.format(Info.Number))
-
- if type(Root.Data) == CIfrBanner:
- f.write(' - banner:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- f.write(' title: {}\n'.format(Info.Title))
- f.write(' linenumber: {}\n'.format(Info.LineNumber))
- f.write(' align: {}\n'.format(Info.Alignment))
-
- if type(Root.Data) == CIfrTimeout:
- f.write(' - banner:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
-
- f.write(' timeout: {}\n'.format(Info.TimeOut))
-
- if type(Root.Data) == CIfrClass:
- f.write(' Class: {}\n'.format(Info.Class))
-
- if type(Root.Data) == CIfrSubClass:
- f.write(' SubClass: {}\n'.format(Info.SubClass))
-
- if type(Root.Data) == CIfrGuid:
- f.write(' - guidop:\n')
- if Root.Condition != None:
- f.write(' condition: {}\n'.format(Root.Condition))
- f.write(' guid: {' + '{}, {}, {},'.format('0x%x'%(Info.Guid.Data1),'0x%x'%(Info.Guid.Data2), '0x%x'%(Info.Guid.Data3)) \
- + ' { ' + '{}, {}, {}, {}, {}, {}, {}, {}'.format('0x%x'%(Info.Guid.Data4[0]), '0x%x'%(Info.Guid.Data4[1]), '0x%x'%(Info.Guid.Data4[2]), '0x%x'%(Info.Guid.Data4[3]), \
- '0x%x'%(Info.Guid.Data4[4]), '0x%x'%(Info.Guid.Data4[5]), '0x%x'%(Info.Guid.Data4[6]), '0x%x'%(Info.Guid.Data4[7])) + ' }}\n')
-
-
- if Root.Child != []:
- for ChildNode in Root.Child:
- if Root.OpCode in ConditionOps:
- if ChildNode.OpCode in ConditionOps:
- ChildNode.Condition = Root.Condition + ' | ' + ChildNode.Condition
- else:
- ChildNode.Condition = Root.Condition
-
- self.DumpYamlDfs(ChildNode, f)
-
- return
-
-del VfrSyntaxParser
\ No newline at end of file
+## @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_OPCODE, ctx.O.line, ctx.O.text
+ )
+
+ elif ctx.NVAccessFlag() != None:
+ gVfrErrorHandle.HandleWarning(
+ EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.N.line, ctx.N.text
+ )
+
+ elif ctx.LateCheckFlag() != None:
+ gVfrErrorHandle.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 = 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_OPCODE, ctx.N.line, ctx.N.text
+ )
+ if ctx.L != None:
+ VfrErrorHandle.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:
+ 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_OPCODE, ctx.A.line, ctx.A.text
+ )
+ if ctx.LateCheckFlag() != None:
+ gVfrErrorHandle.HandleWarning(
+ EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, ctx.L.line, ctx.L.text
+ )
+
+ return ctx.HFlag, ctx.LFlag
+
+ # Visit a parse tree produced by VfrSyntaxParser#vfrStatementRead.
+ def visitVfrStatementRead(self, ctx: VfrSyntaxParser.VfrStatementReadContext):
+ RObj = 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 (#116784): https://edk2.groups.io/g/devel/message/116784
Mute This Topic: https://groups.io/mt/104942849/7686176
Group Owner: devel+owner@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [rebecca@openfw.io]
-=-=-=-=-=-=-=-=-=-=-=-
^ permalink raw reply related [flat|nested] 4+ messages in thread
end of thread, other threads:[~2024-03-15 6:38 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-03-15 6:38 [edk2-devel] [PATCH] BaseTools: Python VfrCompiler implementation Yuting Yang
-- strict thread matches above, loose matches on Subject: below --
2023-11-08 12:45 Yuting Yang
2023-11-08 13:45 ` Yuwei Chen
[not found] ` <1795A9DEEBB01830.6123@groups.io>
2023-11-09 0:25 ` Yuwei Chen
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox