* Re: [edk2-devel] [Patch V1 1/2] BaseTools: Python VfrCompiler implementation
[not found] <176AB1C9D3D2653B.14466@groups.io>
@ 2023-06-21 14:16 ` Yuwei Chen
0 siblings, 0 replies; only message in thread
From: Yuwei Chen @ 2023-06-21 14:16 UTC (permalink / raw)
To: devel@edk2.groups.io, Chen, Christine
Cc: Rebecca Cran, Gao, Liming, Feng, Bob C, Yang, Yuting2
Hi all,
The python implementation of VfrCompiler tool development work has been done.
Here is the patch, or you can get the code from edk2-basetools repo PR: https://github.com/tianocore/edk2-basetools/pull/102
If you are interested in it, please follow the readme in BaseTools\Source\Python\VfrCompiler (edk2basetools\VfrCompiler) folder and try the python tool.
If have any others comments or questions, please send email to me (yuwei.chen@intel.com) or Yang, Yuting (yuting2.yang@intel.com) or directly reply this email.
Thanks,
Christine
> -----Original Message-----
> From: devel@edk2.groups.io <devel@edk2.groups.io> On Behalf Of Yuwei
> Chen
> Sent: Wednesday, June 21, 2023 10:08 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>; Yang,
> Yuting2 <yuting2.yang@intel.com>
> Subject: [edk2-devel] [Patch V1 1/2] 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/VfrCo
> mpile.
>
> This python implementation not only covers the same usage as
> the C version VfrCompiler, but also extends several new features.
>
> Edk2 Basetools issue link:
> https://github.com/tianocore/edk2-basetools/issues/68
>
> 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>
> ---
> BaseTools/Source/Python/VfrCompiler/IfrCommon.py | 83 ++++
> BaseTools/Source/Python/VfrCompiler/IfrCompiler.py | 555
> ++++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrCtypes.py | 1804
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrError.py | 134 +++++++
> BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py | 2861
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++
> BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py | 302
> ++++++++++++++
> BaseTools/Source/Python/VfrCompiler/IfrTree.py | 1528
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++
> BaseTools/Source/Python/VfrCompiler/IfrUtility.py | 2238
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/ReadMe.md | 47 +++
> BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4 | 1913
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py | 1709
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py | 20480
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py | 4846
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> +++++++++++++++++++++++++++++
> BaseTools/Source/Python/VfrCompiler/__init__.py | 1 +
> 14 files changed, 38501 insertions(+)
>
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> new file mode 100644
> index 000000000000..71c1daba9609
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCommon.py
> @@ -0,0 +1,83 @@
> +from VfrCompiler.IfrCtypes import *
> +
> +# 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)
> +
> +
> +def EFI_ERROR(A):
> + if A < 0:
> + return True
> + else:
> + return False
> +
> +
> +# Converts a string to an EFI_GUID.
> +def StringToGuid(AsciiGuidBuffer: str, GuidBuffer: EFI_GUID):
> + Data4 = [0] * 8
> + if AsciiGuidBuffer == None or GuidBuffer == None:
> + return EFI_INVALID_PARAMETER
> + Index = 0
> + while Index < 36:
> + if Index == 8 or Index == 13 or Index == 18 or Index == 23:
> + if AsciiGuidBuffer[Index] != "-":
> + break
> + else:
> + if (
> + (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 < 36:
> + EdkLogger.error("VfrCompiler", PARAMETER_INVALID, "Invalid option
> value")
> + return EFI_ABORTED
> + Index = 11
> + 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:
> + EdkLogger.error("VfrCompiler", PARAMETER_INVALID, "Invalid Data
> value!")
> + Index = 0
> +
> + # Verify the correct number of items were scanned.
> + if Index != 11:
> + 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 000000000000..19f05791d5c1
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCompiler.py
> @@ -0,0 +1,555 @@
> +import re
> +import os
> +import sys
> +import yaml
> +import logging
> +import shutil
> +import subprocess
> +import time
> +import argparse
> +from antlr4 import *
> +from VfrCompiler.VfrSyntaxParser import *
> +from VfrCompiler.VfrSyntaxVisitor import *
> +from VfrCompiler.VfrSyntaxLexer import *
> +from VfrCompiler.IfrCommon import *
> +from VfrCompiler.IfrTree import *
> +from VfrCompiler.IfrPreProcess import *
> +from VfrCompiler.IfrError import *
> +from Common.LongFilePathSupport import LongFilePath
> +
> +
> +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="VfrCompile version {} \
> + Build {} Copyright (c) 2004-2016 Intel Corporation.\
> + All rights reserved.".format(
> + VFR_COMPILER_VERSION, BUILD_VERSION
> + ),
> +)
> +parser.add_argument("InputFileName", help="Input source file name")
> +parser.add_argument("--vfr", dest="LaunchVfrCompiler",
> action="store_true", help="Launch VfrCompiler")
> +parser.add_argument(
> + "--version",
> + action="version",
> + version="VfrCompile version {} Build {}".format(VFR_COMPILER_VERSION,
> 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.LaunchVfrCompiler:
> + self.Options.LaunchVfrCompiler = 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 == None:
> + EdkLogger.error("VfrCompiler", OPTION_MISSING, "-o missing
> output directory name")
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> + LastChar =
> self.Options.OutputDirectory[len(self.Options.OutputDirectory) - 1]
> + if LastChar != "/" and LastChar != "\\":
> + if self.Options.OutputDirectory.find("/") != -1:
> + self.Options.OutputDirectory += "/"
> + self.Options.DebugDirectory =
> os.path.dirname(os.path.dirname(self.Options.OutputDirectory)) +
> "/DEBUG/"
> + else:
> + self.Options.OutputDirectory += "\\"
> + self.Options.DebugDirectory =
> os.path.dirname(os.path.dirname(self.Options.OutputDirectory)) +
> "\\DEBUG\\"
> + EdkLogger.debug(9, "Output Directory
> {}".format(self.Options.OutputDirectory))
> +
> + if Args.Workspace:
> + self.Options.Workspace = Args.Workspace
> + IsInCludePathLine = False
> + HasVFRPPLine = False
> + self.Options.IncludePaths = []
> + MakeFile =
> os.path.join(os.path.dirname(os.path.dirname(self.Options.OutputDirectory
> )), 'Makefile')
> + with open(MakeFile, '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 == False:
> + IsInCludePathLine = False
> + else:
> + break
> +
> + if Args.OldOutputDirectory:
> + self.Options.OldOutputDirectory = Args.OldOutputDirectory
> + if self.Options.OldOutputDirectory == None:
> + EdkLogger.error("VfrCompiler", OPTION_MISSING, "-oo missing
> output directory name")
> + self.SET_RUN_STATUS(COMPILER_RUN_STATUS.STATUS_DEAD)
> + return
> + EdkLogger.debug(9, "Old Output Directory
> {}".format(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 == 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 == 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(9, "Input string file path {}".format(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,
> + "Invalid format: {}".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 == 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 == 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 == 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 == None:
> + return -1
> + if self.Options.LaunchVfrCompiler:
> + self.Options.PkgOutputFileName = self.Options.OutputDirectory +
> "PyVfr_" + self.Options.BaseFileName + ".hpk"
> + return 0
> +
> + def SetCOutputFileName(self):
> + if self.Options.BaseFileName == None:
> + return -1
> + if self.Options.LaunchVfrCompiler:
> + self.Options.COutputFileName = self.Options.DebugDirectory +
> "PyVfr_" + self.Options.BaseFileName + ".c"
> + return 0
> +
> + def SetPreprocessorOutputFileName(self):
> + if self.Options.BaseFileName == None:
> + return -1
> + self.Options.CProcessedVfrFileName = self.Options.OutputDirectory +
> self.Options.BaseFileName + ".i"
> + return 0
> +
> + def SetRecordListFileName(self):
> + if self.Options.BaseFileName == None:
> + return -1
> + if self.Options.LaunchVfrCompiler:
> + self.Options.RecordListFileName = self.Options.DebugDirectory +
> "PyVfr_" + self.Options.BaseFileName + ".lst"
> + return 0
> +
> + def SetSourceYamlFileName(self):
> + if self.Options.BaseFileName == None:
> + return -1
> + self.Options.YamlFileName = self.Options.DebugDirectory +
> self.Options.BaseFileName + ".yml"
> + return 0
> +
> + def SetJsonFileName(self):
> + if self.Options.BaseFileName == None:
> + return -1
> + self.Options.JsonFileName = self.Options.DebugDirectory +
> self.Options.BaseFileName + ".json"
> + return 0
> +
> + def FindIncludeHeaderFile(self, Start, Name):
> + FileList = []
> + for Relpath, Dirs, 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)
> + else:
> + if self.Options.SkipCPreprocessor == False:
> + # call C precessor 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_PREPROCESSE
> D)
> +
> + 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() == 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.DumpSourceYaml()
> + 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)
> + if Cmd.Options.LaunchVfrCompiler:
> + 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__":
> + exit(main())
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> b/BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> new file mode 100644
> index 000000000000..bcc7eb264891
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrCtypes.py
> @@ -0,0 +1,1804 @@
> +from ctypes import *
> +from VfrCompiler.IfrError 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
> +
> +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 = (
> + "{"
> + + "{}, {}, {}, ".format("0x%x" % (self.Data1), "0x%x" % (self.Data2),
> "0x%x" % (self.Data3))
> + + "{"
> + + "{}, {}, {}, {}, {}, {}, {}, {}".format(
> + "0x%x" % (self.Data4[0]),
> + "0x%x" % (self.Data4[1]),
> + "0x%x" % (self.Data4[2]),
> + "0x%x" % (self.Data4[3]),
> + "0x%x" % (self.Data4[4]),
> + "0x%x" % (self.Data4[5]),
> + "0x%x" % (self.Data4[6]),
> + "0x%x" % (self.Data4[7]),
> + )
> + + "}}"
> + )
> + 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 000000000000..224750470e54
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrError.py
> @@ -0,0 +1,134 @@
> +import Common.EdkLogger as EdkLogger
> +from enum import Enum
> +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 == 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 == 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
> + else:
> + 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 000000000000..d5f0c27a7273
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrFormPkg.py
> @@ -0,0 +1,2861 @@
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrError import VfrReturnCode
> +from VfrCompiler.IfrUtility import *
> +from ctypes import *
> +
> +gVfrVarDataTypeDB = VfrVarDataTypeDB()
> +gVfrDefaultStore = VfrDefaultStore()
> +gVfrDataStorage = VfrDataStorage()
> +
> +
> +class ReCordNode(Structure):
> + def __init__(self, Record, LineNo):
> + self.Record = Record
> + self.LineNo = LineNo
> +
> +
> +class OpNode:
> + def __init__(self, Size, Scope):
> + self.Size = Size
> + self.Scope = Scope
> +
> +
> +gOpcodeSizesScopeTable = [
> + OpNode(0, 0), # EFI_IFR_INVALID - 0x00
> + OpNode(ctypes.sizeof(EFI_IFR_FORM), 1), # EFI_IFR_FORM_OP
> + OpNode(ctypes.sizeof(EFI_IFR_SUBTITLE), 1), # EFI_IFR_SUBTITLE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_TEXT), 0), # EFI_IFR_TEXT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_IMAGE), 0), # EFI_IFR_IMAGE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ONE_OF), 1), # EFI_IFR_ONE_OF_OP -
> 0x05
> + OpNode(ctypes.sizeof(EFI_IFR_CHECKBOX), 1), # EFI_IFR_CHECKBOX_OP
> + OpNode(ctypes.sizeof(EFI_IFR_NUMERIC), 1), # EFI_IFR_NUMERIC_OP
> + OpNode(ctypes.sizeof(EFI_IFR_PASSWORD), 1), #
> EFI_IFR_PASSWORD_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ONE_OF_OPTION), 0), #
> EFI_IFR_ONE_OF_OPTION_OP
> + OpNode(ctypes.sizeof(EFI_IFR_SUPPRESS_IF), 1), # EFI_IFR_SUPPRESS_IF -
> 0x0A
> + OpNode(ctypes.sizeof(EFI_IFR_LOCKED), 0), # EFI_IFR_LOCKED_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ACTION), 1), # EFI_IFR_ACTION_OP
> + OpNode(ctypes.sizeof(EFI_IFR_RESET_BUTTON), 1), #
> EFI_IFR_RESET_BUTTON_OP
> + OpNode(ctypes.sizeof(EFI_IFR_FORM_SET), 1), # EFI_IFR_FORM_SET_OP
> -0xE
> + OpNode(ctypes.sizeof(EFI_IFR_REF), 0), # EFI_IFR_REF_OP
> + OpNode(ctypes.sizeof(EFI_IFR_NO_SUBMIT_IF), 1), #
> EFI_IFR_NO_SUBMIT_IF_OP -0x10
> + OpNode(ctypes.sizeof(EFI_IFR_INCONSISTENT_IF), 1), #
> EFI_IFR_INCONSISTENT_IF_OP
> + OpNode(ctypes.sizeof(EFI_IFR_EQ_ID_VAL), 0), # EFI_IFR_EQ_ID_VAL_OP
> + OpNode(ctypes.sizeof(EFI_IFR_EQ_ID_ID), 0), # EFI_IFR_EQ_ID_ID_OP
> + OpNode(ctypes.sizeof(EFI_IFR_EQ_ID_VAL_LIST), 0), #
> EFI_IFR_EQ_ID_LIST_OP - 0x14
> + OpNode(ctypes.sizeof(EFI_IFR_AND), 0), # EFI_IFR_AND_OP
> + OpNode(ctypes.sizeof(EFI_IFR_OR), 0), # EFI_IFR_OR_OP
> + OpNode(ctypes.sizeof(EFI_IFR_NOT), 0), # EFI_IFR_NOT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_RULE), 1), # EFI_IFR_RULE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_GRAY_OUT_IF), 1), #
> EFI_IFR_GRAYOUT_IF_OP - 0x19
> + OpNode(ctypes.sizeof(EFI_IFR_DATE), 1), # EFI_IFR_DATE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_TIME), 1), # EFI_IFR_TIME_OP
> + OpNode(ctypes.sizeof(EFI_IFR_STRING), 1), # EFI_IFR_STRING_OP
> + OpNode(ctypes.sizeof(EFI_IFR_REFRESH), 0), # EFI_IFR_REFRESH_OP
> + OpNode(ctypes.sizeof(EFI_IFR_DISABLE_IF), 1), # EFI_IFR_DISABLE_IF_OP
> - 0x1E
> + OpNode(0, 0), # 0x1F
> + OpNode(ctypes.sizeof(EFI_IFR_TO_LOWER), 0), # EFI_IFR_TO_LOWER_OP
> - 0x20
> + OpNode(ctypes.sizeof(EFI_IFR_TO_UPPER), 0), # EFI_IFR_TO_UPPER_OP -
> 0x21
> + OpNode(ctypes.sizeof(EFI_IFR_MAP), 1), # EFI_IFR_MAP - 0x22
> + OpNode(ctypes.sizeof(EFI_IFR_ORDERED_LIST), 1), #
> EFI_IFR_ORDERED_LIST_OP - 0x23
> + OpNode(ctypes.sizeof(EFI_IFR_VARSTORE), 0), # EFI_IFR_VARSTORE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_VARSTORE_NAME_VALUE), 0), #
> EFI_IFR_VARSTORE_NAME_VALUE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_VARSTORE_EFI), 0), #
> EFI_IFR_VARSTORE_EFI_OP
> + OpNode(ctypes.sizeof(EFI_IFR_VARSTORE_DEVICE), 1), #
> EFI_IFR_VARSTORE_DEVICE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_VERSION), 0), # EFI_IFR_VERSION_OP -
> 0x28
> + OpNode(ctypes.sizeof(EFI_IFR_END), 0), # EFI_IFR_END_OP
> + OpNode(ctypes.sizeof(EFI_IFR_MATCH), 0), # EFI_IFR_MATCH_OP - 0x2A
> + OpNode(ctypes.sizeof(EFI_IFR_GET), 0), # EFI_IFR_GET - 0x2B
> + OpNode(ctypes.sizeof(EFI_IFR_SET), 0), # EFI_IFR_SET - 0x2C
> + OpNode(ctypes.sizeof(EFI_IFR_READ), 0), # EFI_IFR_READ - 0x2D
> + OpNode(ctypes.sizeof(EFI_IFR_WRITE), 0), # EFI_IFR_WRITE - 0x2E
> + OpNode(ctypes.sizeof(EFI_IFR_EQUAL), 0), # EFI_IFR_EQUAL_OP - 0x2F
> + OpNode(ctypes.sizeof(EFI_IFR_NOT_EQUAL), 0), #
> EFI_IFR_NOT_EQUAL_OP
> + OpNode(ctypes.sizeof(EFI_IFR_GREATER_THAN), 0), #
> EFI_IFR_GREATER_THAN_OP
> + OpNode(ctypes.sizeof(EFI_IFR_GREATER_EQUAL), 0), #
> EFI_IFR_GREATER_EQUAL_OP
> + OpNode(ctypes.sizeof(EFI_IFR_LESS_THAN), 0), # EFI_IFR_LESS_THAN_OP
> + OpNode(ctypes.sizeof(EFI_IFR_LESS_EQUAL), 0), #
> EFI_IFR_LESS_EQUAL_OP - 0x34
> + OpNode(ctypes.sizeof(EFI_IFR_BITWISE_AND), 0), #
> EFI_IFR_BITWISE_AND_OP
> + OpNode(ctypes.sizeof(EFI_IFR_BITWISE_OR), 0), #
> EFI_IFR_BITWISE_OR_OP
> + OpNode(ctypes.sizeof(EFI_IFR_BITWISE_NOT), 0), #
> EFI_IFR_BITWISE_NOT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_SHIFT_LEFT), 0), # EFI_IFR_SHIFT_LEFT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_SHIFT_RIGHT), 0), #
> EFI_IFR_SHIFT_RIGHT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ADD), 0), # EFI_IFR_ADD_OP - 0x3A
> + OpNode(ctypes.sizeof(EFI_IFR_SUBTRACT), 0), # EFI_IFR_SUBTRACT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_MULTIPLY), 0), # EFI_IFR_MULTIPLY_OP
> + OpNode(ctypes.sizeof(EFI_IFR_DIVIDE), 0), # EFI_IFR_DIVIDE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_MODULO), 0), # EFI_IFR_MODULO_OP -
> 0x3E
> + OpNode(ctypes.sizeof(EFI_IFR_RULE_REF), 0), # EFI_IFR_RULE_REF_OP
> + OpNode(ctypes.sizeof(EFI_IFR_QUESTION_REF1), 0), #
> EFI_IFR_QUESTION_REF1_OP
> + OpNode(ctypes.sizeof(EFI_IFR_QUESTION_REF2), 0), #
> EFI_IFR_QUESTION_REF2_OP - 0x41
> + OpNode(ctypes.sizeof(EFI_IFR_UINT8), 0), # EFI_IFR_UINT8
> + OpNode(ctypes.sizeof(EFI_IFR_UINT16), 0), # EFI_IFR_UINT16
> + OpNode(ctypes.sizeof(EFI_IFR_UINT32), 0), # EFI_IFR_UINT32
> + OpNode(ctypes.sizeof(EFI_IFR_UINT64), 0), # EFI_IFR_UTNT64
> + OpNode(ctypes.sizeof(EFI_IFR_TRUE), 0), # EFI_IFR_TRUE_OP - 0x46
> + OpNode(ctypes.sizeof(EFI_IFR_FALSE), 0), # EFI_IFR_FALSE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_TO_UINT), 0), # EFI_IFR_TO_UINT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_TO_STRING), 0), # EFI_IFR_TO_STRING_OP
> + OpNode(ctypes.sizeof(EFI_IFR_TO_BOOLEAN), 0), #
> EFI_IFR_TO_BOOLEAN_OP
> + OpNode(ctypes.sizeof(EFI_IFR_MID), 0), # EFI_IFR_MID_OP
> + OpNode(ctypes.sizeof(EFI_IFR_FIND), 0), # EFI_IFR_FIND_OP
> + OpNode(ctypes.sizeof(EFI_IFR_TOKEN), 0), # EFI_IFR_TOKEN_OP
> + OpNode(ctypes.sizeof(EFI_IFR_STRING_REF1), 0), #
> EFI_IFR_STRING_REF1_OP - 0x4E
> + OpNode(ctypes.sizeof(EFI_IFR_STRING_REF2), 0), #
> EFI_IFR_STRING_REF2_OP
> + OpNode(ctypes.sizeof(EFI_IFR_CONDITIONAL), 0), #
> EFI_IFR_CONDITIONAL_OP
> + OpNode(ctypes.sizeof(EFI_IFR_QUESTION_REF3), 0), #
> EFI_IFR_QUESTION_REF3_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ZERO), 0), # EFI_IFR_ZERO_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ONE), 0), # EFI_IFR_ONE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_ONES), 0), # EFI_IFR_ONES_OP
> + OpNode(ctypes.sizeof(EFI_IFR_UNDEFINED), 0), #
> EFI_IFR_UNDEFINED_OP
> + OpNode(ctypes.sizeof(EFI_IFR_LENGTH), 0), # EFI_IFR_LENGTH_OP
> + OpNode(ctypes.sizeof(EFI_IFR_DUP), 0), # EFI_IFR_DUP_OP - 0x57
> + OpNode(ctypes.sizeof(EFI_IFR_THIS), 0), # EFI_IFR_THIS_OP
> + OpNode(ctypes.sizeof(EFI_IFR_SPAN), 0), # EFI_IFR_SPAN_OP
> + OpNode(ctypes.sizeof(EFI_IFR_VALUE), 1), # EFI_IFR_VALUE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_DEFAULT), 0), # EFI_IFR_DEFAULT_OP
> + OpNode(ctypes.sizeof(EFI_IFR_DEFAULTSTORE), 0), #
> EFI_IFR_DEFAULTSTORE_OP - 0x5C
> + OpNode(ctypes.sizeof(EFI_IFR_FORM_MAP), 1), #
> EFI_IFR_FORM_MAP_OP - 0x5D
> + OpNode(ctypes.sizeof(EFI_IFR_CATENATE), 0), # EFI_IFR_CATENATE_OP
> + OpNode(ctypes.sizeof(EFI_IFR_GUID), 0), # EFI_IFR_GUID_OP
> + OpNode(ctypes.sizeof(EFI_IFR_SECURITY), 0), # EFI_IFR_SECURITY_OP -
> 0x60
> + OpNode(ctypes.sizeof(EFI_IFR_MODAL_TAG), 0), #
> EFI_IFR_MODAL_TAG_OP - 0x61
> + OpNode(ctypes.sizeof(EFI_IFR_REFRESH_ID), 0), #
> EFI_IFR_REFRESH_ID_OP - 0x62
> + OpNode(ctypes.sizeof(EFI_IFR_WARNING_IF), 1), #
> EFI_IFR_WARNING_IF_OP - 0x63
> + OpNode(ctypes.sizeof(EFI_IFR_MATCH2), 0),
> +]
> +
> +
> +class OpBufferNode:
> + def __init__(self, Buffer=None, Next=None):
> + self.Buffer = Buffer
> + self.Next = Next
> +
> +
> +class PACKAGE_DATA:
> + def __init__(self, Bu) -> None:
> + # self.Buffer = Buffer
> + pass
> +
> +
> +class ASSIGN_FLAG(Enum):
> + PENDING = 1
> + ASSIGNED = 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 == 1:
> + self.Addr.QuestionId1 = Val
> + elif self.Type == 2:
> + 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 == None:
> + return
> + if Root.OpCode != 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 == 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 == None or Val == None:
> + return
> + pNode = self.PendingAssignList
> + while pNode != None:
> + if pNode.Key == Key:
> + pNode.AssignValue(Val)
> + pNode = pNode.Next
> +
> + def HavePendingUnassigned(self):
> + pNode = self.PendingAssignList
> + while pNode != None:
> + if pNode.Flag == ASSIGN_FLAG.PENDING:
> + return True
> + pNode = pNode.Next
> +
> + return False
> +
> + def PendingAssignPrintAll(self):
> + pNode = self.PendingAssignList
> + while pNode != 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 != 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 != 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
> +BYTES_PRE_LINE = 0x10
> +
> +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 != 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,
> ctypes.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,
> 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
> +
> + 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,
> 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
> +
> + 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 i in range(0, EFI_FREE_FORM_ID_BITMAP_SIZE):
> + self.FormIdBitMap.append(0)
> +
> + def Clear(self):
> + self.FormIdBitMap = []
> + for i 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,
> ctypes.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,
> ctypes.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,
> 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 IfrLabel(IfrLine, IfrOpHeader):
> + def __init__(
> + self,
> + ):
> + self.Label = EFI_IFR_GUID_LABEL()
> + IfrOpHeader.__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 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,
> 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, 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,
> 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, 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
> +
> + def SetError(self, Error):
> + self.InconsistentIf.Error = Error
> +
> + 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, Warning):
> + self.WarningIf.Warning = Warning
> +
> + 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 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)
> +
> +
> +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=[]):
> + 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 != []:
> + 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 000000000000..f7fb90885576
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrPreProcess.py
> @@ -0,0 +1,302 @@
> +import re
> +import os
> +import subprocess
> +import CppHeaderParser
> +from antlr4 import *
> +from VfrCompiler.IfrFormPkg import *
> +from VfrCompiler.IfrCtypes import *
> +from Common.LongFilePathSupport import LongFilePath
> +
> +
> +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
> +
> +
> +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 Guid definitions in Header files
> + self.HeaderDict = self._GetHeaderDicts(self.HeaderFiles)
> + # 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()
> + else:
> + if ("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()
> + else:
> + StrValue = str(Value)
> + if self._IsDigit(StrValue):
> + if Flag:
> + return "STRING_TOKEN" + "(" + StrValue + ")"
> + else:
> + return int(StrValue, 0)
> +
> + return StrValue
> +
> + def GetKey(self, Value):
> + if type(Value) == EFI_GUID:
> + Value = Value.to_string()
> + if Value in self.UniDict.keys():
> + return self.UniDict[Value]
> + if Value in self.VfrDict.keys():
> + return self.VfrDict[Value]
> + if Value in self.HeaderDict.keys():
> + return self.HeaderDict[Value]
> + else:
> + Value = "0x%04x" % Value
> + if Value in self.UniDict.keys():
> + return self.UniDict[Value]
> + return Value
> +
> + def _ExtractHeaderFiles(self):
> + FileName = self.Options.InputFileName
> + try:
> + fFile = open(LongFilePath(FileName), mode="r")
> + line = fFile.readline()
> + IsHeaderLine = False
> + HeaderFiles = []
> + while line:
> + if "#include" in line:
> + IsHeaderLine = True
> + if line.find("<") != -1:
> + HeaderFile = line[line.find("<") + 1 : line.find(">")]
> + HeaderFiles.append(HeaderFile)
> + if line.find('"') != -1:
> + l = line.find('"') + 1
> + r = l + line[l:].find('"')
> + HeaderFile = line[l:r]
> + HeaderFiles.append(HeaderFile)
> + line = fFile.readline()
> + if IsHeaderLine == True and "#include" not in line:
> + break
> + fFile.close()
> + except:
> + EdkLogger.error("VfrCompiler", FILE_PARSE_FAILURE, "File parse
> failed for %s" % FileName, None)
> + return HeaderFiles
> +
> + def _GetUniDicts(self):
> + if self.Options.UniStrDefFileName == None:
> + self.Options.UniStrDefFileName = self.Options.DebugDirectory +
> self.Options.ModuleName + "StrDefs.h"
> + # find UniFile
> + FileName = self.Options.UniStrDefFileName
> + with open(FileName, "r") as File:
> + Content = File.read()
> + UniDict = {}
> + self._ParseDefines(FileName, UniDict)
> +
> + return UniDict
> +
> + def _GetHeaderDicts(self, HeaderFiles):
> + HeaderDict = {}
> + VFRrespPath = os.path.join(self.Options.OutputDirectory,
> "vfrpp_resp.txt")
> + if os.path.exists(VFRrespPath):
> + Command = [
> + rf"{self.Options.VFRPP}",
> + "/showIncludes",
> + f"@{VFRrespPath}",
> + self.Options.InputFileName
> + ]
> + try:
> + Process = subprocess.Popen(Command, stdout=subprocess.PIPE,
> stderr=subprocess.PIPE, universal_newlines=True)
> + _, Error = Process.communicate()
> + except subprocess.CalledProcessError as e:
> + print(f"Error executing command: {e}")
> + EdkLogger.error("VfrCompiler", COMMAND_FAILURE, '
> '.join(Command))
> + Pattern = r'Note: including file:\s+(.*)'
> + IncludePaths = re.findall(Pattern, Error)
> + for IncludePath in IncludePaths:
> + self._ParseDefines(IncludePath, HeaderDict)
> + else:
> + for HeaderFile in HeaderFiles:
> + FileList = self._FindIncludeHeaderFile(self.Options.IncludePaths,
> HeaderFile)
> + CppHeader = None
> + for File in FileList:
> + if File.find(HeaderFile.replace("/", "\\")) != -1:
> + CppHeader = CppHeaderParser.CppHeader(File)
> + self._ParseDefines(File, HeaderDict)
> + if CppHeader == None:
> + EdkLogger.error("VfrCompiler", FILE_NOT_FOUND,
> "File/directory %s not found in workspace" % (HeaderFile), None)
> + self._ParseRecursiveHeader(CppHeader, HeaderDict)
> +
> + return HeaderDict
> +
> + def _ParseRecursiveHeader(self, CppHeader, HeaderDict):
> + if CppHeader != None:
> + for Include in CppHeader.includes:
> + Include = Include[1:-1]
> + IncludeHeaderFileList =
> self._FindIncludeHeaderFile(self.Options.IncludePaths, Include)
> + Flag = False
> + for File in IncludeHeaderFileList:
> + if File.find(Include.replace("/", "\\")) != -1:
> + NewCppHeader = CppHeaderParser.CppHeader(File)
> + self._ParseRecursiveHeader(NewCppHeader, HeaderDict)
> + self._ParseDefines(File, HeaderDict)
> + Flag = True
> + if Flag == False:
> + EdkLogger.error("VfrCompiler", FILE_NOT_FOUND,
> "File/directory %s not found in workspace" % Include, None)
> +
> +
> + def _GetVfrDicts(self):
> + VfrDict = {}
> + if self.Options.LanuchVfrCompiler:
> + FileName = self.Options.InputFileName
> + self._ParseDefines(FileName, VfrDict, True)
> + return VfrDict
> +
> + def _IsDigit(self, String):
> + if String.isdigit():
> + return True
> + elif (String.startswith('0x') or String.startswith('0X')) and all(char in
> "0123456789ABCDEFabcdef" for char in String[2:]):
> + return True
> + else:
> + return False
> +
> + def _ToDigit(self, String):
> + if String.startswith("0x") or String.startswith("0X"):
> + return int(String, 16)
> + else:
> + return int(String)
> +
> + def _ParseDefines(self, FileName, Dict, IsVfrDef = False):
> + Pattern = r"#define\s+(\w+)\s+(.*?)(?:(?<!\\)\n|$)"
> + with open(FileName, "r") 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) == 11:
> + 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()
> + if self._IsDigit(SubValue):
> + SubValue = "0x%04x" % self._ToDigit(SubValue)
> + 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) == 11:
> + 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()
> + if self._IsDigit(Value):
> + Value = "0x%04x" % self._ToDigit(Value)
> + Dict[Value] = Key
> +
> + def _FindIncludeHeaderFile(self, IncludePaths, File):
> + Name = File.split("/")[-1]
> + FileList = []
> + for Start in IncludePaths:
> + for Relpath, Dirs, Files in os.walk(Start):
> + if Name in Files:
> + FullPath = os.path.join(Start, Relpath, Name)
> + FullPath = FullPath.replace("\\", "/")
> + if FullPath.find(File) != -1:
> + FileList.append(os.path.normpath(os.path.abspath(FullPath)))
> +
> + 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 000000000000..4d3df58764e9
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrTree.py
> @@ -0,0 +1,1528 @@
> +from antlr4 import *
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrPreProcess import *
> +from VfrCompiler.IfrFormPkg import *
> +
> +# Ifr related Info -> ctypes obj
> +# conditional Info
> +# Structure Info
> +
> +VFR_COMPILER_VERSION = "2.01 (UEFI 2.4)"
> +BUILD_VERSION = "Developer Build based on Revision: Unknown"
> +
> +
> +class IfrTreeNode:
> + def __init__(self, OpCode=None, Data=None, Buffer=None,
> Position=None) -> 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) -> bool:
> + if self.Condition == None:
> + return False
> + else:
> + return True
> +
> + 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 NewNode != None:
> + if not pos:
> + 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
> +
> +
> +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 IfrTree:
> + def __init__(self, Root: IfrTreeNode, PreProcessDB: PreProcessDB,
> Options: Options) -> None:
> + self.Root = Root
> + self.Options = Options
> + self.PreProcessDB = PreProcessDB
> +
> + def GenBinaryFiles(self):
> + Hpk = None
> + C = None
> + RecordLines = []
> + if self.Options.CreateIfrPkgFile:
> + # GenBinary
> + PkgHdr = gFormPkg.BuildPkgHdr()
> + try:
> + HpkFile = self.Options.PkgOutputFileName
> + Hpk = open(HpkFile, "wb")
> + Hpk.write(gFormPkg.StructToStream(PkgHdr))
> + except:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> HpkFile
> + )
> +
> + # GenCFile
> + try:
> + CFile = self.Options.COutputFileName
> + C = open(CFile, "w")
> + 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(ctypes.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:
> + EdkLogger.error("VfrCompiler", FILE_OPEN_FAILURE, "File open
> failed for %s" % CFile)
> +
> + if self.Options.CreateRecordListFile:
> + # GenRecordList
> + try:
> + LstFile = self.Options.RecordListFileName
> + Lst = open(LstFile, "w")
> + Lst.write(
> + "//\n// VFR compiler version {} {}\n//\n".format(
> + VFR_COMPILER_VERSION, BUILD_VERSION
> + )
> + )
> + except:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> LstFile
> + )
> +
> + self._GenBinaryFilesDfs(self.Root, Hpk, C, RecordLines)
> +
> + if self.Options.CreateIfrPkgFile:
> + # GenCFile
> + try:
> + C.write("\n};\n")
> + except:
> + EdkLogger.error(
> + "VfrCompiler", FILE_WRITE_FAILURE, "File write failed for %s" %
> CFile, None
> + )
> +
> + if self.Options.CreateRecordListFile:
> + # GenRecordList
> + try:
> + In = open(self.Options.CProcessedVfrFileName, "r")
> + InFileLines = []
> + for Line in In:
> + InFileLines.append(Line)
> + Hpk.close()
> + C.close()
> + except:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_OPEN_FAILURE,
> + "File open failed for %s" % self.Options.CProcessedVfrFileName,
> + None,
> + )
> + try:
> + InsertedLine = 0
> + for RecordLine in RecordLines:
> + InFileLines.insert(RecordLine.LineNo + InsertedLine,
> RecordLine.Record)
> + InsertedLine += 1
> + for Line in InFileLines:
> + Lst.write("{}".format(Line))
> +
> + Lst.write("//\n// All Opcode Record List\n//\n")
> + for RecordLine in RecordLines:
> + Lst.write("{}".format(RecordLine.Record))
> + Lst.write("\nTotal Size of all record is" + "
> {:0>8x}".format(gFormPkg.Offset))
> + gVfrVarDataTypeDB.Dump(Lst)
> + In.close()
> + Lst.close()
> + except:
> + EdkLogger.error(
> + "VfrCompiler", FILE_WRITE_FAILURE, "File write failed for %s" %
> LstFile, None
> + )
> +
> + def _GenBinaryFilesDfs(self, Root, Hpk, C, RecordLines):
> + if Root == None:
> + return
> +
> + if Root.OpCode != 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 != None:
> + if self.Options.CreateIfrPkgFile and
> self.Options.CreateRecordListFile:
> + try:
> + Hpk.write(Root.Buffer)
> + except:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" %
> (self.Options.PkgOutputFileName),
> + )
> +
> + try:
> + 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 += "{:0>2X} ".format(Root.Buffer[i])
> +
> + Record = ">{:0>8X}: ".format(Root.Offset) + LineBuffer + "\n"
> + LineNo = Root.Data.GetLineNo()
> + RecordLines.append(ReCordNode(Record, LineNo))
> + except:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" % (self.Options.COutputFileName),
> + )
> +
> + if self.Options.CreateIfrPkgFile and not
> self.Options.CreateRecordListFile:
> + try:
> + Hpk.write(Root.Buffer)
> + except:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" %
> (self.Options.PkgOutputFileName),
> + )
> +
> + try:
> + 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:
> + EdkLogger.error(
> + "VfrCompiler",
> + FILE_WRITE_FAILURE,
> + "File write failed for %s" % (self.Options.COutputFileName),
> + )
> +
> + if not self.Options.CreateIfrPkgFile and
> self.Options.CreateRecordListFile:
> + LineBuffer = ""
> + for i in range(0, len(Root.Buffer)):
> + LineBuffer += "{:0>2X} ".format(Root.Buffer[i])
> +
> + Record = ">{:0>8X}: ".format(Root.Offset) + LineBuffer + "\n"
> + LineNo = Root.Data.GetLineNo()
> + RecordLines.append(ReCordNode(Record, LineNo))
> +
> + if Root.Child != []:
> + for ChildNode in Root.Child:
> + self._GenBinaryFilesDfs(ChildNode, Hpk, C, RecordLines)
> +
> + def GenRecordListFile(self):
> + FileName = self.Options.RecordListFileName
> + RecordLines = []
> + self._GenRecordListFileDfs(self.Root, RecordLines)
> +
> + try:
> + Out = open(FileName, "w")
> + except:
> + 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("{}\n".format(RecordLine))
> + Out.write("\nTotal Size of all record is" + "
> {:0>8x}".format(gFormPkg.Offset))
> + gVfrVarDataTypeDB.Dump(Out)
> + Out.close()
> + except:
> + EdkLogger.error(
> + "VfrCompiler", FILE_WRITE_FAILURE, "File write failed for %s" %
> FileName
> + )
> +
> + def _GenRecordListFileDfs(self, Root, RecordLines):
> + if Root == None:
> + return
> + if Root.OpCode != None:
> + LineBuffer = ""
> + if Root.Buffer != None:
> + for i in range(0, len(Root.Buffer)):
> + LineBuffer += "{:0>2X} ".format(Root.Buffer[i])
> +
> + Record = ">{:0>8X}: ".format(Root.Offset) + 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 != 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 = gVfrVarDataTypeDB.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 = gVfrDataStorage.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": {}\n'.format(pVsNode.Guid.to_string()))
> + if pVsNode.Next == None:
> + f.write("}\n")
> + else:
> + f.write("},\n")
> +
> + pVsNode = pVsNode.Next
> + f.write(" },\n")
> + f.write(' "Data" : [\n')
> + pVsNode = gVfrBufferConfig.GetVarItemList()
> + while pVsNode != None:
> + if pVsNode.Id == None:
> + pVsNode = pVsNode.Next
> + continue
> + pInfoNode = pVsNode.InfoStrList
> + while pInfoNode != None:
> + f.write("{\n")
> + f.write(' "VendorGuid":
> {},\n'.format(pVsNode.Guid.to_string()))
> + 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)))
> + if pInfoNode.Type == EFI_IFR_TYPE_DATE and
> type(pInfoNode.Value) == EFI_HII_DATE:
> + f.write(
> + ' "Value": "{}/{}/{}"\n'.format(
> + pInfoNode.Value.Year, pInfoNode.Value.Month,
> pInfoNode.Value.Day
> + )
> + )
> + elif pInfoNode.Type == EFI_IFR_TYPE_TIME and
> type(pInfoNode.Value) == EFI_HII_TIME:
> + f.write(
> + ' "Value": "{}:{}:{}"\n'.format(
> + pInfoNode.Value.Hour,
> + pInfoNode.Value.Minute,
> + pInfoNode.Value.Second,
> + )
> + )
> + elif pInfoNode.Type == EFI_IFR_TYPE_REF and
> type(pInfoNode.Value) == EFI_HII_REF:
> + f.write(
> + ' "Value": "{};{};{};{}\n'.format(
> + pInfoNode.Value.QuestionId,
> + pInfoNode.Value.FormId,
> + pInfoNode.Value.FormSetGuid.to_string(),
> + pInfoNode.Value.DevicePath,
> + )
> + )
> + else:
> + f.write(' "Value": "{}"\n'.format(pInfoNode.Value))
> +
> + 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 DumpSourceYaml(self):
> + FileName = self.Options.YamlFileName
> + try:
> + with open(FileName, "w") 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")
> + if self.PreProcessDB.VfrDict != {}:
> + Index = 0
> + for Key in self.PreProcessDB.VfrDict.keys():
> + if type(self.PreProcessDB.VfrDict[Key]) == EFI_GUID:
> + if Index == 0:
> + f.write("defines:\n")
> + f.write(f" {Key}:
> '{self.PreProcessDB.VfrDict[Key].to_string()}'\n")
> + Index = Index + 1
> + f.write("\n")
> + self._DumpYamlDfsWithUni(self.Root, f)
> + f.close()
> + except:
> + EdkLogger.error(
> + "VfrCompiler", FILE_OPEN_FAILURE, "File open failed for %s" %
> FileName, None
> + )
> +
> + def _FindIncludeHeaderFile(self, Start, Name):
> + FileList = []
> + for Relpath, Dirs, 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 _DumpQuestionInfosWithUni(self, Root, f, ValueIndent):
> + Info = Root.Data.GetInfo()
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition: '{}'\n".format(Root.Condition))
> + if Root.Data.QName != None:
> + f.write(ValueIndent + "name: {} # Optional
> Input\n".format(Root.Data.QName))
> + if Root.Data.VarIdStr != "":
> + f.write(ValueIndent + "varid: {} # Optional
> Input\n".format(Root.Data.VarIdStr))
> + if Root.Data.HasQuestionId:
> + if "questionid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "questionid: "
> + + Root.Dict["questionid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "questionid: {} # Optional Input\n".format(
> + "0x%x" % Info.Question.QuestionId
> + )
> + )
> +
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Prompt)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Help)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + ValueIndent + "flags: {} # Optional input ,
> flags\n".format(Root.Data.FlagsStream)
> + )
> + if Root.Data.HasKey:
> + if "key" in Root.Dict.keys():
> + f.write(ValueIndent + "key: " + Root.Dict["key"].Key + " # Optional
> Input\n")
> + else:
> + f.write(
> + ValueIndent
> + + "key: {} # Optional input, key\n".format("0x%0x " %
> Info.Question.QuestionId)
> + )
> +
> + def _DumpYamlDfsWithUni(self, Root, f):
> + try:
> + if Root == None:
> + return
> + if Root.OpCode != 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(ValueIndent + "guid: " +
> self.PreProcessDB.GetKey(Info.Guid) + "\n")
> + f.write(
> + ValueIndent
> + + "title: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.FormSetTitle)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Help)
> + + ")\n"
> + )
> + if Root.Data.ClassGuidNum != 0:
> + f.write(ValueIndent + "classguid: ")
> + for i in range(0, len(Root.Data.ClassGuid)):
> + if i != len(Root.Data.ClassGuid) - 1:
> + f.write(self.PreProcessDB.GetKey(Root.Data.ClassGuid[i])
> + " | ")
> + else:
> + f.write(
> + self.PreProcessDB.GetKey(Root.Data.ClassGuid[i])
> + + " # 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(ValueIndent + "type: {}\n".format(Root.Data.Type))
> + if Root.Data.HasVarStoreId:
> + if "varid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "varid: "
> + + Root.Dict["varid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "varid: {} # Optional Input\n".format(
> + "0x%04x" % (Info.VarStoreId)
> + )
> + )
> + Name = ""
> + for i in range(0, len(Info.Name)):
> + Name += chr(Info.Name[i])
> + f.write(ValueIndent + "name: {}\n".format(Name))
> + f.write(ValueIndent + "guid: " +
> self.PreProcessDB.GetKey(Info.Guid) + "\n")
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_EFI_OP:
> + f.write(KeyIndent + "- efivarstore:\n")
> + f.write(ValueIndent + "type: {}\n".format(Root.Data.Type))
> + if Root.Data.HasVarStoreId:
> + if "varid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "varid: "
> + + Root.Dict["varid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "varid: {} # Optional Input\n".format(
> + "0x%04x" % (Info.VarStoreId)
> + )
> + )
> + f.write(ValueIndent + "attribute: {}
> \n".format(Root.Data.AttributesText))
> + if Root.Data.NameStringId:
> + f.write(
> + ValueIndent
> + + "name: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Root.Data.NameStringId)
> + + ")\n"
> + )
> + f.write(ValueIndent + "varsize: " + Root.Data.VarSize + "\n")
> + else:
> + Name = ""
> + for i in range(0, len(Info.Name)):
> + Name += chr(Info.Name[i])
> + f.write(ValueIndent + "name: {}\n".format(Name))
> + f.write(ValueIndent + "guid: " +
> self.PreProcessDB.GetKey(Info.Guid) + "\n")
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_NAME_VALUE_OP:
> + f.write(KeyIndent + "- namevaluevarstore:\n")
> + f.write(ValueIndent + "type: {}\n".format(Root.Data.Type))
> + if Root.Data.HasVarStoreId:
> + if "varid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "varid: "
> + + Root.Dict["varid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "varid: {} # Optional Input\n".format(
> + "0x%04x" % (Info.VarStoreId)
> + )
> + )
> + f.write(ValueIndent + "guid: " +
> self.PreProcessDB.GetKey(Info.Guid) + "\n")
> + if Root.Data.NameItemList != []:
> + f.write(ValueIndent + "nametable: \n")
> + for i in range(0, len(Root.Data.NameItemList)):
> + f.write(
> + ValueIndent
> + + " - name: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Root.Data.NameItemList[i])
> + + ")\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(ValueIndent + "type: {}\n".format(Root.Data.Type))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.DefaultName)
> + + ")\n"
> + )
> + if Root.Data.HasAttr:
> + f.write(
> + ValueIndent
> + + "attribute: {} # Default ID, Optional input\n".format(
> + "0x%04x" % (Info.DefaultId)
> + )
> + )
> +
> + if Root.OpCode == EFI_IFR_FORM_OP:
> + f.write(KeyIndent + "- form: \n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + if "formid" in Root.Dict.keys():
> + f.write(ValueIndent + "formid: " + Root.Dict["formid"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "formid: {} \n".format("0x%x" %
> Info.FormId))
> +
> + f.write(
> + ValueIndent
> + + "title: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(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")
> + if "formid" in Root.Dict.keys():
> + f.write(ValueIndent + "formid: " + Root.Dict["formid"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "formid: {} \n".format("0x%x" %
> Info.FormId))
> +
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + if MethodMapList != []:
> + f.write(ValueIndent + "map: # optional input\n")
> + for i in range(0, len(MethodMapList)):
> + f.write(
> + ValueIndent
> + + "- maptitle: "
> + + "STRING_TOKEN("
> + +
> self.PreProcessDB.GetKey(Info.MethodMapList[i].MethodTitle)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + " mapguid: "
> + +
> self.PreProcessDB.GetKey(Info.MethodMapList[i].MethodIdentifier)
> + + "\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: IMAGE_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Id)
> + + ")\n"
> + )
> +
> + if Root.OpCode == EFI_IFR_RULE_OP: #
> + f.write(KeyIndent + "- rule:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(ValueIndent + "name:
> {}\n".format(Root.Data.GetRuleName()))
> + f.write(ValueIndent + "expression: {}
> \n".format(Root.Expression))
> +
> + if Root.OpCode == EFI_IFR_SUBTITLE_OP:
> + f.write(KeyIndent + "- subtitle:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent
> + + "text: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Statement.Prompt)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + ValueIndent
> + + "flags: {} # Optional
> Input\n".format(Root.Data.FlagsStream)
> + )
> + 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")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + if type(Info) == EFI_IFR_TEXT:
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Statement.Help)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Statement.Prompt)
> + + ")\n"
> + )
> + if Root.Data.HasTextTwo:
> + f.write(
> + ValueIndent
> + + "text: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.TextTwo)
> + + ") # Optional Input\n"
> + )
> + if type(Info) == EFI_IFR_ACTION:
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Help)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Prompt)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + ValueIndent
> + + "flags: {} # Optional Input, Question Flags\n".format(
> + Root.Data.FlagsStream
> + )
> + )
> + if Root.Data.HasKey:
> + if "key" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "key: "
> + + Root.Dict["key"].Key
> + + " # Optional Input, Question QuestionId\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "key: {} # Optional Input, Question
> QuestionId\n".format(
> + "0x%04x" % (Info.Question.QuestionId)
> + )
> + )
> + 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._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + f.write(
> + ValueIndent
> + + "config: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.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._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> +
> + if Root.Data.HasMinMax:
> + if "max" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "maximum: "
> + + Root.Dict["max"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "maximum: {} # Optional Input\n".format(
> + "0x%0x" % (Info.Data.MaxValue)
> + )
> + )
> + if "min" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "minmum: "
> + + Root.Dict["min"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "minimum: {} # Optional Input\n".format(
> + "0x%0x" % (Info.Data.MinValue)
> + )
> + )
> + if Root.Data.HasStep:
> + if "step" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "step: "
> + + Root.Dict["step"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent + "step: {} # Optional
> Input\n".format(Info.Data.Step)
> + )
> + 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 != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent
> + + "text: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Option)
> + + ")\n"
> + )
> +
> + if type(Root.Data) == IfrOneOfOption:
> + if Root.Data.ValueStream != "":
> + f.write(ValueIndent + "value:
> {}\n".format(Root.Data.ValueStream))
> +
> + if Root.Data.FlagsStream != "":
> + f.write(
> + ValueIndent
> + + "flags: {} # Optional
> Input\n".format(Root.Data.FlagsStream)
> + )
> + if Root.Data.IfrOptionKey != None:
> + if "key" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "key: "
> + + Root.Dict["key"].Key
> + + ") # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "key: {} # Optional Input\n".format(
> + "0x%04x" % (Root.Data.GetIfrOptionKey())
> + )
> + )
> + 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 != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> +
> + if type(Root.Data) == IfrDefault:
> + Str = Root.Data.ValueStream
> + if Str.find(";") != -1:
> + RefList = Str.split(";")
> + Str = (
> + RefList[0]
> + + ";"
> + + RefList[1]
> + + ";"
> + + self.PreProcessDB.GetKey(Info.Value[0].FormSetGuid)
> + + ";"
> + + "STRING_TOKEN"
> + + "("
> + + self.PreProcessDB.GetKey(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(ValueIndent + "value: {}\n".format(Str))
> +
> + elif type(Root.Data) == IfrDefault2:
> + f.write(
> + ValueIndent + "value_exp:
> '{}'\n".format(Root.Child[0].Expression)
> + )
> +
> + if Root.Data.DefaultStore != "":
> + f.write(
> + ValueIndent + "defaultstore:
> {}\n".format(Root.Data.DefaultStore)
> + )
> +
> + if Root.OpCode == EFI_IFR_ORDERED_LIST_OP:
> + f.write(KeyIndent + "- orderedlist:\n")
> + self._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + if Root.Data.HasMaxContainers:
> + if "maxcontainers" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "maxcontainers: "
> + + Root.Dict["maxcontainers"].Key
> + + ") # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "maxcontainers: {} # Optional
> Input\n".format(Info.MaxContainers)
> + )
> + 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._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + if "max" in Root.Dict.keys():
> + f.write(ValueIndent + "maximum: " + Root.Dict["max"].Key +
> "\n")
> + else:
> + f.write(
> + ValueIndent + "maximum: {} \n".format("0x%0x" %
> (Info.Data.MaxValue))
> + )
> + if "min" in Root.Dict.keys():
> + f.write(ValueIndent + "minmum: " + Root.Dict["min"].Key +
> "\n")
> + else:
> + f.write(
> + ValueIndent + "minimum: {}\n".format("0x%0x" %
> (Info.Data.MinValue))
> + )
> + if Root.Data.HasStep:
> + if "step" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "step: "
> + + Root.Dict["step"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent + "step: {} # Optional
> Input\n".format(Info.Data.Step)
> + )
> +
> + 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._DumpQuestionInfosWithUni(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 == None:
> + self._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode !=
> EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> + else:
> + f.write(ValueIndent + "hour: {}\n".format(Root.Data.Hour))
> + if Root.Data.D_Hour != None:
> + f.write(ValueIndent + "default_hour:
> {}\n".format(Root.Data.D_Hour))
> + f.write(ValueIndent + "minute:
> {}\n".format(Root.Data.Minute))
> + if Root.Data.D_Minute != None:
> + f.write(ValueIndent + "default_minute:
> {}\n".format(Root.Data.D_Minute))
> + f.write(ValueIndent + "second:
> {}\n".format(Root.Data.Second))
> + if Root.Data.D_Second != None:
> + f.write(ValueIndent + "default_second:
> {}\n".format(Root.Data.D_Second))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Prompt)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Help)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + ValueIndent
> + + "flags: {} # Optional input , flags\n".format(
> + Root.Data.FlagsStream
> + )
> + )
> + 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 == None:
> + self._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + if Root.Child != [] and Root.Child[0].OpCode !=
> EFI_IFR_END_OP:
> + f.write(ValueIndent + "component: \n")
> + else:
> + f.write(ValueIndent + "year: {}\n".format(Root.Data.Year))
> + f.write(ValueIndent + "min_year: {}\n".format(Root.Data.Min))
> + f.write(ValueIndent + "max_year:
> {}\n".format(Root.Data.Max))
> + if Root.Data.D_Year != None:
> + f.write(ValueIndent + "default_year:
> {}\n".format(Root.Data.D_Year))
> + f.write(ValueIndent + "month: " + Root.Data.Month + "\n")
> + if Root.Data.D_Month != None:
> + f.write(ValueIndent + "default_month:
> {}\n".format(Root.Data.D_Month))
> + f.write(ValueIndent + "day: " + Root.Data.Day + "\n")
> + if Root.Data.D_Day != None:
> + f.write(ValueIndent + "default_day:
> {}\n".format(Root.Data.D_Day))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Prompt)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Question.Header.Help)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(
> + ValueIndent
> + + "flags: {} # Optional input , flags\n".format(
> + Root.Data.FlagsStream
> + )
> + )
> + 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._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + if "minsize" in Root.Dict.keys():
> + f.write(ValueIndent + "minsize: " + Root.Dict["minsize"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "minsize: {} \n".format(Info.MinSize))
> + if "maxsize" in Root.Dict.keys():
> + f.write(ValueIndent + "maxsize: " + Root.Dict["maxsize"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "maxsize: {} \n".format(Info.MaxSize))
> + 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._DumpQuestionInfosWithUni(Root, f, ValueIndent)
> + if "minsize" in Root.Dict.keys():
> + f.write(ValueIndent + "minsize: " + Root.Dict["minsize"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "minsize: {} \n".format(Info.MinSize))
> + if "maxsize" in Root.Dict.keys():
> + f.write(ValueIndent + "maxsize: " + Root.Dict["maxsize"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "maxsize: {} \n".format(Info.MaxSize))
> + 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")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(ValueIndent + "defaultstore:
> {}\n".format(Root.Data.DefaultStore))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Statement.Prompt)
> + + ")\n"
> + )
> + f.write(
> + ValueIndent
> + + "help: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(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 != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> +
> + if type(Root.Data) == IfrRef4:
> + f.write(
> + ValueIndent
> + + "devicepath: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.DevicePath)
> + + ") # Optional Input\n"
> + )
> + f.write(
> + ValueIndent
> + + "formsetguid: "
> + + self.PreProcessDB.GetKey(Info.FormSetId)
> + + " # Optional Input\n"
> + )
> + if "formid" in Root.Dict.keys():
> + f.write(ValueIndent + "formid: " + Root.Dict["formid"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "formid: {}\n".format("0x%x" %
> (Info.FormId)))
> + if "questionid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "question: "
> + + Root.Dict["questionid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "question: {} # Optional Input\n".format(
> + "0x%x" % Info.QuestionId
> + )
> + )
> +
> + if type(Root.Data) == IfrRef3:
> + f.write(
> + ValueIndent
> + + "formsetguid: "
> + + self.PreProcessDB.GetKey(Info.FormSetId)
> + + " # Optional Input\n"
> + )
> + if "formid" in Root.Dict.keys():
> + f.write(ValueIndent + "formid: " + Root.Dict["formid"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "formid: {}\n".format("0x%x" %
> (Info.FormId)))
> + if "questionid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "question: "
> + + Root.Dict["questionid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "question: {} # Optional Input\n".format(
> + "0x%x" % Info.QuestionId
> + )
> + )
> +
> + if type(Root.Data) == IfrRef2:
> + if "formid" in Root.Dict.keys():
> + f.write(ValueIndent + "formid: " + Root.Dict["formid"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "formid: {}\n".format("0x%x" %
> (Info.FormId)))
> + if "questionid" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "question: "
> + + Root.Dict["questionid"].Key
> + + " # Optional Input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "question: {} # Optional Input\n".format(
> + "0x%x" % Info.QuestionId
> + )
> + )
> +
> + if type(Root.Data) == IfrRef:
> + if "formid" in Root.Dict.keys():
> + f.write(ValueIndent + "formid: " + Root.Dict["formid"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "formid: {}\n".format("0x%x" %
> (Info.FormId)))
> +
> + self._DumpQuestionInfosWithUni(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 != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + if "interval" in Root.Dict.keys():
> + f.write(ValueIndent + "interval: " + Root.Dict["interval"].Key +
> "\n")
> + else:
> + f.write(
> + ValueIndent
> + + "interval: {} #
> RefreshInterval\n".format(Info.RefreshInterval)
> + )
> +
> + if Root.OpCode == EFI_IFR_VARSTORE_DEVICE_OP:
> + f.write(KeyIndent + "- varstoredevice:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + if "devicepath" in Root.Dict.keys():
> + f.write(ValueIndent + "devicepath: " +
> Root.Dict["devicepath"].Key + "\n")
> + else:
> + f.write(
> + ValueIndent + "devicepath: {} #
> DevicePath\n".format(Info.DevicePath)
> + )
> +
> + if Root.OpCode == EFI_IFR_REFRESH_ID_OP:
> + f.write(KeyIndent + "- refreshguid:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent
> + + "guid: "
> + + self.PreProcessDB.GetKey(Info.RefreshEventGroupId)
> + + "\n"
> + )
> +
> + if Root.OpCode == EFI_IFR_WARNING_IF_OP:
> + f.write(KeyIndent + "- warningif:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Warning)
> + + ")\n"
> + )
> + if Root.Data.HasTimeOut:
> + if "timeout" in Root.Dict.keys():
> + f.write(
> + ValueIndent
> + + "timeout: "
> + + Root.Dict["timeout"].Key
> + + " # optional input\n"
> + )
> + else:
> + f.write(
> + ValueIndent
> + + "timeout: {} # optional input \n".format(Info.TimeOut)
> + )
> + f.write(ValueIndent + "expression:
> {}\n".format(Root.Expression))
> +
> + if Root.OpCode == EFI_IFR_GUID_OP:
> + if type(Root.Data) == IfrLabel:
> + f.write(KeyIndent + "- label:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + if "label" in Root.Dict.keys():
> + f.write(ValueIndent + "number: " + Root.Dict["label"].Key +
> "\n")
> + else:
> + f.write(
> + ValueIndent
> + + "number: {} # Number\n".format("0x%x" %
> (Info.Number))
> + )
> +
> + if type(Root.Data) == IfrBanner:
> + f.write(KeyIndent + "- banner:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent
> + + "title: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Title)
> + + ")\n"
> + )
> + if not Root.Data.HasTimeOut:
> + if "line" in Root.Dict.keys():
> + f.write(ValueIndent + "line: " + Root.Dict["line"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "line:
> {}\n".format(Info.LineNumber))
> + f.write(ValueIndent + "align: " + Root.Dict["align"].Key +
> "\n")
> + else:
> + f.write(ValueIndent + "timeout:
> {}\n".format(Root.Data.TimeOut))
> +
> + 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 != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent + "guid: " + self.PreProcessDB.GetKey(Info.Guid)
> + "\n"
> + )
> + if Root.Data.GetDataType() != "":
> + f.write(ValueIndent + "{}:
> \n".format(Root.Data.GetDataType()))
> + for data in Root.Data.GetFieldList():
> + f.write(
> + ValueIndent + " {}: {}\n".format(data[0], "0x%x" %
> (data[1]))
> + )
> +
> + if Root.OpCode == EFI_IFR_NO_SUBMIT_IF_OP:
> + f.write(KeyIndent + "- nosubmitif:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Error)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(ValueIndent + "flags: " + Root.Data.FlagsStream + "\n")
> + f.write(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> +
> + if Root.OpCode == EFI_IFR_READ_OP:
> + f.write(KeyIndent + "- read:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> +
> + if Root.OpCode == EFI_IFR_WRITE_OP:
> + f.write(KeyIndent + "- write:\n")
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> +
> + if Root.OpCode == EFI_IFR_VALUE_OP and Root.Parent.OpCode !=
> EFI_IFR_DEFAULT_OP: #
> + f.write(KeyIndent + "- value:\n")
> + f.write(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> +
> + if Root.OpCode == EFI_IFR_MODAL_TAG_OP:
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(KeyIndent + "- modal: null\n")
> +
> + if Root.OpCode == EFI_IFR_LOCKED_OP:
> + if Root.Condition != None:
> + f.write(ValueIndent + "condition:
> '{}'\n".format(Root.Condition))
> + f.write(KeyIndent + "- locked: null\n")
> +
> + if Root.OpCode == EFI_IFR_SUPPRESS_IF_OP:
> + f.write(KeyIndent + "- suppressif:\n")
> + f.write(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> + 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 != None:
> + f.write(KeyIndent + "- disableif:\n")
> + f.write(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> + 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(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> + 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(ValueIndent + "expression:
> '{}'\n".format(Root.Expression))
> + f.write(
> + ValueIndent
> + + "prompt: "
> + + "STRING_TOKEN("
> + + self.PreProcessDB.GetKey(Info.Error)
> + + ")\n"
> + )
> + if Root.Data.FlagsStream != "":
> + f.write(ValueIndent + "flags: " + Root.Data.FlagsStream + "\n")
> + self.LastOp = Root.OpCode
> +
> + except:
> + 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
> + 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._DumpYamlDfsWithUni(ChildNode, f)
> +
> + return
> diff --git a/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> new file mode 100644
> index 000000000000..aff6eb0815cd
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/IfrUtility.py
> @@ -0,0 +1,2238 @@
> +import ctypes
> +from VfrCompiler.IfrError import *
> +from VfrCompiler.IfrCtypes import *
> +from VfrCompiler.IfrCommon import *
> +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
> +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 VfrVarDataTypeDB(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 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
> + 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))
> + gVfrErrorHandle.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:
> + gVfrErrorHandle.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:
> + 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 == None:
> + return VfrReturnCode.VFR_RETURN_ERROR_SKIPED
> +
> + if Type == 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 == 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, f):
> + f.write("\n\n*************\n")
> + f.write("\t\tPackAlign = " + str(self.PackAlign) + "\n")
> + pNode = self.DataTypeList
> + while pNode != None:
> + f.write("\t\tstruct {} : Align : [{}] TotalSize :
> [{:#x}]\n\n".format(pNode.TypeName, pNode.Align, pNode.TotalSize))
> + # f.write('%#x\n'%(pNode.TotalSize))
> + f.write("\t\tstruct {}".format(str(pNode.TypeName)) + "\t{\n")
> + FNode = pNode.Members
> + while FNode != 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 != 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(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 VfrDefaultStore(object):
> + 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 == 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 UpdateDefaultType(self, DefaultNode):
> + pNode = self.DefaultStoreList
> + while pNode != 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 != 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
> + 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 != 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
> + self.Guid = Guid
> + self.Id = 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):
> + self.Type = Type
> + self.Offset = Offset
> + self.Width = Width
> + self.Next = None
> + self.Value = Value
> +
> +
> +class VfrBufferConfig(object):
> + __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 == 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):
> + 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 == 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":
> + 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 != 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(object):
> + 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 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 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 != 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_BUFF
> ER)
> + 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 gVfrBufferConfig.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_NAM
> E)
> + 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 VfrStringDB(object):
> + 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(ctypes.c_ushort)
> + StringStr = cast(StringSrc, POINTER(ctypes.c_ushort))
> +
> + while StringStr.contents.value != "\0":
> + StringSize += sizeof(ctypes.c_ushort)
> + StringStr = cast(addressof(StringStr.contents) +
> sizeof(ctypes.c_ushort), POINTER(ctypes.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(ctypes.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(ctypes.c_uint16)],
> + byteorder="little",
> + )
> + string_text_ptr = block_hdr +
> sizeof(EFI_HII_SIBT_STRINGS_SCSU_BLOCK) - sizeof(ctypes.c_uint8)
> + block_size += string_text_ptr - block_hdr
> +
> + for index 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(ctypes.c_uint8) : sizeof(EFI_HII_STRING_BLOCK) + sizeof(ctypes.c_uint8)
> + sizeof(ctypes.c_uint16)],
> + byteorder="little",
> + )
> + string_text_ptr = block_hdr +
> sizeof(EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK) - sizeof(ctypes.c_uint8)
> + block_size += string_text_ptr - block_hdr
> +
> + for index 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(ctypes.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(ctypes.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(ctypes.c_uint16)],
> + byteorder="little",
> + )
> +
> + for index 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(ctypes.c_ushort)
> + string_text_ptr = block_hdr + offset
> + block_size += offset
> + string_count = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) +
> sizeof(ctypes.c_uint8) : sizeof(EFI_HII_STRING_BLOCK) + sizeof(ctypes.c_uint8)
> + sizeof(ctypes.c_uint16)],
> + byteorder="little",
> + )
> +
> + for index 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(ctypes.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(ctypes.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(ctypes.c_uint8) : sizeof(EFI_HII_STRING_BLOCK) + sizeof(ctypes.c_uint8)
> + sizeof(ctypes.c_uint8)],
> + byteorder="little",
> + )
> + block_size += length8
> +
> + elif block_type == EFI_HII_SIBT_EXT2:
> + ext2 = EFI_HII_SIBT_EXT2
> + length32 = int.from_bytes(
> + block_hdr[sizeof(EFI_HII_STRING_BLOCK) +
> sizeof(ctypes.c_uint8) : sizeof(EFI_HII_STRING_BLOCK) + sizeof(ctypes.c_uint8)
> + sizeof(ctypes.c_uint32)],
> + byteorder="little",
> + )
> + block_size += length32
> +
> + if string_id > 0 and string_id != (ctypes.c_uint16)(-1):
> + string_text_offset = block_hdr - string_data + offset
> + block_type = block_hdr[0]
> +
> + if string_id == current_string_id - 1:
> + if block_type == EFI_HII_SIBT_SKIP2 or block_type ==
> EFI_HII_SIBT_SKIP1:
> + return EFI_NOT_FOUND
> + else:
> + 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
> + LineBuf = [0] * EFI_IFR_MAX_LENGTH
> + BlockType = 0
> + PkgHeader = None
> +
> + if self.StringFileName is None:
> + return None
> +
> + try:
> + pInFile = open(LongFilePath(self.StringFileName), "rb")
> + # 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:
> + if pInFile is not None:
> + pInFile.close()
> + 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(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 VfrQuestionDB(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, gFormPkg):
> + 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
> +
> + 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) == 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
> + 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 != 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,
> gFormPkg):
> + 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]
> +
> + 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 == 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]
> +
> + 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 == 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]
> +
> + 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 == 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]
> +
> + 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 == 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]
> +
> + 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 != 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 000000000000..c79e5ac5c17b
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/ReadMe.md
> @@ -0,0 +1,47 @@
> +# 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/VfrCo
> mpile.
> +
> +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, the 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 contents in the Vfr file.
> +
> +### Known issues
> +
> +- The current YAML format is a reference version, and we warmly welcome
> everyone to provide feedback.
> +- 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. 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. 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;%BA
> SE_TOOLS_PATH%\Source\Python\VfrCompiler
> + @%PYTHON_COMMAND% -m %ToolName% %*
> + ```
> +4. Add Env:
> +
> +- run `pip install CppHeaderParser` based on the original build environment.
> +- run `pip install pyyaml` based on the original build environment.
> +- run `pip install antlr4-python3-runtime==4.7` based on the original build
> environment.
> +
> +5. Build the platform:
> +
> +- Run env setting command: `edksetup.bat rebuild`
> +- 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 000000000000..63a6ebcf8e96
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntax.g4
> @@ -0,0 +1,1913 @@
> +grammar VfrSyntax;
> +options {
> + language=Python;
> +}
> +@header{
> +
> +from IfrCtypes import *
> +from IfrFormPkg import *
> +from IfrUtility import *
> +from IfrTree 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(E
> FI_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
> + ;
> \ No newline at end of file
> diff --git a/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> new file mode 100644
> index 000000000000..e99348b7add0
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxLexer.py
> @@ -0,0 +1,1709 @@
> +# Generated from VfrSyntax.g4 by ANTLR 4.7.2
> +from antlr4 import *
> +from io import StringIO
> +from typing.io import TextIO
> +import sys
> +
> +
> +
> +from IfrCtypes import *
> +from IfrFormPkg import *
> +from IfrUtility import *
> +from IfrTree import *
> +
> +
> +
> +def serializedATN():
> + with StringIO() as buf:
> +
> buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u01
> 02")
> + 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\3
> N\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\3
> W\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\u00b
> b")
> +
> buf.write("\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00b
> c")
> +
> 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\u00b
> d")
> +
> buf.write("\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00b
> e")
> +
> 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\u00
> a5")
> +
> buf.write("T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00
> b5")
> +
> 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\u00e
> 5")
> +
> 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\u01d
> d")
> +
> 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\u02
> ab")
> +
> 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\u038
> d")
> +
> 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\u03e
> a")
> +
> 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\u045
> 4")
> +
> 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\u051
> 6")
> +
> 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\u064
> b")
> +
> 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\u06b
> d")
> +
> 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\u071
> a")
> +
> 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\u07b
> 2")
> +
> 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\u088
> 9")
> +
> 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\u08d
> 6")
> +
> 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\u098
> 9")
> +
> 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\u020
> b")
> +
> 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\u021
> 4")
> +
> 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\u022
> 9")
> +
> 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\u022
> f")
> +
> buf.write("\7T\2\2\u022f\u0230\7K\2\2\u0230\u0231\7\\\2\2\u0231\u023
> 2")
> +
> buf.write("\7Q\2\2\u0232\u0233\7P\2\2\u0233\u0234\7V\2\2\u0234\u023
> 5")
> +
> 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\u02
> 3b")
> +
> 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\u02b
> 6")
> +
> buf.write("\u02b7\7o\2\2\u02b7\u02b8\7u\2\2\u02b8\u02b9\7g\2\2\u02b
> 9")
> +
> 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\u02d
> a")
> +
> 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\u033
> 7")
> +
> 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\u034
> 3")
> +
> 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\u036
> 4")
> +
> 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\u036
> d")
> +
> 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\u037
> 3")
> +
> 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\u037
> 9")
> +
> 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\u038
> 2")
> +
> 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\u038
> 8")
> +
> 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\u038
> e")
> +
> 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\u039
> 4")
> +
> 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\u03a
> 3")
> +
> buf.write("\u03a4\7h\2\2\u03a4\u0094\3\2\2\2\u03a5\u03a6\7n\2\2\u03a
> 6")
> +
> 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\u03a
> c")
> +
> 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\u03b
> 2")
> +
> buf.write("\u0098\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4\u03b5\7p\2\2\u03
> b5")
> +
> buf.write("\u03b6\7x\2\2\u03b6\u03b7\7g\2\2\u03b7\u03b8\7p\2\2\u03b
> 8")
> +
> buf.write("\u03b9\7v\2\2\u03b9\u03ba\7q\2\2\u03ba\u03bb\7t\2\2\u03b
> b")
> +
> buf.write("\u03bc\7{\2\2\u03bc\u009a\3\2\2\2\u03bd\u03be\7a\2\2\u03b
> e")
> +
> 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\u03d
> 3")
> +
> buf.write("\u03d4\7v\2\2\u03d4\u009e\3\2\2\2\u03d5\u03d6\7w\2\2\u03
> d6")
> +
> buf.write("\u03d7\7p\2\2\u03d7\u03d8\7k\2\2\u03d8\u03d9\7q\2\2\u03d
> 9")
> +
> buf.write("\u03da\7p\2\2\u03da\u00a0\3\2\2\2\u03db\u03dc\7D\2\2\u03
> dc")
> +
> buf.write("\u03dd\7Q\2\2\u03dd\u03de\7Q\2\2\u03de\u03df\7N\2\2\u03
> df")
> +
> buf.write("\u03e0\7G\2\2\u03e0\u03e1\7C\2\2\u03e1\u03e2\7P\2\2\u03e
> 2")
> +
> buf.write("\u00a2\3\2\2\2\u03e3\u03e4\7W\2\2\u03e4\u03e5\7K\2\2\u03
> e5")
> +
> 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\u040
> 2")
> +
> buf.write("\u0403\7U\2\2\u0403\u0404\7V\2\2\u0404\u0405\7T\2\2\u040
> 5")
> +
> 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\u040
> e")
> +
> 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\u04
> 1a")
> +
> buf.write("\u041b\7H\2\2\u041b\u041c\7K\2\2\u041c\u041d\7a\2\2\u041
> d")
> +
> 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\u04
> 26")
> +
> buf.write("\u0427\7G\2\2\u0427\u0428\7H\2\2\u0428\u0429\7K\2\2\u042
> 9")
> +
> 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\u04
> 32")
> +
> 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\u043
> 8")
> +
> 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\u043
> e")
> +
> 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\u044
> a")
> +
> buf.write("\u044b\7z\2\2\u044b\u00b8\3\2\2\2\u044c\u044d\7p\2\2\u044
> d")
> +
> 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\u045
> 6")
> +
> 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\u045
> f")
> +
> 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\u046
> 5")
> +
> buf.write("\u0466\7o\2\2\u0466\u00be\3\2\2\2\u0467\u0468\7o\2\2\u046
> 8")
> +
> 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\u046
> e")
> +
> buf.write("\u00c0\3\2\2\2\u046f\u0470\7u\2\2\u0470\u0471\7v\2\2\u047
> 1")
> +
> buf.write("\u0472\7g\2\2\u0472\u0473\7r\2\2\u0473\u00c2\3\2\2\2\u047
> 4")
> +
> 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\u047
> a")
> +
> buf.write("\u047b\7v\2\2\u047b\u00c4\3\2\2\2\u047c\u047d\7r\2\2\u047
> d")
> +
> 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\u049
> 2")
> +
> 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\u04a
> 4")
> +
> 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\u04a
> a")
> +
> 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\u04b
> 3")
> +
> buf.write("\u04b4\7p\2\2\u04b4\u04b5\7e\2\2\u04b5\u04b6\7q\2\2\u04b
> 6")
> +
> 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\u04b
> c")
> +
> 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\u04
> d7")
> +
> 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\u04
> dd")
> +
> 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\u04e
> 9")
> +
> 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\u050
> 4")
> +
> buf.write("\u0505\7w\2\2\u0505\u0506\7d\2\2\u0506\u0507\7o\2\2\u050
> 7")
> +
> 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\u050
> d")
> +
> 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\u05
> 13")
> +
> buf.write("\u0514\7g\2\2\u0514\u0515\7{\2\2\u0515\u00e6\3\2\2\2\u051
> 6")
> +
> buf.write("\u0517\7F\2\2\u0517\u0518\7G\2\2\u0518\u0519\7H\2\2\u051
> 9")
> +
> buf.write("\u051a\7C\2\2\u051a\u051b\7W\2\2\u051b\u051c\7N\2\2\u051
> c")
> +
> buf.write("\u051d\7V\2\2\u051d\u00e8\3\2\2\2\u051e\u051f\7O\2\2\u051
> f")
> +
> buf.write("\u0520\7C\2\2\u0520\u0521\7P\2\2\u0521\u0522\7W\2\2\u052
> 2")
> +
> buf.write("\u0523\7H\2\2\u0523\u0524\7C\2\2\u0524\u0525\7E\2\2\u052
> 5")
> +
> buf.write("\u0526\7V\2\2\u0526\u0527\7W\2\2\u0527\u0528\7T\2\2\u052
> 8")
> +
> 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\u052
> e")
> +
> buf.write("\u052f\7G\2\2\u052f\u0530\7E\2\2\u0530\u0531\7M\2\2\u053
> 1")
> +
> buf.write("\u0532\7D\2\2\u0532\u0533\7Q\2\2\u0533\u0534\7Z\2\2\u053
> 4")
> +
> 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\u053
> a")
> +
> buf.write("\u053b\7N\2\2\u053b\u053c\7V\2\2\u053c\u00ec\3\2\2\2\u053
> d")
> +
> 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\u054
> 3")
> +
> buf.write("\u0544\7Q\2\2\u0544\u0545\7Z\2\2\u0545\u0546\7a\2\2\u054
> 6")
> +
> buf.write("\u0547\7F\2\2\u0547\u0548\7G\2\2\u0548\u0549\7H\2\2\u054
> 9")
> +
> buf.write("\u054a\7C\2\2\u054a\u054b\7W\2\2\u054b\u054c\7N\2\2\u054
> c")
> +
> 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\u055
> 2")
> +
> 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\u055
> 8")
> +
> buf.write("\u0559\7E\2\2\u0559\u055a\7V\2\2\u055a\u055b\7K\2\2\u055
> b")
> +
> buf.write("\u055c\7X\2\2\u055c\u055d\7G\2\2\u055d\u00f0\3\2\2\2\u055
> e")
> +
> 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\u056
> 7")
> +
> buf.write("\u00f2\3\2\2\2\u0568\u0569\7T\2\2\u0569\u056a\7G\2\2\u056
> a")
> +
> buf.write("\u056b\7U\2\2\u056b\u056c\7G\2\2\u056c\u056d\7V\2\2\u056
> d")
> +
> 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\u057
> 3")
> +
> 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\u057
> 9")
> +
> 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\u058
> 5")
> +
> buf.write("\u0586\7K\2\2\u0586\u0587\7T\2\2\u0587\u0588\7G\2\2\u058
> 8")
> +
> buf.write("\u0589\7F\2\2\u0589\u00f6\3\2\2\2\u058a\u058b\7N\2\2\u058
> b")
> +
> buf.write("\u058c\7C\2\2\u058c\u058d\7V\2\2\u058d\u058e\7G\2\2\u058
> e")
> +
> 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\u059
> 4")
> +
> buf.write("\u00f8\3\2\2\2\u0595\u0596\7T\2\2\u0596\u0597\7G\2\2\u059
> 7")
> +
> 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\u059
> d")
> +
> 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\u05a
> 3")
> +
> buf.write("\u05a4\7Q\2\2\u05a4\u05a5\7P\2\2\u05a5\u05a6\7U\2\2\u05a
> 6")
> +
> buf.write("\u05a7\7a\2\2\u05a7\u05a8\7Q\2\2\u05a8\u05a9\7P\2\2\u05a
> 9")
> +
> 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\u05b
> 2")
> +
> buf.write("\u05b3\7V\2\2\u05b3\u05b4\7[\2\2\u05b4\u05b5\7N\2\2\u05b
> 5")
> +
> buf.write("\u05b6\7G\2\2\u05b6\u00fe\3\2\2\2\u05b7\u05b8\7e\2\2\u05b
> 8")
> +
> buf.write("\u05b9\7n\2\2\u05b9\u05ba\7c\2\2\u05ba\u05bb\7u\2\2\u05b
> b")
> +
> buf.write("\u05bc\7u\2\2\u05bc\u0100\3\2\2\2\u05bd\u05be\7u\2\2\u05b
> e")
> +
> 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\u05d
> 9")
> +
> buf.write("\u05da\7g\2\2\u05da\u05db\7u\2\2\u05db\u05dc\7v\2\2\u05d
> c")
> +
> 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\u05e
> 2")
> +
> buf.write("\u05e3\7x\2\2\u05e3\u05e4\7g\2\2\u05e4\u010a\3\2\2\2\u05e
> 5")
> +
> 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\u05e
> b")
> +
> buf.write("\u05ec\7v\2\2\u05ec\u05ed\7u\2\2\u05ed\u010c\3\2\2\2\u05e
> e")
> +
> 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\u061
> 2")
> +
> 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\u061
> 8")
> +
> 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\u062
> 7")
> +
> buf.write("\u0628\7w\2\2\u0628\u0629\7g\2\2\u0629\u062a\7u\2\2\u062
> a")
> +
> 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\u063
> 3")
> +
> 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\u063
> 9")
> +
> buf.write("\u063a\7e\2\2\u063a\u063b\7m\2\2\u063b\u063c\7g\2\2\u063
> c")
> +
> 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\u064
> 2")
> +
> buf.write("\u0126\3\2\2\2\u0643\u0644\7g\2\2\u0644\u0645\7p\2\2\u064
> 5")
> +
> 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\u064
> b")
> +
> 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\u065
> 1")
> +
> 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\u065
> d")
> +
> 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\u066
> 3")
> +
> 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\u066
> 9")
> +
> 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\u067
> 2")
> +
> 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\u067
> 8")
> +
> 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\u067
> e")
> +
> 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\u068
> 4")
> +
> 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\u068
> d")
> +
> 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\u069
> 9")
> +
> 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\u06a
> 5")
> +
> 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\u06a
> b")
> +
> 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\u06b
> 4")
> +
> 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\u06b
> a")
> +
> buf.write("\u06bb\7t\2\2\u06bb\u06bc\7g\2\2\u06bc\u013e\3\2\2\2\u06b
> d")
> +
> 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\u06d
> 2")
> +
> buf.write("\u06d3\7q\2\2\u06d3\u06d4\7p\2\2\u06d4\u0144\3\2\2\2\u06
> d5")
> +
> 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\u06d
> b")
> +
> buf.write("\u06dc\7j\2\2\u06dc\u0146\3\2\2\2\u06dd\u06de\7k\2\2\u06d
> e")
> +
> 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\u06e
> 7")
> +
> 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\u070
> 8")
> +
> 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\u071
> 4")
> +
> 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\u071
> a")
> +
> buf.write("\u071b\7P\2\2\u071b\u071c\7Q\2\2\u071c\u071d\7P\2\2\u071
> d")
> +
> 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\u072
> 6")
> +
> buf.write("\u0727\7K\2\2\u0727\u0728\7U\2\2\u0728\u0729\7M\2\2\u072
> 9")
> +
> 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\u073
> 2")
> +
> 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\u073
> 8")
> +
> buf.write("\u0739\7G\2\2\u0739\u073a\7X\2\2\u073a\u073b\7K\2\2\u073
> b")
> +
> buf.write("\u073c\7E\2\2\u073c\u073d\7G\2\2\u073d\u015a\3\2\2\2\u073
> e")
> +
> 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\u074
> 4")
> +
> buf.write("\u0745\7M\2\2\u0745\u0746\7a\2\2\u0746\u0747\7F\2\2\u074
> 7")
> +
> buf.write("\u0748\7G\2\2\u0748\u0749\7X\2\2\u0749\u074a\7K\2\2\u074
> a")
> +
> buf.write("\u074b\7E\2\2\u074b\u074c\7G\2\2\u074c\u015c\3\2\2\2\u074
> d")
> +
> 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\u075
> 3")
> +
> 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\u075
> 9")
> +
> buf.write("\u015e\3\2\2\2\u075a\u075b\7Q\2\2\u075b\u075c\7P\2\2\u075
> c")
> +
> 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\u076
> 8")
> +
> buf.write("\u0160\3\2\2\2\u0769\u076a\7Q\2\2\u076a\u076b\7V\2\2\u07
> 6b")
> +
> 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\u07
> 77")
> +
> buf.write("\u0778\7G\2\2\u0778\u0779\7V\2\2\u0779\u077a\7W\2\2\u07
> 7a")
> +
> 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\u078
> 6")
> +
> buf.write("\u0787\7P\2\2\u0787\u0164\3\2\2\2\u0788\u0789\7I\2\2\u078
> 9")
> +
> buf.write("\u078a\7G\2\2\u078a\u078b\7P\2\2\u078b\u078c\7G\2\2\u078
> c")
> +
> 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\u079
> 5")
> +
> buf.write("\u0796\7E\2\2\u0796\u0797\7C\2\2\u0797\u0798\7V\2\2\u079
> 8")
> +
> buf.write("\u0799\7K\2\2\u0799\u079a\7Q\2\2\u079a\u079b\7P\2\2\u079
> b")
> +
> buf.write("\u0166\3\2\2\2\u079c\u079d\7H\2\2\u079d\u079e\7T\2\2\u079
> e")
> +
> 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\u07a
> 7")
> +
> buf.write("\u07a8\7U\2\2\u07a8\u07a9\7K\2\2\u07a9\u07aa\7P\2\2\u07a
> a")
> +
> 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\u07b
> 0")
> +
> buf.write("\u07b1\7G\2\2\u07b1\u016a\3\2\2\2\u07b2\u07b3\7[\2\2\u07b
> 3")
> +
> buf.write("\u07b4\7G\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7T\2\2\u07b
> 6")
> +
> buf.write("\u07b7\7a\2\2\u07b7\u07b8\7U\2\2\u07b8\u07b9\7W\2\2\u07
> b9")
> +
> buf.write("\u07ba\7R\2\2\u07ba\u07bb\7R\2\2\u07bb\u07bc\7T\2\2\u07b
> c")
> +
> buf.write("\u07bd\7G\2\2\u07bd\u07be\7U\2\2\u07be\u07bf\7U\2\2\u07b
> f")
> +
> buf.write("\u016c\3\2\2\2\u07c0\u07c1\7O\2\2\u07c1\u07c2\7Q\2\2\u07c
> 2")
> +
> 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\u07d
> 1")
> +
> buf.write("\u07d2\7[\2\2\u07d2\u07d3\7a\2\2\u07d3\u07d4\7U\2\2\u07d
> 4")
> +
> buf.write("\u07d5\7W\2\2\u07d5\u07d6\7R\2\2\u07d6\u07d7\7R\2\2\u07
> d7")
> +
> buf.write("\u07d8\7T\2\2\u07d8\u07d9\7G\2\2\u07d9\u07da\7U\2\2\u07d
> a")
> +
> buf.write("\u07db\7U\2\2\u07db\u0170\3\2\2\2\u07dc\u07dd\7J\2\2\u07
> dd")
> +
> buf.write("\u07de\7Q\2\2\u07de\u07df\7W\2\2\u07df\u07e0\7T\2\2\u07e
> 0")
> +
> buf.write("\u07e1\7a\2\2\u07e1\u07e2\7U\2\2\u07e2\u07e3\7W\2\2\u07e
> 3")
> +
> 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\u07e
> 9")
> +
> buf.write("\u0172\3\2\2\2\u07ea\u07eb\7O\2\2\u07eb\u07ec\7K\2\2\u07e
> c")
> +
> buf.write("\u07ed\7P\2\2\u07ed\u07ee\7W\2\2\u07ee\u07ef\7V\2\2\u07e
> f")
> +
> 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\u080
> 4")
> +
> buf.write("\u0805\7R\2\2\u0805\u0806\7T\2\2\u0806\u0807\7G\2\2\u080
> 7")
> +
> buf.write("\u0808\7U\2\2\u0808\u0809\7U\2\2\u0809\u0176\3\2\2\2\u08
> 0a")
> +
> buf.write("\u080b\7U\2\2\u080b\u080c\7V\2\2\u080c\u080d\7Q\2\2\u080
> d")
> +
> 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\u081
> 3")
> +
> buf.write("\u0814\7Q\2\2\u0814\u0815\7T\2\2\u0815\u0816\7O\2\2\u081
> 6")
> +
> buf.write("\u0817\7C\2\2\u0817\u0818\7N\2\2\u0818\u0178\3\2\2\2\u081
> 9")
> +
> buf.write("\u081a\7U\2\2\u081a\u081b\7V\2\2\u081b\u081c\7Q\2\2\u081
> c")
> +
> 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\u082
> 2")
> +
> buf.write("\u0823\7K\2\2\u0823\u0824\7O\2\2\u0824\u0825\7G\2\2\u082
> 5")
> +
> buf.write("\u017a\3\2\2\2\u0826\u0827\7U\2\2\u0827\u0828\7V\2\2\u08
> 28")
> +
> buf.write("\u0829\7Q\2\2\u0829\u082a\7T\2\2\u082a\u082b\7C\2\2\u082
> b")
> +
> 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\u083
> 4")
> +
> buf.write("\u017c\3\2\2\2\u0835\u0836\7W\2\2\u0836\u0837\7P\2\2\u08
> 37")
> +
> buf.write("\u0838\7K\2\2\u0838\u0839\7S\2\2\u0839\u083a\7W\2\2\u083
> a")
> +
> buf.write("\u083b\7G\2\2\u083b\u017e\3\2\2\2\u083c\u083d\7P\2\2\u083
> d")
> +
> buf.write("\u083e\7Q\2\2\u083e\u083f\7G\2\2\u083f\u0840\7O\2\2\u084
> 0")
> +
> 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\u084
> 6")
> +
> buf.write("\u0847\7p\2\2\u0847\u0848\7f\2\2\u0848\u0182\3\2\2\2\u084
> 9")
> +
> 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\u085
> 2")
> +
> buf.write("\u0853\7v\2\2\u0853\u0854\7q\2\2\u0854\u0855\7m\2\2\u085
> 5")
> +
> buf.write("\u0856\7g\2\2\u0856\u0857\7p\2\2\u0857\u0188\3\2\2\2\u085
> 8")
> +
> 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\u085
> e")
> +
> 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\u086
> a")
> +
> 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\u087
> 6")
> +
> 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\u088
> b")
> +
> 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\u089
> 7")
> +
> 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\u089
> d")
> +
> 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\u08a
> 9")
> +
> 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\u08
> b2")
> +
> buf.write("\u08b3\7e\2\2\u08b3\u08b4\7w\2\2\u08b4\u08b5\7t\2\2\u08b
> 5")
> +
> 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\u08b
> b")
> +
> buf.write("\u08bc\7v\2\2\u08bc\u01a2\3\2\2\2\u08bd\u08be\7V\2\2\u08b
> e")
> +
> 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\u08c
> 4")
> +
> 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\u08c
> a")
> +
> buf.write("\u08cb\7G\2\2\u08cb\u01a8\3\2\2\2\u08cc\u08cd\7Q\2\2\u08c
> d")
> +
> 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\u08d
> c")
> +
> buf.write("\7K\2\2\u08dc\u08dd\7P\2\2\u08dd\u08de\7G\2\2\u08de\u08d
> f")
> +
> buf.write("\7F\2\2\u08df\u01ae\3\2\2\2\u08e0\u08e1\7X\2\2\u08e1\u08e
> 2")
> +
> buf.write("\7G\2\2\u08e2\u08e3\7T\2\2\u08e3\u08e4\7U\2\2\u08e4\u08e
> 5")
> +
> buf.write("\7K\2\2\u08e5\u08e6\7Q\2\2\u08e6\u08e7\7P\2\2\u08e7\u01b
> 0")
> +
> buf.write("\3\2\2\2\u08e8\u08e9\7n\2\2\u08e9\u08ea\7g\2\2\u08ea\u08e
> b")
> +
> 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\u090
> 2")
> +
> 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\u090
> 8")
> +
> 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\u091
> 4")
> +
> 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\u091
> d")
> +
> 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\u094
> 4")
> +
> 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\u095
> 3")
> +
> 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\u095
> f")
> +
> 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\u096
> e")
> +
> 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\u097
> 7")
> +
> buf.write("\7M\2\2\u0977\u0978\7G\2\2\u0978\u0979\7P\2\2\u0979\u01d
> 6")
> +
> buf.write("\3\2\2\2\u097a\u097b\7Q\2\2\u097b\u097c\7R\2\2\u097c\u097
> d")
> +
> 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\u098
> 6")
> +
> buf.write("\7W\2\2\u0986\u0987\7N\2\2\u0987\u0988\7V\2\2\u0988\u01
> d8")
> +
> buf.write("\3\2\2\2\u0989\u098a\7Q\2\2\u098a\u098b\7R\2\2\u098b\u09
> 8c")
> +
> 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\u099
> 5")
> +
> buf.write("\7W\2\2\u0995\u0996\7N\2\2\u0996\u0997\7V\2\2\u0997\u09
> 98")
> +
> buf.write("\7a\2\2\u0998\u0999\7O\2\2\u0999\u099a\7H\2\2\u099a\u099
> b")
> +
> buf.write("\7I\2\2\u099b\u01da\3\2\2\2\u099c\u099d\7P\2\2\u099d\u099
> e")
> +
> buf.write("\7W\2\2\u099e\u099f\7O\2\2\u099f\u09a0\7G\2\2\u09a0\u09a
> 1")
> +
> 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\u09a
> 7")
> +
> buf.write("\7\\\2\2\u09a7\u09a8\7G\2\2\u09a8\u09a9\7a\2\2\u09a9\u09a
> a")
> +
> 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\u09
> af")
> +
> buf.write("\u09b0\7T\2\2\u09b0\u09b1\7K\2\2\u09b1\u09b2\7E\2\2\u09b
> 2")
> +
> buf.write("\u09b3\7a\2\2\u09b3\u09b4\7U\2\2\u09b4\u09b5\7K\2\2\u09b
> 5")
> +
> buf.write("\u09b6\7\\\2\2\u09b6\u09b7\7G\2\2\u09b7\u09b8\7a\2\2\u09
> b8")
> +
> 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\u09d
> 2")
> +
> buf.write("\u09d3\7K\2\2\u09d3\u09d4\7\\\2\2\u09d4\u09d5\7G\2\2\u09
> d5")
> +
> buf.write("\u09d6\7a\2\2\u09d6\u09d7\7:\2\2\u09d7\u01e2\3\2\2\2\u09d
> 8")
> +
> buf.write("\u09d9\7F\2\2\u09d9\u09da\7K\2\2\u09da\u09db\7U\2\2\u09d
> b")
> +
> buf.write("\u09dc\7R\2\2\u09dc\u09dd\7N\2\2\u09dd\u09de\7C\2\2\u09d
> e")
> +
> 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\u09e
> a")
> +
> buf.write("\u09eb\7U\2\2\u09eb\u09ec\7R\2\2\u09ec\u09ed\7N\2\2\u09e
> d")
> +
> 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\u0a0
> 2")
> +
> 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\u0a0
> b")
> +
> buf.write("\u0a0c\7P\2\2\u0a0c\u0a0d\7U\2\2\u0a0d\u0a0e\7G\2\2\u0a0
> e")
> +
> 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\u0a
> 17")
> +
> buf.write("\u0a18\7G\2\2\u0a18\u0a19\7P\2\2\u0a19\u0a1a\7U\2\2\u0a1
> a")
> +
> 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\u0a2
> 3")
> +
> 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\u0a2
> 9")
> +
> buf.write("\u0a2a\7O\2\2\u0a2a\u0a2b\7C\2\2\u0a2b\u0a2c\7V\2\2\u0a2
> c")
> +
> buf.write("\u0a2d\7E\2\2\u0a2d\u0a2e\7J\2\2\u0a2e\u01ee\3\2\2\2\u0a2
> f")
> +
> buf.write("\u0a30\7H\2\2\u0a30\u0a31\7K\2\2\u0a31\u0a32\7T\2\2\u0a3
> 2")
> +
> buf.write("\u0a33\7U\2\2\u0a33\u0a34\7V\2\2\u0a34\u0a35\7a\2\2\u0a3
> 5")
> +
> buf.write("\u0a36\7P\2\2\u0a36\u0a37\7Q\2\2\u0a37\u0a38\7P\2\2\u0a3
> 8")
> +
> buf.write("\u0a39\7a\2\2\u0a39\u0a3a\7O\2\2\u0a3a\u0a3b\7C\2\2\u0a3
> b")
> +
> 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\u0a4
> 6")
> +
> 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\u0a7
> 8")
> +
> 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\u0a8
> c")
> +
> 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\u0a9
> c")
> + 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\u0aa
> b")
> +
> 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 000000000000..4a78c395cd40
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxParser.py
> @@ -0,0 +1,20480 @@
> +# Generated from VfrSyntax.g4 by ANTLR 4.7.2
> +# encoding: utf-8
> +from antlr4 import *
> +from io import StringIO
> +from typing.io import TextIO
> +import sys
> +
> +import os
> +sys.path.append(os.path.dirname(os.path.abspath(__file__)))
> +
> +from IfrCtypes import *
> +from IfrFormPkg import *
> +from IfrUtility import *
> +from IfrTree import *
> +
> +
> +def serializedATN():
> + with StringIO() as buf:
> +
> buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u01
> 02")
> + 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#\u034
> 3")
> +
> 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\u050
> c")
> +
> 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\u0
> 5ac")
> +
> 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\u
> 0603")
> +
> 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\u00a
> 3")
> +
> 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\u00b
> e")
> +
> 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\u03b
> 8")
> +
> 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\u058
> 1")
> +
> 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\u070
> 4")
> +
> 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\u087
> b")
> +
> 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\u095
> 9")
> +
> 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\u0a5
> 0")
> +
> 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\u0ab
> d")
> +
> 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\u0b5
> a")
> +
> 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\u00
> 84")
> +
> 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\u01
> d2")
> +
> 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\u01e
> 2")
> +
> 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\u01e
> 9")
> +
> 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\u020
> c")
> + 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\u028
> 8")
> +
> 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\u02c
> 1")
> +
> 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\u00f
> a")
> +
> 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\u037
> 2")
> +
> 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\u008
> e")
> +
> 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\u03a
> 9")
> +
> 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\u03b
> 2")
> +
> 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\u03d
> c")
> +
> 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\u041
> e")
> +
> 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\u042
> a")
> +
> 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\u043
> b")
> +
> 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\u04
> 51")
> +
> 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\u045
> e")
> +
> 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\u049
> f")
> +
> 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\u04a
> c")
> +
> 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\u04b
> 3")
> + 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\u04d
> 5")
> +
> buf.write("\7!\2\2\u04d5\u04d6\7/\2\2\u04d6\u04d7\7\b\2\2\u04d7\u04d
> 8")
> +
> 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\u04d
> d")
> +
> 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\u00f
> b")
> +
> 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\u05
> 30")
> +
> 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\u053
> 4")
> +
> 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\u05
> 40")
> +
> 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\u054
> 0")
> +
> 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\u055
> 6")
> +
> 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\u009
> 3")
> +
> buf.write("\3\2\2\2\u0574\u0575\7\u00a6\2\2\u0575\u0576\7\b\2\2\u057
> 6")
> +
> 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\u05
> 8b")
> +
> 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\u059
> d")
> +
> 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\u05a
> 4")
> +
> 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\u05b
> 3")
> +
> 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\u05b
> f")
> + 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\u060
> b")
> + 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\u061
> 8")
> +
> 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\u009
> 3")
> + 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\u06
> 32")
> +
> 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\u06
> 34")
> +
> 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\u06
> 3e")
> +
> 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\u067
> e")
> +
> 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\u06
> 88")
> +
> 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\u069
> a")
> +
> 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\u06a
> b")
> +
> 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\u06b
> 7")
> +
> 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\u06d
> e")
> +
> 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\u06e
> 3")
> +
> 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\u073
> 8")
> +
> 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\u00c
> 0")
> +
> buf.write("\2\2\u0752\u0755\7\u00c1\2\2\u0753\u0755\5V,\2\u0754\u075
> 0")
> +
> 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\u075
> d")
> +
> 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\u077
> b")
> +
> 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\u079
> 2")
> +
> 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\u07b
> 4")
> + 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\u07b
> c")
> +
> 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\u084
> 0")
> +
> buf.write("\7!\2\2\u083c\u083d\7b\2\2\u083d\u083e\7\b\2\2\u083e\u083
> f")
> +
> 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\u008
> d")
> +
> 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\u086
> a")
> +
> buf.write("\u086e\5\u0088E\2\u086b\u086e\5\u0118\u008d\2\u086c\u086
> e")
> +
> 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\u08
> 7e")
> +
> 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\u089
> d")
> + 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\u08e
> 7")
> +
> buf.write("\7!\2\2\u08db\u08dc\7@\2\2\u08dc\u08dd\7\b\2\2\u08dd\u08
> e2")
> +
> 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\u08e
> 2")
> +
> 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\u090
> e")
> +
> 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\u093
> 0")
> +
> 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\u096
> 9")
> +
> 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\u097
> b")
> +
> 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\u098
> d")
> +
> 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\u099
> 8")
> +
> 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\u095
> d")
> +
> 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\u012
> 8")
> +
> buf.write("\u0095\2\u09c9\u09ca\7\u00dc\2\2\u09ca\u09cc\5\u0128\u009
> 5")
> +
> 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\u09d
> 6")
> +
> 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\u09
> dc")
> +
> 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\u0a4
> 6")
> +
> 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\u009
> 4")
> +
> 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\u00
> ab")
> +
> 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\u0a7
> 4")
> +
> 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\u00c
> 8")
> +
> 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\u0a8
> e")
> +
> 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\u0a9
> c")
> +
> 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\u0ab
> 6")
> +
> 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\u015
> d")
> +
> 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\u0b0
> e")
> +
> 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\u0b1
> 3")
> +
> 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\u0b8
> f")
> +
> 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\u0ba
> 5")
> +
> 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.VfrStatementVarStoreLinearConte
> xt,0)
> +
> +
> + def vfrStatementVarStoreEfi(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreEfiContext,0)
> +
> +
> + def vfrStatementVarStoreNameValue(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarStoreNameValue
> Context,0)
> +
> +
> + def vfrStatementDefaultStore(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDefaultStoreContext
> ,0)
> +
> +
> + def vfrStatementDisableIfFormSet(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfFormSetCo
> ntext,0)
> +
> +
> + def vfrStatementSuppressIfFormSet(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSuppressIfFormSetC
> ontext,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.VfrStatementRefreshEventContex
> t,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.VfrStatementCrossReferenceCont
> ext,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.VfrStatementSubTitleComponent
> Context)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementSubTitleComponent
> Context,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementNumericTypeContex
> t,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.VfrStatementInconsistentIfContex
> t,0)
> +
> +
> + def vfrStatementNoSubmitIf(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementNoSubmitIfContext,0)
> +
> +
> + def vfrStatementDisableIfQuest(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementDisableIfQuestConte
> xt,0)
> +
> +
> + def vfrStatementRefresh(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshContext,0)
> +
> +
> + def vfrStatementVarstoreDevice(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementVarstoreDeviceCont
> ext,0)
> +
> +
> + def vfrStatementExtension(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExtensionContext,0)
> +
> +
> + def vfrStatementRefreshEvent(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementRefreshEventContex
> t,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionTagContex
> t)
> + 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.VfrStatementSuppressIfQuestCon
> text,0)
> +
> +
> + def vfrStatementGrayOutIfQuest(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfQuestCont
> ext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementOneOfOptionContex
> t,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.VfrStatementQuestionOptionCon
> text)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementQuestionOptionCont
> ext,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.VfrStatementQuestionOptionTagC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionTagListCont
> ext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementInconsistentIfConte
> xt)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContex
> t,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.VfrStatementQuestionOptionListC
> ontext,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.VfrStatementInconsistentIfConte
> xt)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfContex
> t,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.VfrStatementSuppressIfStatConte
> xt,0)
> +
> +
> + def vfrStatementGrayOutIfStat(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatContex
> t,0)
> +
> +
> + def vfrStatementInconsistentIfStat(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatCo
> ntext,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.VfrStatementSuppressIfStatNewC
> ontext,0)
> +
> +
> + def vfrStatementGrayOutIfStatNew(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementGrayOutIfStatNewCo
> ntext,0)
> +
> +
> + def vfrStatementInconsistentIfStat(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInconsistentIfStatCo
> ntext,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.VfrStatementSuppressIfStatNewC
> ontext,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.VfrStatementGrayOutIfStatNewCo
> ntext,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.VfrStatementInvalidHiddenContex
> t,0)
> +
> +
> + def vfrStatementInvalidInventory(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidInventoryCon
> text,0)
> +
> +
> + def vfrStatementInvalidSaveRestoreDefaults(self):
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementInvalidSaveRestoreD
> efaultsContext,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.EqualTermSupplementaryContex
> t)
> + 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.CompareTermSupplementaryCo
> ntext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.CompareTermSupplementaryCon
> text,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(CompareTermSupplementaryConte
> xt):
> +
> + 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.AddMinusTermSupplementaryC
> ontext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.AddMinusTermSupplementaryCo
> ntext,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.MultdivmodTermSupplementary
> Context)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.MultdivmodTermSupplementaryC
> ontext,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.VfrExpressionBuildInFunctionCont
> ext,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrQuestionDataFieldNameConte
> xt,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.VfrQuestionDataFieldNameCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrQuestionDataFieldNameConte
> xt,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.VfrQuestionDataFieldNameConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubCont
> ext)
> + else:
> + return
> self.getTypedRuleContext(VfrSyntaxParser.VfrStatementExpressionSubConte
> xt,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.VfrStatementExpressionSubConte
> xt,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 000000000000..7a1c56c56238
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/VfrSyntaxVisitor.py
> @@ -0,0 +1,4846 @@
> +import ctypes
> +from antlr4 import *
> +from IfrCtypes import *
> +from IfrFormPkg import *
> +from IfrUtility import *
> +from IfrTree 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 += '{} | '.format('0x%08x'%
> (ctx.vfrVarStoreEfiAttr(i).Attr))
> + else:
> + AttributesText += '{}'.format('0x%08x'%
> (ctx.vfrVarStoreEfiAttr(i).Attr))
> +
> + 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_UNSUPPORTE
> D, 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.T
> N), 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)
> + 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 = IfrInconsistentIf()
> + 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.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.vfrOneOfOption
> Flags().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_DEF
> AULT_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_DEF
> AULT_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_OPC
> ODE, ctx.A.line, ctx.A.text)
> + if ctx.LateCheckFlag() != None:
> + gVfrErrorHandle.HandleWarning
> (EFI_VFR_WARNING_CODE.VFR_WARNING_OBSOLETED_FRAMEWORK_OPC
> ODE, 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.VarT
> ype)
> + 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.VarT
> ype)
> + 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(ctypes.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_STAN
> DARD,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_MAN
> UFACTURING, 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.VarT
> ype)
> + 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.v
> frNumericFlags().LFlags, ctx.vfrNumericFlags().IsDisplaySpecified), ctx.F.line)
> + else:
> +
> self.ErrorHandler(NObj.SetFlags(ctx.vfrNumericFlags().HFlags,ctx.vfrNumericF
> lags().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.VarT
> ype)
> + 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.VarT
> ype)
> + 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,ct
> x.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.VarT
> ype)
> + 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 000000000000..dfc018ca6954
> --- /dev/null
> +++ b/BaseTools/Source/Python/VfrCompiler/__init__.py
> @@ -0,0 +1 @@
> +__all__ = ["VfrCompiler"]
> \ No newline at end of file
> --
> 2.27.0.windows.1
>
>
>
>
>
^ permalink raw reply [flat|nested] only message in thread