Date   

Re: [PATCH 0/3] Arm builds on Visual Studio

Laszlo Ersek
 

On 09/19/19 11:44, Leif Lindholm wrote:
Hi Liming,

On Thu, Sep 19, 2019 at 06:19:42AM +0000, Gao, Liming wrote:
I add my comments.

-----Original Message-----
From: Baptiste Gerondeau [mailto:baptiste.gerondeau@linaro.org]
Sent: Thursday, September 19, 2019 12:05 AM
To: devel@edk2.groups.io
Cc: ard.biesheuvel@linaro.org; leif.lindholm@linaro.org; Kinney, Michael D
<michael.d.kinney@intel.com>; Gao, Liming <liming.gao@intel.com>; Zhang,
Shenglei <shenglei.zhang@intel.com>; Baptiste Gerondeau
<baptiste.gerondeau@linaro.org>
Subject: [PATCH 0/3] Arm builds on Visual Studio

EDIT: Resending the series since I mistakenly used the wrong email,
sorry !

We are currently making an effort to make ARM (and AARCH64 eventually)
builds using Microsoft's Visual Studio Compiler (aka MSVC/MSFT).

These 3 patches correspond to an effort to make the assembler work with
MSFT, which entails :
- Feeding MSFT the RVCT .asm files, since they share syntax
requirements.
Please separate the patch. Each patch is for each package, can't cross packages.
If so, the package maintainer can easy review the change.
I agree with this as a general rule, but for this (hopefully never to
be repeated) operation, it makes sense to me to keep each change in
this set as one patch.

For the simple reason that the alternative leaves several unusable
commits in sequence in the repository. There is simply no way to
bisect through this change on a per-package basis.

This is after all a horrible horrible hack that lets us keep using the
.asm files provided for one toolchain family (RVCT) in a different
toolchain family (MSFT), without having to delete and re-add, losing
history in the process.

Would you be OK with an exception for this extremely unusual
situation?
(The question was posed to Liming, but I'm going to follow up here with
my own thoughts, after getting CC'd by Liming. Thanks for that BTW.)

Let's assume the changes are split up with a fine granularity. Under
that assumption, consider two cases:

(1) ARM builds on Visual Studio are broken until the last patch is
applied, but all other toolchains continue working fine throughout the
series.

versus

(2) ARM builds are broken on Visual Studio *and* on at least one other
-- preexistent -- toolchain, until the last patch in the series is applied.


Which case reflects reality?

If it's case (1), then I prefer the fine-grained patch series structure.
Nothing regresses with existent toolchains (so bisection works with
them), we just have to advertise the last patch in the series as the one
that enables Visual Studio.

If it's case (2), then I agree with the larger (multi-package) patch, as
a rare exception.

(We can also put it like this: if it's *possible* to write this series
such that it enables (1), then we should strive for that.)

Thanks,
Laszlo


Re: [PATCH 0/7] Strip trailing whitespace

Ard Biesheuvel
 

On Thu, 19 Sep 2019 at 21:06, Leif Lindholm <leif.lindholm@linaro.org> wrote:

*cough* 5-6/7 do take a bit of a shotgun approach with the Cc:s, but I
would prefer not breaking the set up any more than it already is.
The changes are however trivial, so hopefully not much of an issue.

Before we start looking into migrating the repository to native
line endings, let's start by killing off a bunch of trailing
whitespace.

This is basically the output of:
for filetype in '*.c' '*.h' '*.s' '*.S' '*.asm' '*.py' '*.inf' '*.inc' '*.dsc' '*.fdf' '*.dec' '*.uni' '*.txt' '*.md' '*.nasm' '*.vfr' '*.asl' '*.aslc' '*.asm16' '*makefile' '*.common' '*.cpp'; do find * -type f -iname "$filetype" -exec sed --in-place 's/[[:blank:]]\+\(\r*\)$/\1/' {} \;; done
executed in the top-level directory.

This does mess about with some imported projects, but I figure if
we keep them in the tree, we might as well clean it up.

Since we have some weird and wonderful file types in the tree, I think we can
only realy ever run automated fixups on a "whitelist" of file types. Please
let me know if I have left any important ones out from this operation.

(Why yes, that .S _is_ totally redundant given the use of -iname, but at least I'm being honest.)

These patches, as well as the preceding line ending and character
encoding cleanup can also be accessed at:
https://git.linaro.org/people/leif.lindholm/edk2.git/log/?h=pre-CRLF2LF-cleanup

Leif Lindholm (7):
ArmPkg: strip trailing whitespace
ArmPlatformPkg: strip trailing whitespace
OvmfPkg: strip trailing whitespace
For the above,
Acked-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>

BaseTools: strip trailing whitespace
EmulatorPkg: strip trailing whitespace
MdeModulePkg: strip trailing whitespace
UefiCpuPkg: strip trailing whitespace

ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf | 4 +-
ArmPlatformPkg/Scripts/Ds5/profile.py | 2 +-
ArmPlatformPkg/Scripts/Makefile | 2 +-
BaseTools/Source/C/BrotliCompress/tools/brotli.c | 2 +-
BaseTools/Source/C/GNUmakefile | 2 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c | 20 ++---
BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c | 22 ++---
BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h | 8 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c | 70 ++++++++--------
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c | 40 ++++-----
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c | 30 +++----
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c | 194 ++++++++++++++++++++++----------------------
BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c | 6 +-
BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt | 92 ++++++++++-----------
BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt | 102 +++++++++++------------
BaseTools/Source/C/Makefiles/app.makefile | 4 +-
BaseTools/Source/C/Makefiles/footer.makefile | 4 +-
BaseTools/Source/C/Makefiles/header.makefile | 8 +-
BaseTools/Source/C/Makefiles/lib.makefile | 2 +-
BaseTools/Source/C/Makefiles/ms.common | 4 +-
BaseTools/Source/C/VfrCompile/GNUmakefile | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt | 286 ++++++++++++++++++++++++++++++++---------------------------------
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt | 20 ++---
BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c | 194 ++++++++++++++++++++++----------------------
BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c | 18 ++---
BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c | 12 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c | 16 ++--
BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c | 16 ++--
BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c | 78 +++++++++---------
BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c | 40 ++++-----
BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c | 42 +++++-----
BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c | 4072 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c | 950 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------------------------------------------------------------------------------------
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c | 30 +++----
BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h | 22 ++---
BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/h/ast.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/h/err.h | 70 ++++++++--------
BaseTools/Source/C/VfrCompile/Pccts/history.txt | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c | 14 ++--
BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c | 46 +++++------
BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c | 46 +++++------
BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c | 26 +++---
BaseTools/Source/Python/Ecc/Check.py | 2 +-
BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py | 2 +-
BaseTools/Source/Python/Makefile | 2 +-
EmulatorPkg/Readme.md | 4 +-
MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr | 8 +-
MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr | 2 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h | 4 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h | 8 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c | 70 ++++++++--------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h | 4 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c | 30 +++----
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h | 4 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt | 92 ++++++++++-----------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt | 102 +++++++++++------------
MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr | 6 +-
MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr | 4 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c | 2 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h | 2 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c | 2 +-
OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c | 4 +-
OvmfPkg/AcpiPlatformDxe/Xen.c | 8 +-
OvmfPkg/AcpiTables/Facs.aslc | 6 +-
OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr | 18 ++---
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h | 4 +-
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h | 4 +-
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h | 4 +-
OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h | 2 +-
OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h | 2 +-
OvmfPkg/Include/IndustryStandard/Xen/io/ring.h | 34 ++++----
OvmfPkg/Include/IndustryStandard/Xen/memory.h | 4 +-
OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h | 4 +-
OvmfPkg/Include/IndustryStandard/Xen/xen.h | 10 +--
OvmfPkg/Include/Register/QemuSmramSaveStateMap.h | 2 +-
OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c | 12 +--
OvmfPkg/Library/LockBoxLib/LockBoxDxe.c | 2 +-
OvmfPkg/Library/LockBoxLib/LockBoxLib.c | 2 +-
OvmfPkg/Library/LockBoxLib/LockBoxLib.h | 2 +-
OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c | 4 +-
OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c | 2 +-
OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c | 2 +-
OvmfPkg/PlatformPei/Xen.c | 2 +-
OvmfPkg/SataControllerDxe/ComponentName.c | 6 +-
OvmfPkg/SataControllerDxe/SataController.c | 214 ++++++++++++++++++++++++-------------------------
OvmfPkg/SataControllerDxe/SataController.h | 208 +++++++++++++++++++++++------------------------
OvmfPkg/SataControllerDxe/SataControllerDxe.inf | 6 +-
OvmfPkg/Sec/SecMain.c | 34 ++++----
UefiCpuPkg/Application/Cpuid/Cpuid.c | 2 +-
122 files changed, 3882 insertions(+), 3882 deletions(-)

Cc: Andrew Fish <afish@apple.com>
Cc: Anthony Perard <anthony.perard@citrix.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Bob Feng <bob.c.feng@intel.com>
Cc: Dandan Bi <dandan.bi@intel.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Hao A Wu <hao.a.wu@intel.com>
Cc: Jian J Wang <jian.j.wang@intel.com>
Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Julien Grall <julien.grall@arm.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Liming Gao <liming.gao@intel.com>
Cc: Ray Ni <ray.ni@intel.com>
Cc: Zhichao Gao <zhichao.gao@intel.com>
--
2.20.1


Re: [PATCH 4/7] EmulatorPkg: strip trailing whitespace

Ni, Ray
 

Reviewed-by: Ray Ni <ray.ni@intel.com>

-----Original Message-----
From: devel@edk2.groups.io <devel@edk2.groups.io> On Behalf Of Leif Lindholm
Sent: Thursday, September 19, 2019 11:06 AM
To: devel@edk2.groups.io
Cc: Justen, Jordan L <jordan.l.justen@intel.com>; Andrew Fish <afish@apple.com>; Ni, Ray <ray.ni@intel.com>
Subject: [edk2-devel] [PATCH 4/7] EmulatorPkg: strip trailing whitespace

Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Andrew Fish <afish@apple.com>
Cc: Ray Ni <ray.ni@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
EmulatorPkg/Readme.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/EmulatorPkg/Readme.md b/EmulatorPkg/Readme.md
index 5ea61ca7ab5a..0c2eea6a9a02 100644
--- a/EmulatorPkg/Readme.md
+++ b/EmulatorPkg/Readme.md
@@ -57,12 +57,12 @@ emulator.**

For example, to build + run:

-`$ EmulatorPkg/build.sh`
+`$ EmulatorPkg/build.sh`
`$ EmulatorPkg/build.sh run`

The build architecture will match your host machine's architecture.

On X64 host machines, you can build + run IA32 mode as well:

-`$ EmulatorPkg/build.sh -a IA32`
+`$ EmulatorPkg/build.sh -a IA32`
`$ EmulatorPkg/build.sh -a IA32 run`
--
2.20.1



Re: [PATCH 7/7] UefiCpuPkg: strip trailing whitespace

Ni, Ray
 

Reviewed-by: Ray Ni <ray.ni@intel.com>

-----Original Message-----
From: devel@edk2.groups.io <devel@edk2.groups.io> On Behalf Of Leif Lindholm
Sent: Thursday, September 19, 2019 11:06 AM
To: devel@edk2.groups.io
Cc: Dong, Eric <eric.dong@intel.com>; Ni, Ray <ray.ni@intel.com>; Laszlo Ersek <lersek@redhat.com>
Subject: [edk2-devel] [PATCH 7/7] UefiCpuPkg: strip trailing whitespace

Cc: Eric Dong <eric.dong@intel.com>
Cc: Ray Ni <ray.ni@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
UefiCpuPkg/Application/Cpuid/Cpuid.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/UefiCpuPkg/Application/Cpuid/Cpuid.c b/UefiCpuPkg/Application/Cpuid/Cpuid.c
index f39a7fb33ae5..cee64f2fb5fc 100644
--- a/UefiCpuPkg/Application/Cpuid/Cpuid.c
+++ b/UefiCpuPkg/Application/Cpuid/Cpuid.c
@@ -709,7 +709,7 @@ CpuidArchitecturalPerformanceMonitoring (
Display CPUID_EXTENDED_TOPOLOGY leafs for all supported levels.

@param[in] LeafFunction Leaf function index for CPUID_EXTENDED_TOPOLOGY.
-
+
**/
VOID
CpuidExtendedTopology (
--
2.20.1



Re: [PATCH] Maintainers.txt: Unify one maintainer name

Laszlo Ersek
 

On 09/19/19 04:34, Jian J Wang wrote:
Update all occurrences of "Jian Wang" to be "Jian J Wang".

Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Liming Gao <liming.gao@intel.com>
Signed-off-by: Jian J Wang <jian.j.wang@intel.com>
---
Maintainers.txt | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Maintainers.txt b/Maintainers.txt
index dcf81c737a..e30d62cb28 100644
--- a/Maintainers.txt
+++ b/Maintainers.txt
@@ -130,7 +130,7 @@ M: Liming Gao <liming.gao@intel.com>
CryptoPkg
F: CryptoPkg/
W: https://github.com/tianocore/tianocore.github.io/wiki/CryptoPkg
-M: Jian Wang <jian.j.wang@intel.com>
+M: Jian J Wang <jian.j.wang@intel.com>
R: Xiaoyu Lu <xiaoyux.lu@intel.com>

DynamicTablesPkg
@@ -412,7 +412,7 @@ SecurityPkg
F: SecurityPkg/
W: https://github.com/tianocore/tianocore.github.io/wiki/SecurityPkg
M: Jiewen Yao <jiewen.yao@intel.com>
-M: Jian Wang <jian.j.wang@intel.com>
+M: Jian J Wang <jian.j.wang@intel.com>
R: Chao Zhang <chao.b.zhang@intel.com>

ShellPkg
Reviewed-by: Laszlo Ersek <lersek@redhat.com>

Thanks!
Laszlo


[PATCH 6/7] OvmfPkg: strip trailing whitespace

Leif Lindholm
 

Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Anthony Perard <anthony.perard@citrix.com>
Cc: Julien Grall <julien.grall@arm.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c | 4 ++--
OvmfPkg/AcpiPlatformDxe/Xen.c | 8 ++++----
OvmfPkg/AcpiTables/Facs.aslc | 6 +++---
OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr | 18 +++++++++---------
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h | 4 ++--
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h | 4 ++--
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h | 4 ++--
OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h | 2 +-
OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h | 2 +-
OvmfPkg/Include/IndustryStandard/Xen/io/ring.h | 34 +++++++++++++++++-----------------
OvmfPkg/Include/IndustryStandard/Xen/memory.h | 4 ++--
OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h | 4 ++--
OvmfPkg/Include/IndustryStandard/Xen/xen.h | 10 +++++-----
OvmfPkg/Include/Register/QemuSmramSaveStateMap.h | 2 +-
OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c | 12 ++++++------
OvmfPkg/Library/LockBoxLib/LockBoxDxe.c | 2 +-
OvmfPkg/Library/LockBoxLib/LockBoxLib.c | 2 +-
OvmfPkg/Library/LockBoxLib/LockBoxLib.h | 2 +-
OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c | 4 ++--
OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c | 2 +-
OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c | 2 +-
OvmfPkg/PlatformPei/Xen.c | 2 +-
OvmfPkg/SataControllerDxe/ComponentName.c | 6 +++---
OvmfPkg/SataControllerDxe/SataController.c | 214 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------------------------------------------------------------------------------------
OvmfPkg/SataControllerDxe/SataController.h | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------------------------------------------------------------------
OvmfPkg/SataControllerDxe/SataControllerDxe.inf | 6 +++---
OvmfPkg/Sec/SecMain.c | 34 +++++++++++++++++-----------------
27 files changed, 301 insertions(+), 301 deletions(-)

diff --git a/OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c b/OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c
index 2b529d58a15c..f872d91aea72 100644
--- a/OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c
+++ b/OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c
@@ -124,7 +124,7 @@ LocateFvInstanceWithTables (


/**
- Find ACPI tables in an FV and install them.
+ Find ACPI tables in an FV and install them.

This is now a fall-back path. Normally, we will search for tables provided
by the VMM first.
@@ -132,7 +132,7 @@ LocateFvInstanceWithTables (
If that fails, we use this function to load the ACPI tables from an FV. The
sources for the FV based tables is located under OvmfPkg/AcpiTables.

- @param AcpiTable Protocol instance pointer
+ @param AcpiTable Protocol instance pointer

**/
EFI_STATUS
diff --git a/OvmfPkg/AcpiPlatformDxe/Xen.c b/OvmfPkg/AcpiPlatformDxe/Xen.c
index f80dfe1a57cf..289ef971c4b8 100644
--- a/OvmfPkg/AcpiPlatformDxe/Xen.c
+++ b/OvmfPkg/AcpiPlatformDxe/Xen.c
@@ -6,7 +6,7 @@

SPDX-License-Identifier: BSD-2-Clause-Patent

-**/
+**/

#include "AcpiPlatform.h"
#include <Library/BaseLib.h>
@@ -151,12 +151,12 @@ InstallXenTables (
}

//
- // If XSDT table is find, just install its tables.
+ // If XSDT table is find, just install its tables.
// Otherwise, try to find and install the RSDT tables.
//
if (XenAcpiRsdpStructurePtr->XsdtAddress) {
//
- // Retrieve the addresses of XSDT and
+ // Retrieve the addresses of XSDT and
// calculate the number of its table entries.
//
Xsdt = (EFI_ACPI_DESCRIPTION_HEADER *) (UINTN)
@@ -212,7 +212,7 @@ InstallXenTables (
Rsdt = (EFI_ACPI_DESCRIPTION_HEADER *) (UINTN)
XenAcpiRsdpStructurePtr->RsdtAddress;
NumberOfTableEntries = (Rsdt->Length -
- sizeof (EFI_ACPI_DESCRIPTION_HEADER)) /
+ sizeof (EFI_ACPI_DESCRIPTION_HEADER)) /
sizeof (UINT32);

//
diff --git a/OvmfPkg/AcpiTables/Facs.aslc b/OvmfPkg/AcpiTables/Facs.aslc
index 159dd81373e3..56f86c1ca4fd 100644
--- a/OvmfPkg/AcpiTables/Facs.aslc
+++ b/OvmfPkg/AcpiTables/Facs.aslc
@@ -1,10 +1,10 @@
/** @file
FACS Table
-
+
Copyright (c) 2008 - 2012, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

-**/
+**/

#include <IndustryStandard/Acpi.h>

@@ -70,7 +70,7 @@ ReferenceAcpiTable (
)
{
//
- // Reference the table being generated to prevent the optimizer from removing the
+ // Reference the table being generated to prevent the optimizer from removing the
// data structure from the exeutable
//
return (VOID*)&FACS;
diff --git a/OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr b/OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr
index c879ca551fa0..2b03820d3869 100644
--- a/OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr
+++ b/OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr
@@ -1,10 +1,10 @@
///** @file
-//
+//
// Browser formset.
-//
+//
// Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
// SPDX-License-Identifier: BSD-2-Clause-Patent
-//
+//
//**/

#include "LegacyBootMaintUiVfr.h"
@@ -15,15 +15,15 @@ formset
title = STRING_TOKEN(STR_LEGACY_BOOT_PROMPT),
help = STRING_TOKEN(STR_LEGACY_BOOT_HELP),
classguid = EFI_IFR_BOOT_MAINTENANCE_GUID,
-
+
varstore LEGACY_BOOT_NV_DATA,
varid = VARSTORE_ID_LEGACY_BOOT,
name = LegacyBootData,
guid = LEGACY_BOOT_OPTION_FORMSET_GUID;
-
+
form formid = LEGACY_BOOT_FORM_ID,
title = STRING_TOKEN(STR_LEGACY_BOOT_PROMPT);
-
+
goto LEGACY_ORDER_CHANGE_FORM_ID,
prompt = STRING_TOKEN(STR_FORM_FLOPPY_BOOT_TITLE),
help = STRING_TOKEN(STR_FORM_FLOPPY_BOOT_HELP),
@@ -53,15 +53,15 @@ formset
help = STRING_TOKEN(STR_FORM_BEV_BOOT_HELP),
flags = INTERACTIVE,
key = FORM_BEV_BOOT_ID;
-
+
endform;

form formid = LEGACY_ORDER_CHANGE_FORM_ID,
title = STRING_TOKEN(STR_ORDER_CHANGE_PROMPT);
-
+
label FORM_BOOT_LEGACY_DEVICE_ID;
label FORM_BOOT_LEGACY_LABEL_END;
-
+
endform;

endformset;
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h b/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h
index 86378fba9b34..0314877f0b8a 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h
@@ -1,8 +1,8 @@
/******************************************************************************
* xen-x86_32.h
- *
+ *
* Guest OS interface to x86 32-bit Xen.
- *
+ *
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2004-2007, K A Fraser
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h b/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h
index 9dc92d02ce6c..c8f54c5746de 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h
@@ -1,8 +1,8 @@
/******************************************************************************
* xen-x86_64.h
- *
+ *
* Guest OS interface to x86 64-bit Xen.
- *
+ *
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2004-2006, K A Fraser
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h b/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h
index ed69f9241485..3c07c59f3831 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h
@@ -1,8 +1,8 @@
/******************************************************************************
* arch-x86/xen.h
- *
+ *
* Guest OS interface to x86 Xen.
- *
+ *
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2004-2006, K A Fraser
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h b/OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h
index 3b94435c9f8d..15aa93e2f52b 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h
@@ -103,7 +103,7 @@
*/
#define HVM_PARAM_ACPI_IOPORTS_LOCATION 19

-/* Enable blocking memory events, async or sync (pause vcpu until response)
+/* Enable blocking memory events, async or sync (pause vcpu until response)
* onchangeonly indicates messages only on a change of value */
#define HVM_PARAM_MEMORY_EVENT_CR0 20
#define HVM_PARAM_MEMORY_EVENT_CR3 21
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h b/OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h
index 0c48e7693787..4303d37c30be 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h
@@ -1,6 +1,6 @@
/******************************************************************************
* protocols.h
- *
+ *
* SPDX-License-Identifier: MIT
*/

diff --git a/OvmfPkg/Include/IndustryStandard/Xen/io/ring.h b/OvmfPkg/Include/IndustryStandard/Xen/io/ring.h
index c770ade40785..2fa5d20ca0fa 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/io/ring.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/io/ring.h
@@ -1,6 +1,6 @@
/******************************************************************************
* ring.h
- *
+ *
* Shared producer-consumer ring macros.
*
* SPDX-License-Identifier: MIT
@@ -31,7 +31,7 @@ typedef UINT32 RING_IDX;
/*
* Calculate size of a shared ring, given the total available space for the
* ring and indexes (_sz), and the name tag of the request/response structure.
- * A ring contains as many entries as will fit, rounded down to the nearest
+ * A ring contains as many entries as will fit, rounded down to the nearest
* power of two (so we can mask with (size-1) to loop around).
*/
#define __CONST_RING_SIZE(_s, _sz) \
@@ -45,7 +45,7 @@ typedef UINT32 RING_IDX;

/*
* Macros to make the correct C datatypes for a new kind of ring.
- *
+ *
* To make a new ring datatype, you need to have two message structures,
* let's say request_t, and response_t already defined.
*
@@ -55,7 +55,7 @@ typedef UINT32 RING_IDX;
*
* These expand out to give you a set of types, as you can see below.
* The most important of these are:
- *
+ *
* mytag_sring_t - The shared ring.
* mytag_front_ring_t - The 'front' half of the ring.
* mytag_back_ring_t - The 'back' half of the ring.
@@ -123,15 +123,15 @@ typedef struct __name##_back_ring __name##_back_ring_t

/*
* Macros for manipulating rings.
- *
- * FRONT_RING_whatever works on the "front end" of a ring: here
+ *
+ * FRONT_RING_whatever works on the "front end" of a ring: here
* requests are pushed on to the ring and responses taken off it.
- *
- * BACK_RING_whatever works on the "back end" of a ring: here
+ *
+ * BACK_RING_whatever works on the "back end" of a ring: here
* requests are taken off the ring and responses put on.
- *
- * N.B. these macros do NO INTERLOCKS OR FLOW CONTROL.
- * This is OK in 1-for-1 request-response situations where the
+ *
+ * N.B. these macros do NO INTERLOCKS OR FLOW CONTROL.
+ * This is OK in 1-for-1 request-response situations where the
* requestor (front end) never has more than RING_SIZE()-1
* outstanding requests.
*/
@@ -219,26 +219,26 @@ typedef struct __name##_back_ring __name##_back_ring_t

/*
* Notification hold-off (req_event and rsp_event):
- *
+ *
* When queueing requests or responses on a shared ring, it may not always be
* necessary to notify the remote end. For example, if requests are in flight
* in a backend, the front may be able to queue further requests without
* notifying the back (if the back checks for new requests when it queues
* responses).
- *
+ *
* When enqueuing requests or responses:
- *
+ *
* Use RING_PUSH_{REQUESTS,RESPONSES}_AND_CHECK_NOTIFY(). The second argument
* is a boolean return value. True indicates that the receiver requires an
* asynchronous notification.
- *
+ *
* After dequeuing requests or responses (before sleeping the connection):
- *
+ *
* Use RING_FINAL_CHECK_FOR_REQUESTS() or RING_FINAL_CHECK_FOR_RESPONSES().
* The second argument is a boolean return value. True indicates that there
* are pending messages on the ring (i.e., the connection should not be put
* to sleep).
- *
+ *
* These macros will set the req_event/rsp_event field to trigger a
* notification on the very next message that is enqueued. If you want to
* create batches of work (i.e., only receive a notification after several
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/memory.h b/OvmfPkg/Include/IndustryStandard/Xen/memory.h
index 4a33a26d4eba..54ee4b465417 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/memory.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/memory.h
@@ -1,8 +1,8 @@
/******************************************************************************
* memory.h
- *
+ *
* Memory reservation and information.
- *
+ *
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2005, Keir Fraser <keir@xensource.com>
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h b/OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h
index 99d5a5dc0419..c77049f7964e 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h
@@ -1,8 +1,8 @@
/******************************************************************************
* xen-compat.h
- *
+ *
* Guest OS interface to Xen. Compatibility layer.
- *
+ *
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2006, Christian Limpach
diff --git a/OvmfPkg/Include/IndustryStandard/Xen/xen.h b/OvmfPkg/Include/IndustryStandard/Xen/xen.h
index eccc1ad6251a..e55d93263285 100644
--- a/OvmfPkg/Include/IndustryStandard/Xen/xen.h
+++ b/OvmfPkg/Include/IndustryStandard/Xen/xen.h
@@ -1,8 +1,8 @@
/******************************************************************************
* xen.h
- *
+ *
* Guest OS interface to Xen.
- *
+ *
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2004, K A Fraser
@@ -203,7 +203,7 @@ typedef struct vcpu_time_info vcpu_time_info_t;
struct vcpu_info {
/*
* 'evtchn_upcall_pending' is written non-zero by Xen to indicate
- * a pending notification for a particular VCPU. It is then cleared
+ * a pending notification for a particular VCPU. It is then cleared
* by the guest OS /before/ checking for pending work, thus avoiding
* a set-and-check race. Note that the mask is only accessed by Xen
* on the CPU that is currently hosting the VCPU. This means that the
@@ -266,7 +266,7 @@ struct shared_info {
* 3. Virtual interrupts ('events'). A domain can bind an event-channel
* port to a virtual interrupt source, such as the virtual-timer
* device or the emergency console.
- *
+ *
* Event channels are addressed by a "port index". Each channel is
* associated with two bits of information:
* 1. PENDING -- notifies the domain that there is a pending notification
@@ -277,7 +277,7 @@ struct shared_info {
* becomes pending while the channel is masked then the 'edge' is lost
* (i.e., when the channel is unmasked, the guest must manually handle
* pending notifications as no upcall will be scheduled by Xen).
- *
+ *
* To expedite scanning of pending notifications, any 0->1 pending
* transition on an unmasked channel causes a corresponding bit in a
* per-vcpu selector word to be set. Each bit in the selector covers a
diff --git a/OvmfPkg/Include/Register/QemuSmramSaveStateMap.h b/OvmfPkg/Include/Register/QemuSmramSaveStateMap.h
index 45db759092a4..40cf63c3e60b 100644
--- a/OvmfPkg/Include/Register/QemuSmramSaveStateMap.h
+++ b/OvmfPkg/Include/Register/QemuSmramSaveStateMap.h
@@ -1,7 +1,7 @@
/** @file
SMRAM Save State Map Definitions.

-SMRAM Save State Map definitions based on contents of the
+SMRAM Save State Map definitions based on contents of the
Intel(R) 64 and IA-32 Architectures Software Developer's Manual
Volume 3C, Section 34.4 SMRAM
Volume 3C, Section 34.5 SMI Handler Execution Environment
diff --git a/OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c b/OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c
index bc64a63c78a7..49bdfdf65043 100644
--- a/OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c
+++ b/OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c
@@ -39,19 +39,19 @@ InitializeConfigAccessMethod (
}

/**
- Registers a PCI device so PCI configuration registers may be accessed after
+ Registers a PCI device so PCI configuration registers may be accessed after
SetVirtualAddressMap().
-
- Registers the PCI device specified by Address so all the PCI configuration registers
+
+ Registers the PCI device specified by Address so all the PCI configuration registers
associated with that PCI device may be accessed after SetVirtualAddressMap() is called.
-
+
If Address > 0x0FFFFFFF, then ASSERT().

@param Address The address that encodes the PCI Bus, Device, Function and
Register.
-
+
@retval RETURN_SUCCESS The PCI device was registered for runtime access.
- @retval RETURN_UNSUPPORTED An attempt was made to call this function
+ @retval RETURN_UNSUPPORTED An attempt was made to call this function
after ExitBootServices().
@retval RETURN_UNSUPPORTED The resources required to access the PCI device
at runtime could not be mapped.
diff --git a/OvmfPkg/Library/LockBoxLib/LockBoxDxe.c b/OvmfPkg/Library/LockBoxLib/LockBoxDxe.c
index a42a7a6248eb..b28ad4d2dba7 100644
--- a/OvmfPkg/Library/LockBoxLib/LockBoxDxe.c
+++ b/OvmfPkg/Library/LockBoxLib/LockBoxDxe.c
@@ -24,7 +24,7 @@

@param MemoryType Memory type of memory to allocate.
@param Size Size of memory to allocate.
-
+
@return Allocated address for output.

**/
diff --git a/OvmfPkg/Library/LockBoxLib/LockBoxLib.c b/OvmfPkg/Library/LockBoxLib/LockBoxLib.c
index bc40a4b3bb8e..1f36b5cc06b5 100644
--- a/OvmfPkg/Library/LockBoxLib/LockBoxLib.c
+++ b/OvmfPkg/Library/LockBoxLib/LockBoxLib.c
@@ -48,7 +48,7 @@ LockBoxLibInitialize (
StartOfEntries = ((LOCK_BOX_ENTRY *) (mLockBoxGlobal + 1));
NumEntries = ((PcdGet32 (PcdOvmfLockBoxStorageSize) - sizeof (LOCK_BOX_GLOBAL)) /
sizeof (LOCK_BOX_ENTRY));
- EndOfEntries = StartOfEntries + NumEntries;
+ EndOfEntries = StartOfEntries + NumEntries;
if (mLockBoxGlobal->Signature != LOCK_BOX_GLOBAL_SIGNATURE) {
//
// Note: This code depends on the lock box being cleared in early
diff --git a/OvmfPkg/Library/LockBoxLib/LockBoxLib.h b/OvmfPkg/Library/LockBoxLib/LockBoxLib.h
index 80b4998d5eb6..d654ea63987b 100644
--- a/OvmfPkg/Library/LockBoxLib/LockBoxLib.h
+++ b/OvmfPkg/Library/LockBoxLib/LockBoxLib.h
@@ -1,5 +1,5 @@
/** @file
-
+
Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>

SPDX-License-Identifier: BSD-2-Clause-Patent
diff --git a/OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c b/OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c
index 206b90866957..734d30213cb1 100644
--- a/OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c
+++ b/OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c
@@ -10,7 +10,7 @@
/**

This function provides a platform-specific method to detect whether the platform
- is operating by a physically present user.
+ is operating by a physically present user.

Programmatic changing of platform security policy (such as disable Secure Boot,
or switch between Standard/Custom Secure Boot mode) MUST NOT be possible during
@@ -19,7 +19,7 @@

NOTE THAT: This function cannot depend on any EFI Variable Service since they are
not available when this function is called in AuthenticateVariable driver.
-
+
@retval TRUE The platform is operated by a physically present user.
@retval FALSE The platform is NOT operated by a physically present user.

diff --git a/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c b/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c
index a80ceeaa8a99..4d2c43cb8fd7 100644
--- a/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c
+++ b/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c
@@ -22,7 +22,7 @@

/**
Selects a firmware configuration item for reading.
-
+
Following this call, any data read from this item will start from
the beginning of the configuration item's data.

diff --git a/OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c b/OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c
index 35a4a082334a..154e4fdeb71c 100644
--- a/OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c
+++ b/OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c
@@ -102,7 +102,7 @@ XenIoMmioInstall (
*Handle = OutHandle;
return EFI_SUCCESS;
}
-
+
DEBUG ((EFI_D_ERROR, "%a: Failed to install the EFI_DEVICE_PATH and "
"XENIO_PROTOCOL protocols on handle %p (Status == %r)\n",
__FUNCTION__, OutHandle, Status));
diff --git a/OvmfPkg/PlatformPei/Xen.c b/OvmfPkg/PlatformPei/Xen.c
index 3e15b32a73bf..0904c654f149 100644
--- a/OvmfPkg/PlatformPei/Xen.c
+++ b/OvmfPkg/PlatformPei/Xen.c
@@ -64,7 +64,7 @@ XenGetE820Map (

/**
Connects to the Hypervisor.
-
+
@param XenLeaf CPUID index used to connect.

@return EFI_STATUS
diff --git a/OvmfPkg/SataControllerDxe/ComponentName.c b/OvmfPkg/SataControllerDxe/ComponentName.c
index 09d0e0325c2b..320dca382a1d 100644
--- a/OvmfPkg/SataControllerDxe/ComponentName.c
+++ b/OvmfPkg/SataControllerDxe/ComponentName.c
@@ -66,7 +66,7 @@ GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mSataControllerController
@param DriverName A pointer to the Unicode string to return. This Unicode string
is the name of the driver specified by This in the language
specified by Language.
-
+
@retval EFI_SUCCESS The Unicode string for the Driver specified by This
and the language specified by Language was returned
in DriverName.
@@ -94,7 +94,7 @@ SataControllerComponentNameGetDriverName (

/**
Retrieves a Unicode string that is the user readable name of the controller
- that is being managed by an UEFI Driver.
+ that is being managed by an UEFI Driver.

@param This A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
@param ControllerHandle The handle of a controller that the driver specified by
@@ -117,7 +117,7 @@ SataControllerComponentNameGetDriverName (
ControllerHandle and ChildHandle in the language
specified by Language from the point of view of the
driver specified by This.
-
+
@retval EFI_SUCCESS The Unicode string for the user readable name in the
language specified by Language for the driver
specified by This was returned in DriverName.
diff --git a/OvmfPkg/SataControllerDxe/SataController.c b/OvmfPkg/SataControllerDxe/SataController.c
index 8d6a6bbb2286..313bfab1bea5 100644
--- a/OvmfPkg/SataControllerDxe/SataController.c
+++ b/OvmfPkg/SataControllerDxe/SataController.c
@@ -39,7 +39,7 @@ AhciReadReg (
UINT32 Data;

ASSERT (PciIo != NULL);
-
+
Data = 0;

PciIo->Mem.Read (
@@ -265,9 +265,9 @@ CalculateBestUdmaMode (
/**
The Entry Point of module. It follows the standard UEFI driver model.

- @param[in] ImageHandle The firmware allocated handle for the EFI image.
+ @param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
-
+
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.

@@ -361,7 +361,7 @@ SataControllerSupported (
}

/**
- This routine is called right after the .Supported() called and
+ This routine is called right after the .Supported() called and
Start this driver on ControllerHandle.

@param This Protocol instance pointer.
@@ -680,34 +680,34 @@ FlatDeviceIndex (
//
/**
Returns the information about the specified IDE channel.
-
+
This function can be used to obtain information about a particular IDE channel.
- The driver entity uses this information during the enumeration process.
-
- If Enabled is set to FALSE, the driver entity will not scan the channel. Note
+ The driver entity uses this information during the enumeration process.
+
+ If Enabled is set to FALSE, the driver entity will not scan the channel. Note
that it will not prevent an operating system driver from scanning the channel.
-
- For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
- controllers, this value will always be 1. SATA configurations can contain SATA
+
+ For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
+ controllers, this value will always be 1. SATA configurations can contain SATA
port multipliers. SATA port multipliers behave like SATA bridges and can support
- up to 16 devices on the other side. If a SATA port out of the IDE controller
- is connected to a port multiplier, MaxDevices will be set to the number of SATA
- devices that the port multiplier supports. Because today's port multipliers
- support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
- bus driver is required to scan for the presence of port multipliers behind an SATA
- controller and enumerate up to MaxDevices number of devices behind the port
- multiplier.
-
- In this context, the devices behind a port multiplier constitute a channel.
-
+ up to 16 devices on the other side. If a SATA port out of the IDE controller
+ is connected to a port multiplier, MaxDevices will be set to the number of SATA
+ devices that the port multiplier supports. Because today's port multipliers
+ support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
+ bus driver is required to scan for the presence of port multipliers behind an SATA
+ controller and enumerate up to MaxDevices number of devices behind the port
+ multiplier.
+
+ In this context, the devices behind a port multiplier constitute a channel.
+
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel Zero-based channel number.
- @param[out] Enabled TRUE if this channel is enabled. Disabled channels
+ @param[out] Enabled TRUE if this channel is enabled. Disabled channels
are not scanned to see if any devices are present.
@param[out] MaxDevices The maximum number of IDE devices that the bus driver
- can expect on this channel. For the ATA/ATAPI
- specification, version 6, this number will either be
- one or two. For Serial ATA (SATA) configurations with a
+ can expect on this channel. For the ATA/ATAPI
+ specification, version 6, this number will either be
+ one or two. For Serial ATA (SATA) configurations with a
port multiplier, this number can be as large as fifteen.

@retval EFI_SUCCESS Information was returned without any errors.
@@ -740,13 +740,13 @@ IdeInitGetChannelInfo (
/**
The notifications from the driver entity that it is about to enter a certain
phase of the IDE channel enumeration process.
-
- This function can be used to notify the IDE controller driver to perform
- specific actions, including any chipset-specific initialization, so that the
- chipset is ready to enter the next phase. Seven notification points are defined
- at this time.
-
- More synchronization points may be added as required in the future.
+
+ This function can be used to notify the IDE controller driver to perform
+ specific actions, including any chipset-specific initialization, so that the
+ chipset is ready to enter the next phase. Seven notification points are defined
+ at this time.
+
+ More synchronization points may be added as required in the future.

@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Phase The phase during enumeration.
@@ -755,9 +755,9 @@ IdeInitGetChannelInfo (
@retval EFI_SUCCESS The notification was accepted without any errors.
@retval EFI_UNSUPPORTED Phase is not supported.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
- @retval EFI_NOT_READY This phase cannot be entered at this time; for
- example, an attempt was made to enter a Phase
- without having entered one or more previous
+ @retval EFI_NOT_READY This phase cannot be entered at this time; for
+ example, an attempt was made to enter a Phase
+ without having entered one or more previous
Phase.

**/
@@ -775,32 +775,32 @@ IdeInitNotifyPhase (
/**
Submits the device information to the IDE controller driver.

- This function is used by the driver entity to pass detailed information about
- a particular device to the IDE controller driver. The driver entity obtains
+ This function is used by the driver entity to pass detailed information about
+ a particular device to the IDE controller driver. The driver entity obtains
this information by issuing an ATA or ATAPI IDENTIFY_DEVICE command. IdentifyData
- is the pointer to the response data buffer. The IdentifyData buffer is owned
- by the driver entity, and the IDE controller driver must make a local copy
- of the entire buffer or parts of the buffer as needed. The original IdentifyData
+ is the pointer to the response data buffer. The IdentifyData buffer is owned
+ by the driver entity, and the IDE controller driver must make a local copy
+ of the entire buffer or parts of the buffer as needed. The original IdentifyData
buffer pointer may not be valid when
-
+
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() or
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() is called at a later point.
-
- The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
- compute the optimum mode for the device. These fields are not limited to the
- timing information. For example, an implementation of the IDE controller driver
- may examine the vendor and type/mode field to match known bad drives.
-
- The driver entity may submit drive information in any order, as long as it
- submits information for all the devices belonging to the enumeration group
+
+ The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
+ compute the optimum mode for the device. These fields are not limited to the
+ timing information. For example, an implementation of the IDE controller driver
+ may examine the vendor and type/mode field to match known bad drives.
+
+ The driver entity may submit drive information in any order, as long as it
+ submits information for all the devices belonging to the enumeration group
before EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() is called for any device
in that enumeration group. If a device is absent, EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- should be called with IdentifyData set to NULL. The IDE controller driver may
- not have any other mechanism to know whether a device is present or not. Therefore,
- setting IdentifyData to NULL does not constitute an error condition.
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
- given (Channel, Device) pair.
-
+ should be called with IdentifyData set to NULL. The IDE controller driver may
+ not have any other mechanism to know whether a device is present or not. Therefore,
+ setting IdentifyData to NULL does not constitute an error condition.
+ EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
+ given (Channel, Device) pair.
+
@param[in] This A pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel Zero-based channel number.
@param[in] Device Zero-based device number on the Channel.
@@ -853,31 +853,31 @@ IdeInitSubmitData (
/**
Disqualifies specific modes for an IDE device.

- This function allows the driver entity or other drivers (such as platform
+ This function allows the driver entity or other drivers (such as platform
drivers) to reject certain timing modes and request the IDE controller driver
- to recalculate modes. This function allows the driver entity and the IDE
- controller driver to negotiate the timings on a per-device basis. This function
- is useful in the case of drives that lie about their capabilities. An example
- is when the IDE device fails to accept the timing modes that are calculated
+ to recalculate modes. This function allows the driver entity and the IDE
+ controller driver to negotiate the timings on a per-device basis. This function
+ is useful in the case of drives that lie about their capabilities. An example
+ is when the IDE device fails to accept the timing modes that are calculated
by the IDE controller driver based on the response to the Identify Drive command.

- If the driver entity does not want to limit the ATA timing modes and leave that
- decision to the IDE controller driver, it can either not call this function for
- the given device or call this function and set the Valid flag to FALSE for all
+ If the driver entity does not want to limit the ATA timing modes and leave that
+ decision to the IDE controller driver, it can either not call this function for
+ the given device or call this function and set the Valid flag to FALSE for all
modes that are listed in EFI_ATA_COLLECTIVE_MODE.
-
- The driver entity may disqualify modes for a device in any order and any number
+
+ The driver entity may disqualify modes for a device in any order and any number
of times.
-
- This function can be called multiple times to invalidate multiple modes of the
- same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
- specification for more information on PIO modes.
-
+
+ This function can be called multiple times to invalidate multiple modes of the
+ same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
+ specification for more information on PIO modes.
+
For Serial ATA (SATA) controllers, this member function can be used to disqualify
a higher transfer rate mode on a given channel. For example, a platform driver
- may inform the IDE controller driver to not use second-generation (Gen2) speeds
+ may inform the IDE controller driver to not use second-generation (Gen2) speeds
for a certain SATA drive.
-
+
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel The zero-based channel number.
@param[in] Device The zero-based device number on the Channel.
@@ -888,7 +888,7 @@ IdeInitSubmitData (
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
@retval EFI_INVALID_PARAMETER Device is invalid.
@retval EFI_INVALID_PARAMETER IdentifyData is NULL.
-
+
**/
EFI_STATUS
EFIAPI
@@ -928,39 +928,39 @@ IdeInitDisqualifyMode (
Returns the information about the optimum modes for the specified IDE device.

This function is used by the driver entity to obtain the optimum ATA modes for
- a specific device. The IDE controller driver takes into account the following
+ a specific device. The IDE controller driver takes into account the following
while calculating the mode:
- The IdentifyData inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- The BadModes inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode()

- The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- for all the devices that belong to an enumeration group before calling
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
-
- The IDE controller driver will use controller- and possibly platform-specific
- algorithms to arrive at SupportedModes. The IDE controller may base its
- decision on user preferences and other considerations as well. This function
- may be called multiple times because the driver entity may renegotiate the mode
+ The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
+ for all the devices that belong to an enumeration group before calling
+ EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
+
+ The IDE controller driver will use controller- and possibly platform-specific
+ algorithms to arrive at SupportedModes. The IDE controller may base its
+ decision on user preferences and other considerations as well. This function
+ may be called multiple times because the driver entity may renegotiate the mode
with the IDE controller driver using EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode().
-
- The driver entity may collect timing information for various devices in any
+
+ The driver entity may collect timing information for various devices in any
order. The driver entity is responsible for making sure that all the dependencies
- are satisfied. For example, the SupportedModes information for device A that
- was previously returned may become stale after a call to
+ are satisfied. For example, the SupportedModes information for device A that
+ was previously returned may become stale after a call to
EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() for device B.
-
- The buffer SupportedModes is allocated by the callee because the caller does
- not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
- is defined in a way that allows for future extensibility and can be of variable
- length. This memory pool should be deallocated by the caller when it is no
- longer necessary.
-
- The IDE controller driver for a Serial ATA (SATA) controller can use this
- member function to force a lower speed (first-generation [Gen1] speeds on a
- second-generation [Gen2]-capable hardware). The IDE controller driver can
- also allow the driver entity to stay with the speed that has been negotiated
+
+ The buffer SupportedModes is allocated by the callee because the caller does
+ not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
+ is defined in a way that allows for future extensibility and can be of variable
+ length. This memory pool should be deallocated by the caller when it is no
+ longer necessary.
+
+ The IDE controller driver for a Serial ATA (SATA) controller can use this
+ member function to force a lower speed (first-generation [Gen1] speeds on a
+ second-generation [Gen2]-capable hardware). The IDE controller driver can
+ also allow the driver entity to stay with the speed that has been negotiated
by the physical layer.
-
+
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel A zero-based channel number.
@param[in] Device A zero-based device number on the Channel.
@@ -968,13 +968,13 @@ IdeInitDisqualifyMode (

@retval EFI_SUCCESS SupportedModes was returned.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
- @retval EFI_INVALID_PARAMETER Device is invalid.
+ @retval EFI_INVALID_PARAMETER Device is invalid.
@retval EFI_INVALID_PARAMETER SupportedModes is NULL.
- @retval EFI_NOT_READY Modes cannot be calculated due to a lack of
- data. This error may happen if
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
- were not called for at least one drive in the
+ @retval EFI_NOT_READY Modes cannot be calculated due to a lack of
+ data. This error may happen if
+ EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
+ and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
+ were not called for at least one drive in the
same enumeration group.

**/
@@ -1061,9 +1061,9 @@ IdeInitCalculateMode (
Commands the IDE controller driver to program the IDE controller hardware
so that the specified device can operate at the specified mode.

- This function is used by the driver entity to instruct the IDE controller
- driver to program the IDE controller hardware to the specified modes. This
- function can be called only once for a particular device. For a Serial ATA
+ This function is used by the driver entity to instruct the IDE controller
+ driver to program the IDE controller hardware to the specified modes. This
+ function can be called only once for a particular device. For a Serial ATA
(SATA) Advanced Host Controller Interface (AHCI) controller, no controller-
specific programming may be required.

diff --git a/OvmfPkg/SataControllerDxe/SataController.h b/OvmfPkg/SataControllerDxe/SataController.h
index e8044e870d8e..4ef7f56e2249 100644
--- a/OvmfPkg/SataControllerDxe/SataController.h
+++ b/OvmfPkg/SataControllerDxe/SataController.h
@@ -132,7 +132,7 @@ SataControllerSupported (
;

/**
- This routine is called right after the .Supported() called and
+ This routine is called right after the .Supported() called and
Start this driver on ControllerHandle.

@param This Protocol instance pointer.
@@ -181,34 +181,34 @@ SataControllerStop (
//
/**
Returns the information about the specified IDE channel.
-
+
This function can be used to obtain information about a particular IDE channel.
- The driver entity uses this information during the enumeration process.
-
- If Enabled is set to FALSE, the driver entity will not scan the channel. Note
+ The driver entity uses this information during the enumeration process.
+
+ If Enabled is set to FALSE, the driver entity will not scan the channel. Note
that it will not prevent an operating system driver from scanning the channel.
-
- For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
- controllers, this value will always be 1. SATA configurations can contain SATA
+
+ For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
+ controllers, this value will always be 1. SATA configurations can contain SATA
port multipliers. SATA port multipliers behave like SATA bridges and can support
- up to 16 devices on the other side. If a SATA port out of the IDE controller
- is connected to a port multiplier, MaxDevices will be set to the number of SATA
- devices that the port multiplier supports. Because today's port multipliers
- support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
- bus driver is required to scan for the presence of port multipliers behind an SATA
- controller and enumerate up to MaxDevices number of devices behind the port
- multiplier.
-
- In this context, the devices behind a port multiplier constitute a channel.
-
+ up to 16 devices on the other side. If a SATA port out of the IDE controller
+ is connected to a port multiplier, MaxDevices will be set to the number of SATA
+ devices that the port multiplier supports. Because today's port multipliers
+ support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
+ bus driver is required to scan for the presence of port multipliers behind an SATA
+ controller and enumerate up to MaxDevices number of devices behind the port
+ multiplier.
+
+ In this context, the devices behind a port multiplier constitute a channel.
+
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel Zero-based channel number.
- @param[out] Enabled TRUE if this channel is enabled. Disabled channels
+ @param[out] Enabled TRUE if this channel is enabled. Disabled channels
are not scanned to see if any devices are present.
@param[out] MaxDevices The maximum number of IDE devices that the bus driver
- can expect on this channel. For the ATA/ATAPI
- specification, version 6, this number will either be
- one or two. For Serial ATA (SATA) configurations with a
+ can expect on this channel. For the ATA/ATAPI
+ specification, version 6, this number will either be
+ one or two. For Serial ATA (SATA) configurations with a
port multiplier, this number can be as large as fifteen.

@retval EFI_SUCCESS Information was returned without any errors.
@@ -228,13 +228,13 @@ IdeInitGetChannelInfo (
/**
The notifications from the driver entity that it is about to enter a certain
phase of the IDE channel enumeration process.
-
- This function can be used to notify the IDE controller driver to perform
- specific actions, including any chipset-specific initialization, so that the
- chipset is ready to enter the next phase. Seven notification points are defined
- at this time.
-
- More synchronization points may be added as required in the future.
+
+ This function can be used to notify the IDE controller driver to perform
+ specific actions, including any chipset-specific initialization, so that the
+ chipset is ready to enter the next phase. Seven notification points are defined
+ at this time.
+
+ More synchronization points may be added as required in the future.

@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Phase The phase during enumeration.
@@ -243,9 +243,9 @@ IdeInitGetChannelInfo (
@retval EFI_SUCCESS The notification was accepted without any errors.
@retval EFI_UNSUPPORTED Phase is not supported.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
- @retval EFI_NOT_READY This phase cannot be entered at this time; for
- example, an attempt was made to enter a Phase
- without having entered one or more previous
+ @retval EFI_NOT_READY This phase cannot be entered at this time; for
+ example, an attempt was made to enter a Phase
+ without having entered one or more previous
Phase.

**/
@@ -261,32 +261,32 @@ IdeInitNotifyPhase (
/**
Submits the device information to the IDE controller driver.

- This function is used by the driver entity to pass detailed information about
- a particular device to the IDE controller driver. The driver entity obtains
+ This function is used by the driver entity to pass detailed information about
+ a particular device to the IDE controller driver. The driver entity obtains
this information by issuing an ATA or ATAPI IDENTIFY_DEVICE command. IdentifyData
- is the pointer to the response data buffer. The IdentifyData buffer is owned
- by the driver entity, and the IDE controller driver must make a local copy
- of the entire buffer or parts of the buffer as needed. The original IdentifyData
+ is the pointer to the response data buffer. The IdentifyData buffer is owned
+ by the driver entity, and the IDE controller driver must make a local copy
+ of the entire buffer or parts of the buffer as needed. The original IdentifyData
buffer pointer may not be valid when
-
+
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() or
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() is called at a later point.
-
- The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
- compute the optimum mode for the device. These fields are not limited to the
- timing information. For example, an implementation of the IDE controller driver
- may examine the vendor and type/mode field to match known bad drives.
-
- The driver entity may submit drive information in any order, as long as it
- submits information for all the devices belonging to the enumeration group
+
+ The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
+ compute the optimum mode for the device. These fields are not limited to the
+ timing information. For example, an implementation of the IDE controller driver
+ may examine the vendor and type/mode field to match known bad drives.
+
+ The driver entity may submit drive information in any order, as long as it
+ submits information for all the devices belonging to the enumeration group
before EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() is called for any device
in that enumeration group. If a device is absent, EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- should be called with IdentifyData set to NULL. The IDE controller driver may
- not have any other mechanism to know whether a device is present or not. Therefore,
- setting IdentifyData to NULL does not constitute an error condition.
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
- given (Channel, Device) pair.
-
+ should be called with IdentifyData set to NULL. The IDE controller driver may
+ not have any other mechanism to know whether a device is present or not. Therefore,
+ setting IdentifyData to NULL does not constitute an error condition.
+ EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
+ given (Channel, Device) pair.
+
@param[in] This A pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel Zero-based channel number.
@param[in] Device Zero-based device number on the Channel.
@@ -310,31 +310,31 @@ IdeInitSubmitData (
/**
Disqualifies specific modes for an IDE device.

- This function allows the driver entity or other drivers (such as platform
+ This function allows the driver entity or other drivers (such as platform
drivers) to reject certain timing modes and request the IDE controller driver
- to recalculate modes. This function allows the driver entity and the IDE
- controller driver to negotiate the timings on a per-device basis. This function
- is useful in the case of drives that lie about their capabilities. An example
- is when the IDE device fails to accept the timing modes that are calculated
+ to recalculate modes. This function allows the driver entity and the IDE
+ controller driver to negotiate the timings on a per-device basis. This function
+ is useful in the case of drives that lie about their capabilities. An example
+ is when the IDE device fails to accept the timing modes that are calculated
by the IDE controller driver based on the response to the Identify Drive command.

- If the driver entity does not want to limit the ATA timing modes and leave that
- decision to the IDE controller driver, it can either not call this function for
- the given device or call this function and set the Valid flag to FALSE for all
+ If the driver entity does not want to limit the ATA timing modes and leave that
+ decision to the IDE controller driver, it can either not call this function for
+ the given device or call this function and set the Valid flag to FALSE for all
modes that are listed in EFI_ATA_COLLECTIVE_MODE.
-
- The driver entity may disqualify modes for a device in any order and any number
+
+ The driver entity may disqualify modes for a device in any order and any number
of times.
-
- This function can be called multiple times to invalidate multiple modes of the
- same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
- specification for more information on PIO modes.
-
+
+ This function can be called multiple times to invalidate multiple modes of the
+ same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
+ specification for more information on PIO modes.
+
For Serial ATA (SATA) controllers, this member function can be used to disqualify
a higher transfer rate mode on a given channel. For example, a platform driver
- may inform the IDE controller driver to not use second-generation (Gen2) speeds
+ may inform the IDE controller driver to not use second-generation (Gen2) speeds
for a certain SATA drive.
-
+
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel The zero-based channel number.
@param[in] Device The zero-based device number on the Channel.
@@ -345,7 +345,7 @@ IdeInitSubmitData (
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
@retval EFI_INVALID_PARAMETER Device is invalid.
@retval EFI_INVALID_PARAMETER IdentifyData is NULL.
-
+
**/
EFI_STATUS
EFIAPI
@@ -361,39 +361,39 @@ IdeInitDisqualifyMode (
Returns the information about the optimum modes for the specified IDE device.

This function is used by the driver entity to obtain the optimum ATA modes for
- a specific device. The IDE controller driver takes into account the following
+ a specific device. The IDE controller driver takes into account the following
while calculating the mode:
- The IdentifyData inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- The BadModes inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode()

- The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- for all the devices that belong to an enumeration group before calling
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
-
- The IDE controller driver will use controller- and possibly platform-specific
- algorithms to arrive at SupportedModes. The IDE controller may base its
- decision on user preferences and other considerations as well. This function
- may be called multiple times because the driver entity may renegotiate the mode
+ The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
+ for all the devices that belong to an enumeration group before calling
+ EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
+
+ The IDE controller driver will use controller- and possibly platform-specific
+ algorithms to arrive at SupportedModes. The IDE controller may base its
+ decision on user preferences and other considerations as well. This function
+ may be called multiple times because the driver entity may renegotiate the mode
with the IDE controller driver using EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode().
-
- The driver entity may collect timing information for various devices in any
+
+ The driver entity may collect timing information for various devices in any
order. The driver entity is responsible for making sure that all the dependencies
- are satisfied. For example, the SupportedModes information for device A that
- was previously returned may become stale after a call to
+ are satisfied. For example, the SupportedModes information for device A that
+ was previously returned may become stale after a call to
EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() for device B.
-
- The buffer SupportedModes is allocated by the callee because the caller does
- not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
- is defined in a way that allows for future extensibility and can be of variable
- length. This memory pool should be deallocated by the caller when it is no
- longer necessary.
-
- The IDE controller driver for a Serial ATA (SATA) controller can use this
- member function to force a lower speed (first-generation [Gen1] speeds on a
- second-generation [Gen2]-capable hardware). The IDE controller driver can
- also allow the driver entity to stay with the speed that has been negotiated
+
+ The buffer SupportedModes is allocated by the callee because the caller does
+ not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
+ is defined in a way that allows for future extensibility and can be of variable
+ length. This memory pool should be deallocated by the caller when it is no
+ longer necessary.
+
+ The IDE controller driver for a Serial ATA (SATA) controller can use this
+ member function to force a lower speed (first-generation [Gen1] speeds on a
+ second-generation [Gen2]-capable hardware). The IDE controller driver can
+ also allow the driver entity to stay with the speed that has been negotiated
by the physical layer.
-
+
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
@param[in] Channel A zero-based channel number.
@param[in] Device A zero-based device number on the Channel.
@@ -401,13 +401,13 @@ IdeInitDisqualifyMode (

@retval EFI_SUCCESS SupportedModes was returned.
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
- @retval EFI_INVALID_PARAMETER Device is invalid.
+ @retval EFI_INVALID_PARAMETER Device is invalid.
@retval EFI_INVALID_PARAMETER SupportedModes is NULL.
- @retval EFI_NOT_READY Modes cannot be calculated due to a lack of
- data. This error may happen if
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
- and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
- were not called for at least one drive in the
+ @retval EFI_NOT_READY Modes cannot be calculated due to a lack of
+ data. This error may happen if
+ EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
+ and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
+ were not called for at least one drive in the
same enumeration group.

**/
@@ -425,9 +425,9 @@ IdeInitCalculateMode (
Commands the IDE controller driver to program the IDE controller hardware
so that the specified device can operate at the specified mode.

- This function is used by the driver entity to instruct the IDE controller
- driver to program the IDE controller hardware to the specified modes. This
- function can be called only once for a particular device. For a Serial ATA
+ This function is used by the driver entity to instruct the IDE controller
+ driver to program the IDE controller hardware to the specified modes. This
+ function can be called only once for a particular device. For a Serial ATA
(SATA) Advanced Host Controller Interface (AHCI) controller, no controller-
specific programming may be required.

diff --git a/OvmfPkg/SataControllerDxe/SataControllerDxe.inf b/OvmfPkg/SataControllerDxe/SataControllerDxe.inf
index fbfe7145b043..2bc416971b79 100644
--- a/OvmfPkg/SataControllerDxe/SataControllerDxe.inf
+++ b/OvmfPkg/SataControllerDxe/SataControllerDxe.inf
@@ -1,10 +1,10 @@
## @file
-#
+#
# Component description file for the Sata Controller driver.
#
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
# SPDX-License-Identifier: BSD-2-Clause-Patent
-#
+#
##

[Defines]
@@ -39,5 +39,5 @@ [LibraryClasses]
UefiBootServicesTableLib

[Protocols]
- gEfiPciIoProtocolGuid
+ gEfiPciIoProtocolGuid
gEfiIdeControllerInitProtocolGuid
diff --git a/OvmfPkg/Sec/SecMain.c b/OvmfPkg/Sec/SecMain.c
index 3914355cd17b..bae9764577f0 100644
--- a/OvmfPkg/Sec/SecMain.c
+++ b/OvmfPkg/Sec/SecMain.c
@@ -51,7 +51,7 @@ TemporaryRamMigration (

//
//
-//
+//
EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mTemporaryRamSupportPpi = {
TemporaryRamMigration
};
@@ -74,7 +74,7 @@ IA32_IDT_GATE_DESCRIPTOR mIdtEntryTemplate = {
0x0, // Reserved_0
IA32_IDT_GATE_TYPE_INTERRUPT_32, // GateType
0xffff // OffsetHigh
- }
+ }
};

/**
@@ -685,7 +685,7 @@ FindAndReportEntryPoints (
ASSERT_EFI_ERROR (Status);

FindPeiCoreImageBase (BootFirmwareVolumePtr, &PeiCoreImageBase);
-
+
ZeroMem ((VOID *) &ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));
//
// Report SEC Core debug information when remote debug is enabled
@@ -753,7 +753,7 @@ SecCoreStartupWithStack (

//
// Initialize IDT
- //
+ //
IdtTableInStack.PeiService = NULL;
for (Index = 0; Index < SEC_IDT_ENTRY_COUNT; Index ++) {
CopyMem (&IdtTableInStack.IdtTable[Index], &mIdtEntryTemplate, sizeof (mIdtEntryTemplate));
@@ -814,13 +814,13 @@ SecCoreStartupWithStack (
//
InitializeApicTimer (0, MAX_UINT32, TRUE, 5);
DisableApicTimerInterrupt ();
-
+
//
// Initialize Debug Agent to support source level debug in SEC/PEI phases before memory ready.
//
InitializeDebugAgent (DEBUG_AGENT_INIT_PREMEM_SEC, &SecCoreData, SecStartupPhase2);
}
-
+
/**
Caller provided function to be invoked at the end of InitializeDebugAgent().

@@ -840,9 +840,9 @@ SecStartupPhase2(
EFI_SEC_PEI_HAND_OFF *SecCoreData;
EFI_FIRMWARE_VOLUME_HEADER *BootFv;
EFI_PEI_CORE_ENTRY_POINT PeiCoreEntryPoint;
-
+
SecCoreData = (EFI_SEC_PEI_HAND_OFF *) Context;
-
+
//
// Find PEI Core entry point. It will report SEC and Pei Core debug information if remote debug
// is enabled.
@@ -856,7 +856,7 @@ SecStartupPhase2(
// Transfer the control to the PEI core
//
(*PeiCoreEntryPoint) (SecCoreData, (EFI_PEI_PPI_DESCRIPTOR *)&mPrivateDispatchTable);
-
+
//
// If we get here then the PEI Core returned, which is not recoverable.
//
@@ -881,23 +881,23 @@ TemporaryRamMigration (
DEBUG_AGENT_CONTEXT_POSTMEM_SEC DebugAgentContext;
BOOLEAN OldStatus;
BASE_LIBRARY_JUMP_BUFFER JumpBuffer;
-
+
DEBUG ((EFI_D_INFO,
"TemporaryRamMigration(0x%Lx, 0x%Lx, 0x%Lx)\n",
TemporaryMemoryBase,
PermanentMemoryBase,
(UINT64)CopySize
));
-
+
OldHeap = (VOID*)(UINTN)TemporaryMemoryBase;
NewHeap = (VOID*)((UINTN)PermanentMemoryBase + (CopySize >> 1));
-
+
OldStack = (VOID*)((UINTN)TemporaryMemoryBase + (CopySize >> 1));
NewStack = (VOID*)(UINTN)PermanentMemoryBase;

DebugAgentContext.HeapMigrateOffset = (UINTN)NewHeap - (UINTN)OldHeap;
DebugAgentContext.StackMigrateOffset = (UINTN)NewStack - (UINTN)OldStack;
-
+
OldStatus = SaveAndSetDebugTimerInterrupt (FALSE);
InitializeDebugAgent (DEBUG_AGENT_INIT_POSTMEM_SEC, (VOID *) &DebugAgentContext, NULL);

@@ -910,7 +910,7 @@ TemporaryRamMigration (
// Migrate Stack
//
CopyMem (NewStack, OldStack, CopySize >> 1);
-
+
//
// Rebase IDT table in permanent memory
//
@@ -921,16 +921,16 @@ TemporaryRamMigration (

//
// Use SetJump()/LongJump() to switch to a new stack.
- //
+ //
if (SetJump (&JumpBuffer) == 0) {
#if defined (MDE_CPU_IA32)
JumpBuffer.Esp = JumpBuffer.Esp + DebugAgentContext.StackMigrateOffset;
JumpBuffer.Ebp = JumpBuffer.Ebp + DebugAgentContext.StackMigrateOffset;
-#endif
+#endif
#if defined (MDE_CPU_X64)
JumpBuffer.Rsp = JumpBuffer.Rsp + DebugAgentContext.StackMigrateOffset;
JumpBuffer.Rbp = JumpBuffer.Rbp + DebugAgentContext.StackMigrateOffset;
-#endif
+#endif
LongJump (&JumpBuffer, (UINTN)-1);
}

--
2.20.1


[PATCH 7/7] UefiCpuPkg: strip trailing whitespace

Leif Lindholm
 

Cc: Eric Dong <eric.dong@intel.com>
Cc: Ray Ni <ray.ni@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
UefiCpuPkg/Application/Cpuid/Cpuid.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/UefiCpuPkg/Application/Cpuid/Cpuid.c b/UefiCpuPkg/Application/Cpuid/Cpuid.c
index f39a7fb33ae5..cee64f2fb5fc 100644
--- a/UefiCpuPkg/Application/Cpuid/Cpuid.c
+++ b/UefiCpuPkg/Application/Cpuid/Cpuid.c
@@ -709,7 +709,7 @@ CpuidArchitecturalPerformanceMonitoring (
Display CPUID_EXTENDED_TOPOLOGY leafs for all supported levels.

@param[in] LeafFunction Leaf function index for CPUID_EXTENDED_TOPOLOGY.
-
+
**/
VOID
CpuidExtendedTopology (
--
2.20.1


[PATCH 3/7] BaseTools: strip trailing whitespace

Leif Lindholm
 

Cc: Bob Feng <bob.c.feng@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
BaseTools/Source/C/BrotliCompress/tools/brotli.c | 2 +-
BaseTools/Source/C/GNUmakefile | 2 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c | 20 ++---
BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c | 22 ++---
BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h | 8 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c | 70 ++++++++--------
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c | 40 +++++-----
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c | 30 +++----
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h | 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c | 194 ++++++++++++++++++++++----------------------
BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c | 6 +-
BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt | 92 ++++++++++-----------
BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt | 102 ++++++++++++------------
BaseTools/Source/C/Makefiles/app.makefile | 4 +-
BaseTools/Source/C/Makefiles/footer.makefile | 4 +-
BaseTools/Source/C/Makefiles/header.makefile | 8 +-
BaseTools/Source/C/Makefiles/lib.makefile | 2 +-
BaseTools/Source/C/Makefiles/ms.common | 4 +-
BaseTools/Source/C/VfrCompile/GNUmakefile | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt | 286 ++++++++++++++++++++++++++++++++---------------------------------
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt | 20 ++---
BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c | 194 ++++++++++++++++++++++----------------------
BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c | 18 ++---
BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c | 12 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c | 16 ++--
BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c | 16 ++--
BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c | 78 +++++++++---------
BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c | 40 +++++-----
BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c | 42 +++++-----
BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c | 4072 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c | 950 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c | 30 +++----
BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h | 22 ++---
BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp | 2 +-
BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp | 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h | 10 +--
BaseTools/Source/C/VfrCompile/Pccts/h/ast.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/h/err.h | 70 ++++++++--------
BaseTools/Source/C/VfrCompile/Pccts/history.txt | 6 +-
BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c | 14 ++--
BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c | 46 +++++------
BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c | 46 +++++------
BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h | 4 +-
BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c | 26 +++---
BaseTools/Source/Python/Ecc/Check.py | 2 +-
BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py | 2 +-
BaseTools/Source/Python/Makefile | 2 +-
75 files changed, 3404 insertions(+), 3404 deletions(-)

diff --git a/BaseTools/Source/C/BrotliCompress/tools/brotli.c b/BaseTools/Source/C/BrotliCompress/tools/brotli.c
index b0246e1ecf86..946da96013da 100644
--- a/BaseTools/Source/C/BrotliCompress/tools/brotli.c
+++ b/BaseTools/Source/C/BrotliCompress/tools/brotli.c
@@ -909,7 +909,7 @@ static BROTLI_BOOL DecompressFile(Context* context, BrotliDecoderState* s) {

/* Default brotli_alloc_func */
void* BrotliAllocFunc(void* opaque, size_t size) {
- *(size_t *)opaque = *(size_t *) opaque + size;
+ *(size_t *)opaque = *(size_t *) opaque + size;
return malloc(size);
}

diff --git a/BaseTools/Source/C/GNUmakefile b/BaseTools/Source/C/GNUmakefile
index 37bcce519c7e..df4eb64ea95e 100644
--- a/BaseTools/Source/C/GNUmakefile
+++ b/BaseTools/Source/C/GNUmakefile
@@ -77,7 +77,7 @@ $(SUBDIRS):
$(patsubst %,%-clean,$(sort $(SUBDIRS))):
-$(MAKE) -C $(@:-clean=) clean

-$(VFRAUTOGEN): VfrCompile/VfrSyntax.g
+$(VFRAUTOGEN): VfrCompile/VfrSyntax.g
$(MAKE) -C VfrCompile VfrLexer.h

clean: $(patsubst %,%-clean,$(sort $(SUBDIRS)))
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c
index e486901e3022..76169000d54d 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c
@@ -122,12 +122,12 @@ WRes File_Read(CSzFile *p, void *data, size_t *size)
return 0;

#else
-
+
*size = fread(data, 1, originalSize, p->file);
if (*size == originalSize)
return 0;
return ferror(p->file);
-
+
#endif
}

@@ -136,7 +136,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
size_t originalSize = *size;
if (originalSize == 0)
return 0;
-
+
#ifdef USE_WINDOWS_FILE

*size = 0;
@@ -162,7 +162,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
if (*size == originalSize)
return 0;
return ferror(p->file);
-
+
#endif
}

@@ -192,7 +192,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
return 0;

#else
-
+
int moveMethod;
int res;
switch (origin)
@@ -205,14 +205,14 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
res = fseek(p->file, (long)*pos, moveMethod);
*pos = ftell(p->file);
return res;
-
+
#endif
}

WRes File_GetLength(CSzFile *p, UInt64 *length)
{
#ifdef USE_WINDOWS_FILE
-
+
DWORD sizeHigh;
DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);
if (sizeLow == 0xFFFFFFFF)
@@ -223,15 +223,15 @@ WRes File_GetLength(CSzFile *p, UInt64 *length)
}
*length = (((UInt64)sizeHigh) << 32) + sizeLow;
return 0;
-
+
#else
-
+
long pos = ftell(p->file);
int res = fseek(p->file, 0, SEEK_END);
*length = ftell(p->file);
fseek(p->file, pos, SEEK_SET);
return res;
-
+
#endif
}

diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h
index 4977cdaa66d9..ab7baee4c4fa 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h
@@ -241,10 +241,10 @@ typedef struct
{
ILookInStream vt;
const ISeekInStream *realStream;
-
+
size_t pos;
size_t size; /* it's data size */
-
+
/* the following variables must be set outside */
Byte *buf;
size_t bufSize;
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c
index 30b499e5ff7c..dc8f17977cc1 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c
@@ -108,13 +108,13 @@ static void PrintAddr(void *p)
PrintHex(size, 10); \
PrintAddr(ptr); \
PrintLn();
-
+
#define PRINT_FREE(name, cnt, ptr) if (ptr) { \
Print(name " "); \
PrintDec(--cnt, 10); \
PrintAddr(ptr); \
PrintLn(); }
-
+
#else

#define PRINT_ALLOC(name, cnt, size, ptr)
@@ -147,7 +147,7 @@ void *MyAlloc(size_t size)
void MyFree(void *address)
{
PRINT_FREE("Free ", g_allocCount, address);
-
+
free(address);
}

@@ -157,9 +157,9 @@ void *MidAlloc(size_t size)
{
if (size == 0)
return NULL;
-
+
PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);
-
+
return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
}

@@ -203,7 +203,7 @@ void *BigAlloc(size_t size)
return NULL;

PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);
-
+
#ifdef _7ZIP_LARGE_PAGES
{
SIZE_T ps = g_LargePageSize;
@@ -228,7 +228,7 @@ void *BigAlloc(size_t size)
void BigFree(void *address)
{
PRINT_FREE("Free-Big", g_allocCountBig, address);
-
+
if (!address)
return;
VirtualFree(address, 0, MEM_RELEASE);
@@ -322,7 +322,7 @@ static int posix_memalign(void **ptr, size_t align, size_t size)
static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
{
#ifndef USE_posix_memalign
-
+
void *p;
void *pAligned;
size_t newSize;
@@ -336,7 +336,7 @@ static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
return NULL;

p = MyAlloc(newSize);
-
+
if (!p)
return NULL;
pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
@@ -402,7 +402,7 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)

if (alignSize < sizeof(void *))
alignSize = sizeof(void *);
-
+
if (p->offset >= alignSize)
return NULL;

@@ -414,7 +414,7 @@ static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
return NULL;

adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
-
+
if (!adr)
return NULL;

diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h
index aba8dce14f19..ecf7b0c44759 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h
@@ -11,23 +11,23 @@ EXTERN_C_BEGIN
/*
These functions convert relative addresses to absolute addresses
in CALL instructions to increase the compression ratio.
-
+
In:
data - data buffer
size - size of data
ip - current virtual Instruction Pinter (IP) value
state - state variable for x86 converter
encoding - 0 (for decoding), 1 (for encoding)
-
+
Out:
state - state variable for x86 converter

Returns:
The number of processed bytes. If you call these functions with multiple calls,
you must start next call with first byte after block of processed bytes.
-
+
Type Endian Alignment LookAhead
-
+
x86 little 1 4
ARMT little 2 2
ARM little 4 0
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c
index 6ea82a9b5344..507eb026f168 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c
@@ -73,7 +73,7 @@ static void MatchFinder_ReadBlock(CMatchFinder *p)
p->streamEndWasReached = 1;
return;
}
-
+
for (;;)
{
Byte *dest = p->buffer + (p->streamPos - p->pos);
@@ -180,24 +180,24 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
ISzAllocPtr alloc)
{
UInt32 sizeReserv;
-
+
if (historySize > kMaxHistorySize)
{
MatchFinder_Free(p, alloc);
return 0;
}
-
+
sizeReserv = historySize >> 1;
if (historySize >= ((UInt32)3 << 30)) sizeReserv = historySize >> 3;
else if (historySize >= ((UInt32)2 << 30)) sizeReserv = historySize >> 2;
-
+
sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);

p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
p->keepSizeAfter = matchMaxLen + keepAddBufferAfter;
-
+
/* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
-
+
if (LzInWindow_Create(p, sizeReserv, alloc))
{
UInt32 newCyclicBufferSize = historySize + 1;
@@ -243,7 +243,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
p->historySize = historySize;
p->hashSizeSum = hs;
p->cyclicBufferSize = newCyclicBufferSize;
-
+
numSons = newCyclicBufferSize;
if (p->btMode)
numSons <<= 1;
@@ -251,11 +251,11 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,

if (p->hash && p->numRefs == newSize)
return 1;
-
+
MatchFinder_FreeThisClassMemory(p, alloc);
p->numRefs = newSize;
p->hash = AllocRefs(newSize, alloc);
-
+
if (p->hash)
{
p->son = p->hash + p->hashSizeSum;
@@ -272,11 +272,11 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
{
UInt32 limit = kMaxValForNormalize - p->pos;
UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
-
+
if (limit2 < limit)
limit = limit2;
limit2 = p->streamPos - p->pos;
-
+
if (limit2 <= p->keepSizeAfter)
{
if (limit2 > 0)
@@ -284,10 +284,10 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
}
else
limit2 -= p->keepSizeAfter;
-
+
if (limit2 < limit)
limit = limit2;
-
+
{
UInt32 lenLimit = p->streamPos - p->pos;
if (lenLimit > p->matchMaxLen)
@@ -326,10 +326,10 @@ void MatchFinder_Init_3(CMatchFinder *p, int readData)
p->streamPos = p->cyclicBufferSize;
p->result = SZ_OK;
p->streamEndWasReached = 0;
-
+
if (readData)
MatchFinder_ReadBlock(p);
-
+
MatchFinder_SetLimits(p);
}

@@ -341,7 +341,7 @@ void MatchFinder_Init(CMatchFinder *p)
MatchFinder_Init_3(p, True);
}

-
+
static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
{
return (p->pos - p->historySize - 1) & kNormalizeMask;
@@ -584,7 +584,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
d2 = pos - hash[h2];

curMatch = (hash + kFix3HashSize)[hv];
-
+
hash[h2] = pos;
(hash + kFix3HashSize)[hv] = pos;

@@ -603,7 +603,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
GET_MATCHES_FOOTER(offset, maxLen)
}

@@ -629,14 +629,14 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

maxLen = 0;
offset = 0;
-
+
if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
{
distances[0] = maxLen = 2;
distances[1] = d2 - 1;
offset = 2;
}
-
+
if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
{
maxLen = 3;
@@ -644,7 +644,7 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d3;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -655,10 +655,10 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
if (maxLen < 3)
maxLen = 3;
-
+
GET_MATCHES_FOOTER(offset, maxLen)
}

@@ -710,7 +710,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset = 2;
d2 = d3;
}
-
+
if (d2 != d4 && d4 < p->cyclicBufferSize
&& *(cur - d4) == *cur
&& *(cur - d4 + 3) == *(cur + 3))
@@ -720,7 +720,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d4;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -734,7 +734,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

if (maxLen < 4)
maxLen = 4;
-
+
GET_MATCHES_FOOTER(offset, maxLen)
}
*/
@@ -749,10 +749,10 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

hash = p->hash;
pos = p->pos;
-
+
d2 = pos - hash[ h2];
d3 = pos - (hash + kFix3HashSize)[h3];
-
+
curMatch = (hash + kFix4HashSize)[hv];

hash[ h2] = pos;
@@ -768,7 +768,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
distances[1] = d2 - 1;
offset = 2;
}
-
+
if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
{
maxLen = 3;
@@ -776,7 +776,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d3;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -787,7 +787,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
if (maxLen < 3)
maxLen = 3;

@@ -807,7 +807,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

hash = p->hash;
pos = p->pos;
-
+
d2 = pos - hash[ h2];
d3 = pos - (hash + kFix3HashSize)[h3];
d4 = pos - (hash + kFix4HashSize)[h4];
@@ -844,7 +844,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset = 2;
d2 = d3;
}
-
+
if (d2 != d4 && d4 < p->cyclicBufferSize
&& *(cur - d4) == *cur
&& *(cur - d4 + 3) == *(cur + 3))
@@ -854,7 +854,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d4;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -865,7 +865,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
if (maxLen < 4)
maxLen = 4;

diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h
index c77added7bd3..61bb9dd302b5 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h
@@ -34,7 +34,7 @@ typedef struct _CMatchFinder

Byte *bufferBase;
ISeqInStream *stream;
-
+
UInt32 blockSize;
UInt32 keepSizeBefore;
UInt32 keepSizeAfter;
@@ -59,7 +59,7 @@ typedef struct _CMatchFinder
((p)->streamEndWasReached \
&& (p)->streamPos == (p)->pos \
&& (!(p)->directInput || (p)->directInputRem == 0))
-
+
int MatchFinder_NeedMove(CMatchFinder *p);
Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
void MatchFinder_MoveBlock(CMatchFinder *p);
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c
index 2563824fcdef..8e7cf6493ce3 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c
@@ -62,7 +62,7 @@ static void MtSync_StopWriting(CMtSync *p)
p->csWasEntered = False;
}
Semaphore_Release1(&p->freeSemaphore);
-
+
Event_Wait(&p->wasStopped);

while (myNumBlocks++ != p->numProcessedBlocks)
@@ -112,12 +112,12 @@ static SRes MtSync_Create2(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj,
RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart));
RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStarted));
RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped));
-
+
RINOK_THREAD(Semaphore_Create(&p->freeSemaphore, numBlocks, numBlocks));
RINOK_THREAD(Semaphore_Create(&p->filledSemaphore, 0, numBlocks));

p->needStart = True;
-
+
RINOK_THREAD(Thread_Create(&p->thread, startAddress, obj));
p->wasCreated = True;
return SZ_OK;
@@ -320,9 +320,9 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
UInt32 numProcessed = 0;
UInt32 curPos = 2;
UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2);
-
+
distances[1] = p->hashNumAvail;
-
+
while (curPos < limit)
{
if (p->hashBufPos == p->hashBufPosLimit)
@@ -352,7 +352,7 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
if (size2 < size)
size = size2;
}
-
+
#ifndef MFMT_GM_INLINE
while (curPos < limit && size-- != 0)
{
@@ -386,7 +386,7 @@ static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
p->cyclicBufferPos = cyclicBufferPos;
}
}
-
+
distances[0] = curPos;
}

@@ -398,7 +398,7 @@ static void BtFillBlock(CMatchFinderMt *p, UInt32 globalBlockIndex)
CriticalSection_Enter(&sync->cs);
sync->csWasEntered = True;
}
-
+
BtGetMatches(p, p->btBuf + (globalBlockIndex & kMtBtNumBlocksMask) * kMtBtBlockSize);

if (p->pos > kMtMaxValForNormalize - kMtBtBlockSize)
@@ -504,7 +504,7 @@ SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddB
static void MatchFinderMt_Init(CMatchFinderMt *p)
{
CMatchFinder *mf = p->MatchFinder;
-
+
p->btBufPos =
p->btBufPosLimit = 0;
p->hashBufPos =
@@ -513,7 +513,7 @@ static void MatchFinderMt_Init(CMatchFinderMt *p)
/* Init without data reading. We don't want to read data in this thread */
MatchFinder_Init_3(mf, False);
MatchFinder_Init_LowHash(mf);
-
+
p->pointerToCurPos = Inline_MatchFinder_GetPointerToCurrentPos(mf);
p->btNumAvailBytes = 0;
p->lzPos = p->historySize + 1;
@@ -577,7 +577,7 @@ static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
const Byte *cur = p->pointerToCurPos;
UInt32 lzPos = p->lzPos;
MT_HASH2_CALC
-
+
curMatch2 = hash[h2];
hash[h2] = lzPos;

@@ -587,7 +587,7 @@ static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
*distances++ = 2;
*distances++ = lzPos - curMatch2 - 1;
}
-
+
return distances;
}

@@ -601,7 +601,7 @@ static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista

curMatch2 = hash[ h2];
curMatch3 = (hash + kFix3HashSize)[h3];
-
+
hash[ h2] = lzPos;
(hash + kFix3HashSize)[h3] = lzPos;

@@ -616,13 +616,13 @@ static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *dista
distances[0] = 2;
distances += 2;
}
-
+
if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0])
{
*distances++ = 3;
*distances++ = lzPos - curMatch3 - 1;
}
-
+
return distances;
}

@@ -634,11 +634,11 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan
const Byte *cur = p->pointerToCurPos;
UInt32 lzPos = p->lzPos;
MT_HASH4_CALC
-
+
curMatch2 = hash[ h2];
curMatch3 = (hash + kFix3HashSize)[h3];
curMatch4 = (hash + kFix4HashSize)[h4];
-
+
hash[ h2] = lzPos;
(hash + kFix3HashSize)[h3] = lzPos;
(hash + kFix4HashSize)[h4] = lzPos;
@@ -654,7 +654,7 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan
distances[0] = 2;
distances += 2;
}
-
+
if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0])
{
distances[1] = lzPos - curMatch3 - 1;
@@ -676,7 +676,7 @@ static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distan
*distances++ = 4;
*distances++ = lzPos - curMatch4 - 1;
}
-
+
return distances;
}
*/
@@ -789,7 +789,7 @@ void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable)
vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinderMt_GetNumAvailableBytes;
vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinderMt_GetPointerToCurrentPos;
vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt_GetMatches;
-
+
switch (p->MatchFinder->numHashBytes)
{
case 2:
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h
index 3d86c788f3f9..b1398a883aaf 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h
@@ -60,7 +60,7 @@ typedef struct _CMatchFinderMt
const UInt32 *crc;

Mf_Mix_Matches MixMatchesFunc;
-
+
/* LZ + BT */
CMtSync btSync;
Byte btDummy[kMtCacheLineDummy];
@@ -83,7 +83,7 @@ typedef struct _CMatchFinderMt
/* BT + Hash */
CMtSync hashSync;
/* Byte hashDummy[kMtCacheLineDummy]; */
-
+
/* Hash */
Mf_GetHeads GetHeadsFunc;
CMatchFinder *MatchFinder;
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c
index 962b94bb6338..6328c9011aa0 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c
@@ -227,7 +227,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
Byte *dic = p->dic;
SizeT dicBufSize = p->dicBufSize;
SizeT dicPos = p->dicPos;
-
+
UInt32 processedPos = p->processedPos;
UInt32 checkDicSize = p->checkDicSize;
unsigned len = 0;
@@ -303,7 +303,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
dic[dicPos++] = (Byte)symbol;
continue;
}
-
+
{
UPDATE_1(prob);
prob = probs + IsRep + state;
@@ -370,7 +370,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
state = state < kNumLitStates ? 8 : 11;
prob = probs + RepLenCoder;
}
-
+
#ifdef _LZMA_SIZE_OPT
{
unsigned lim, offset;
@@ -474,7 +474,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
{
NORMALIZE
range >>= 1;
-
+
{
UInt32 t;
code -= range;
@@ -510,7 +510,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
}
}
}
-
+
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
@@ -529,13 +529,13 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
SizeT rem;
unsigned curLen;
SizeT pos;
-
+
if ((rem = limit - dicPos) == 0)
{
p->dicPos = dicPos;
return SZ_ERROR_DATA;
}
-
+
curLen = ((rem < len) ? (unsigned)rem : len);
pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);

@@ -568,7 +568,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
while (dicPos < limit && buf < bufLimit);

NORMALIZE;
-
+
p->buf = buf;
p->range = range;
p->code = code;
@@ -638,10 +638,10 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte
}

RINOK(LZMA_DECODE_REAL(p, limit2, bufLimit));
-
+
if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)
p->checkDicSize = p->prop.dicSize;
-
+
LzmaDec_WriteRem(p, limit);
}
while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
@@ -877,7 +877,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
{
SizeT inSize = *srcLen;
(*srcLen) = 0;
-
+
*status = LZMA_STATUS_NOT_SPECIFIED;

if (p->remainLen > kMatchSpecLenStart)
@@ -995,7 +995,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
p->buf = p->tempBuf;
if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
return SZ_ERROR_DATA;
-
+
{
unsigned kkk = (unsigned)(p->buf - p->tempBuf);
if (rem < kkk)
@@ -1011,7 +1011,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
p->tempBufSize = 0;
}
}
-
+
if (p->code != 0)
return SZ_ERROR_DATA;
*status = LZMA_STATUS_FINISHED_WITH_MARK;
@@ -1081,12 +1081,12 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
{
UInt32 dicSize;
Byte d;
-
+
if (size < LZMA_PROPS_SIZE)
return SZ_ERROR_UNSUPPORTED;
else
dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
-
+
if (dicSize < LZMA_DIC_MIN)
dicSize = LZMA_DIC_MIN;
p->dicSize = dicSize;
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h
index 28ce60c3ea94..ebc568cb4ff4 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h
@@ -135,7 +135,7 @@ LzmaDec_Allocate* can return:
SZ_ERROR_MEM - Memory allocation error
SZ_ERROR_UNSUPPORTED - Unsupported properties
*/
-
+
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);

@@ -164,7 +164,7 @@ void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);
*/

/* LzmaDec_DecodeToDic
-
+
The decoding to internal dictionary buffer (CLzmaDec::dic).
You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!

diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c
index e281716fee1b..d7931cd73799 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c
@@ -52,7 +52,7 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
int level = p->level;
if (level < 0) level = 5;
p->level = level;
-
+
if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level <= 7 ? (1 << 25) : (1 << 26)));
if (p->dictSize > p->reduceSize)
{
@@ -74,7 +74,7 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
if (p->numHashBytes < 0) p->numHashBytes = 4;
if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
-
+
if (p->numThreads < 0)
p->numThreads =
#ifndef _7ZIP_ST
@@ -124,7 +124,7 @@ static void LzmaEnc_FastPosInit(Byte *g_FastPos)
g_FastPos[0] = 0;
g_FastPos[1] = 1;
g_FastPos += 2;
-
+
for (slot = 2; slot < kNumLogBits * 2; slot++)
{
size_t k = ((size_t)1 << ((slot >> 1) - 1));
@@ -273,7 +273,7 @@ typedef struct

CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
CLzmaProb posEncoders[kNumFullDistances];
-
+
CLenEnc lenProbs;
CLenEnc repLenProbs;

@@ -315,7 +315,7 @@ typedef struct
Bool needInit;

UInt64 nowPos64;
-
+
unsigned matchPriceCount;
unsigned alignPriceCount;

@@ -336,7 +336,7 @@ typedef struct
#ifndef _7ZIP_ST
Byte pad[128];
#endif
-
+
// LZ thread
CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

@@ -355,7 +355,7 @@ typedef struct
CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
CLzmaProb posEncoders[kNumFullDistances];
-
+
CLenEnc lenProbs;
CLenEnc repLenProbs;

@@ -383,9 +383,9 @@ void LzmaEnc_SaveState(CLzmaEncHandle pp)
{
CLzmaEnc *p = (CLzmaEnc *)pp;
CSaveState *dest = &p->saveState;
-
+
dest->state = p->state;
-
+
dest->lenProbs = p->lenProbs;
dest->repLenProbs = p->repLenProbs;

@@ -414,9 +414,9 @@ void LzmaEnc_RestoreState(CLzmaEncHandle pp)

dest->lenProbs = p->lenProbs;
dest->repLenProbs = p->repLenProbs;
-
+
COPY_ARR(dest, p, reps);
-
+
COPY_ARR(dest, p, posAlignEncoder);
COPY_ARR(dest, p, isRep);
COPY_ARR(dest, p, isRepG0);
@@ -914,7 +914,7 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates,
printf("\n MovePos %u", num);
#endif
*/
-
+
#define MOVE_POS(p, num) { \
p->additionalOffset += (num); \
p->matchFinder.Skip(p->matchFinderObj, (num)); }
@@ -923,12 +923,12 @@ static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, unsigned numPosStates,
static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
{
unsigned numPairs;
-
+
p->additionalOffset++;
p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
*numPairsRes = numPairs;
-
+
#ifdef SHOW_STAT
printf("\n i = %u numPairs = %u ", g_STAT_OFFSET, numPairs / 2);
g_STAT_OFFSET++;
@@ -938,7 +938,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
printf("%2u %6u | ", p->matches[i], p->matches[i + 1]);
}
#endif
-
+
if (numPairs == 0)
return 0;
{
@@ -976,7 +976,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
+ GET_PRICE_1(p->isRep0Long[state][posState])) \
+ GET_PRICE_1(p->isRep[state]) \
+ GET_PRICE_0(p->isRepG0[state])
-
+

static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState)
{
@@ -1042,7 +1042,7 @@ static unsigned Backward(CLzmaEnc *p, unsigned cur)
p->optCur = wr;
return len;
}
-
+
wr--;
p->opt[wr].dist = dist;
p->opt[wr].len = len;
@@ -1068,9 +1068,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
UInt32 matchPrice, repMatchPrice;
const Byte *data;
Byte curByte, matchByte;
-
+
p->optCur = p->optEnd = 0;
-
+
if (p->additionalOffset == 0)
mainLen = ReadMatchDistances(p, &numPairs);
else
@@ -1078,7 +1078,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
mainLen = p->longestMatchLen;
numPairs = p->numPairs;
}
-
+
numAvail = p->numAvail;
if (numAvail < 2)
{
@@ -1087,10 +1087,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}
if (numAvail > LZMA_MATCH_LEN_MAX)
numAvail = LZMA_MATCH_LEN_MAX;
-
+
data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
repMaxIndex = 0;
-
+
for (i = 0; i < LZMA_NUM_REPS; i++)
{
unsigned len;
@@ -1107,7 +1107,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
if (len > repLens[repMaxIndex])
repMaxIndex = i;
}
-
+
if (repLens[repMaxIndex] >= p->numFastBytes)
{
unsigned len;
@@ -1116,29 +1116,29 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
MOVE_POS(p, len - 1)
return len;
}
-
+
matches = p->matches;
-
+
if (mainLen >= p->numFastBytes)
{
p->backRes = matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;
MOVE_POS(p, mainLen - 1)
return mainLen;
}
-
+
curByte = *data;
matchByte = *(data - reps[0]);
-
+
if (mainLen < 2 && curByte != matchByte && repLens[repMaxIndex] < 2)
{
p->backRes = MARK_LIT;
return 1;
}
-
+
p->opt[0].state = (CState)p->state;
-
+
posState = (position & p->pbMask);
-
+
{
const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +
@@ -1146,12 +1146,12 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
LitEnc_GetPrice(probs, curByte, p->ProbPrices));
}
-
+
MakeAs_Lit(&p->opt[1]);
-
+
matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);
repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);
-
+
if (matchByte == curByte)
{
UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, p->state, posState);
@@ -1161,22 +1161,22 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
MakeAs_ShortRep(&p->opt[1]);
}
}
-
+
last = (mainLen >= repLens[repMaxIndex] ? mainLen : repLens[repMaxIndex]);
-
+
if (last < 2)
{
p->backRes = p->opt[1].dist;
return 1;
}
-
+
p->opt[1].len = 1;
-
+
p->opt[0].reps[0] = reps[0];
p->opt[0].reps[1] = reps[1];
p->opt[0].reps[2] = reps[2];
p->opt[0].reps[3] = reps[3];
-
+
{
unsigned len = last;
do
@@ -1185,7 +1185,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}

// ---------- REP ----------
-
+
for (i = 0; i < LZMA_NUM_REPS; i++)
{
unsigned repLen = repLens[i];
@@ -1207,8 +1207,8 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}
while (--repLen >= 2);
}
-
-
+
+
// ---------- MATCH ----------
{
unsigned len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);
@@ -1219,14 +1219,14 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)

while (len > matches[offs])
offs += 2;
-
+
for (; ; len++)
{
COptimal *opt;
UInt32 dist = matches[(size_t)offs + 1];
UInt32 price2 = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN];
unsigned lenToPosState = GetLenToPosState(len);
-
+
if (dist < kNumFullDistances)
price2 += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];
else
@@ -1236,9 +1236,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
price2 += p->alignPrices[dist & kAlignMask];
price2 += p->posSlotPrices[lenToPosState][slot];
}
-
+
opt = &p->opt[len];
-
+
if (price2 < opt->price)
{
opt->price = price2;
@@ -1246,7 +1246,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
opt->dist = dist + LZMA_NUM_REPS;
opt->extra = 0;
}
-
+
if (len == matches[offs])
{
offs += 2;
@@ -1256,7 +1256,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}
}
}
-
+

cur = 0;

@@ -1272,7 +1272,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}


-
+
// ---------- Optimal Parsing ----------

for (;;)
@@ -1289,17 +1289,17 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
return Backward(p, cur);

newLen = ReadMatchDistances(p, &numPairs);
-
+
if (newLen >= p->numFastBytes)
{
p->numPairs = numPairs;
p->longestMatchLen = newLen;
return Backward(p, cur);
}
-
+
curOpt = &p->opt[cur];
prev = cur - curOpt->len;
-
+
if (curOpt->len == 1)
{
state = p->opt[prev].state;
@@ -1368,7 +1368,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
reps[3] = prevOpt->reps[2];
}
}
-
+
curOpt->state = (CState)state;
curOpt->reps[0] = reps[0];
curOpt->reps[1] = reps[1];
@@ -1403,7 +1403,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
litPrice += (!IsLitState(state) ?
LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
LitEnc_GetPrice(probs, curByte, p->ProbPrices));
-
+
if (litPrice < nextOpt->price)
{
nextOpt->price = litPrice;
@@ -1415,7 +1415,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)

matchPrice = curPrice + GET_PRICE_1(p->isMatch[state][posState]);
repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]);
-
+
// ---------- SHORT_REP ----------
// if (IsLitState(state)) // 18.new
if (matchByte == curByte)
@@ -1435,7 +1435,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
nextIsLit = False;
}
}
-
+
numAvailFull = p->numAvail;
{
UInt32 temp = kNumOpts - 1 - cur;
@@ -1467,7 +1467,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
for (len = 3; len < limit && data[len] == data2[len]; len++)
{
}
-
+
{
unsigned state2 = kLiteralNextStates[state];
unsigned posState2 = (position + 1) & p->pbMask;
@@ -1476,7 +1476,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
unsigned offset = cur + len;
while (last < offset)
p->opt[++last].price = kInfinityPrice;
-
+
// do
{
UInt32 price2;
@@ -1500,7 +1500,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}
}
}
-
+
startLen = 2; /* speed optimization */
{
// ---------- REP ----------
@@ -1513,9 +1513,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
const Byte *data2 = data - reps[repIndex];
if (data[0] != data2[0] || data[1] != data2[1])
continue;
-
+
for (len = 2; len < numAvail && data[len] == data2[len]; len++);
-
+
// if (len < startLen) continue; // 18.new: speed optimization

while (last < cur + len)
@@ -1537,7 +1537,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}
while (--len2 >= 2);
}
-
+
if (repIndex == 0) startLen = len + 1; // 17.old
// startLen = len + 1; // 18.new

@@ -1550,9 +1550,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
unsigned limit = len2 + p->numFastBytes;
if (limit > numAvailFull)
limit = numAvailFull;
-
+
for (; len2 < limit && data[len2] == data2[len2]; len2++);
-
+
len2 -= len;
if (len2 >= 3)
{
@@ -1563,7 +1563,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
+ GET_PRICE_0(p->isMatch[state2][posState2])
+ LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),
data[len], data2[len], p->ProbPrices);
-
+
// state2 = kLiteralNextStates[state2];
state2 = kState_LitAfterRep;
posState2 = (posState2 + 1) & p->pbMask;
@@ -1609,7 +1609,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
matches[numPairs] = newLen;
numPairs += 2;
}
-
+
if (newLen >= startLen)
{
UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
@@ -1622,10 +1622,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
while (startLen > matches[offs])
offs += 2;
dist = matches[(size_t)offs + 1];
-
+
// if (dist >= kNumFullDistances)
GetPosSlot2(dist, posSlot);
-
+
for (len = /*2*/ startLen; ; len++)
{
UInt32 price = normalMatchPrice + p->lenEnc.prices[posState][(size_t)len - LZMA_MATCH_LEN_MIN];
@@ -1636,7 +1636,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];
else
price += p->posSlotPrices[lenToPosState][posSlot] + p->alignPrices[dist & kAlignMask];
-
+
opt = &p->opt[cur + len];
if (price < opt->price)
{
@@ -1656,11 +1656,11 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
unsigned limit = len2 + p->numFastBytes;
if (limit > numAvailFull)
limit = numAvailFull;
-
+
for (; len2 < limit && data[len2] == data2[len2]; len2++);
-
+
len2 -= len;
-
+
if (len2 >= 3)
{
unsigned state2 = kMatchNextStates[state];
@@ -1698,7 +1698,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
}
// while (len2 >= 3);
}
-
+
offs += 2;
if (offs == numPairs)
break;
@@ -1739,7 +1739,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
numAvail = LZMA_MATCH_LEN_MAX;
data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
repLen = repIndex = 0;
-
+
for (i = 0; i < LZMA_NUM_REPS; i++)
{
unsigned len;
@@ -1768,7 +1768,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
}

mainDist = 0; /* for GCC */
-
+
if (mainLen >= 2)
{
mainDist = p->matches[(size_t)numPairs - 1];
@@ -1797,14 +1797,14 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
MOVE_POS(p, repLen - 1)
return repLen;
}
-
+
if (mainLen < 2 || numAvail <= 2)
return 1;

{
unsigned len1 = ReadMatchDistances(p, &p->numPairs);
p->longestMatchLen = len1;
-
+
if (len1 >= 2)
{
UInt32 newDist = p->matches[(size_t)p->numPairs - 1];
@@ -1815,9 +1815,9 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
return 1;
}
}
-
+
data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
-
+
for (i = 0; i < LZMA_NUM_REPS; i++)
{
unsigned len, limit;
@@ -1833,7 +1833,7 @@ static unsigned GetOptimumFast(CLzmaEnc *p)
break;
}
}
-
+
p->backRes = mainDist + LZMA_NUM_REPS;
if (mainLen != 2)
{
@@ -1859,7 +1859,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
RC_BIT_0(&p->rc, prob)
}
p->state = kMatchNextStates[p->state];
-
+
p->rc.range = range;
LenEnc_Encode(&p->lenProbs, &p->rc, 0, posState);
range = p->rc.range;
@@ -1888,7 +1888,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
}
while (--numBits);
}
-
+
{
// RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);
CLzmaProb *probs = p->posAlignEncoder;
@@ -2037,7 +2037,7 @@ void LzmaEnc_Construct(CLzmaEnc *p)
{
RangeEnc_Construct(&p->rc);
MatchFinder_Construct(&p->matchFinderBase);
-
+
#ifndef _7ZIP_ST
MatchFinderMt_Construct(&p->matchFinderMt);
p->matchFinderMt.MatchFinder = &p->matchFinderBase;
@@ -2081,7 +2081,7 @@ void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
#ifndef _7ZIP_ST
MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
#endif
-
+
MatchFinder_Free(&p->matchFinderBase, allocBig);
LzmaEnc_FreeLits(p, alloc);
RangeEnc_Free(&p->rc, alloc);
@@ -2126,14 +2126,14 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
}

if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)
-
+
for (;;)
{
UInt32 dist;
unsigned len, posState;
UInt32 range, ttt, newBound;
CLzmaProb *probs;
-
+
if (p->fastMode)
len = GetOptimumFast(p);
else
@@ -2153,9 +2153,9 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
posState = (unsigned)nowPos32 & p->pbMask;
range = p->rc.range;
probs = &p->isMatch[p->state][posState];
-
+
RC_BIT_PRE(&p->rc, probs)
-
+
dist = p->backRes;

#ifdef SHOW_STAT2
@@ -2185,7 +2185,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
RC_BIT_1(&p->rc, probs);
probs = &p->isRep[p->state];
RC_BIT_PRE(&p->rc, probs)
-
+
if (dist < LZMA_NUM_REPS)
{
RC_BIT_1(&p->rc, probs);
@@ -2269,7 +2269,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
p->reps[2] = p->reps[1];
p->reps[1] = p->reps[0];
p->reps[0] = dist + 1;
-
+
p->matchPriceCount++;
GetPosSlot(dist, posSlot);
// RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot);
@@ -2287,7 +2287,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
while (symbol < (1 << kNumPosSlotBits * 2));
p->rc.range = range;
}
-
+
if (dist >= kStartPosModelIndex)
{
unsigned footerBits = ((posSlot >> 1) - 1);
@@ -2340,7 +2340,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa

nowPos32 += len;
p->additionalOffset -= len;
-
+
if (p->additionalOffset == 0)
{
UInt32 processed;
@@ -2352,11 +2352,11 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
if (p->alignPriceCount >= kAlignTableSize)
FillAlignPrices(p);
}
-
+
if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
break;
processed = nowPos32 - startPos32;
-
+
if (maxPackSize)
{
if (processed + kNumOpts + 300 >= maxUnpackSize
@@ -2430,7 +2430,7 @@ static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc,
p->matchFinderObj = &p->matchFinderBase;
MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);
}
-
+
return SZ_OK;
}

@@ -2644,7 +2644,7 @@ SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
return SZ_ERROR_OUTPUT_EOF;

res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);
-
+
*unpackSize = (UInt32)(p->nowPos64 - nowPos64);
*destLen -= outStream.rem;
if (outStream.overflow)
@@ -2679,7 +2679,7 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
}
}
}
-
+
LzmaEnc_Finish(p);

/*
@@ -2751,7 +2751,7 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte
p->rc.outStream = &outStream.vt;

res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
-
+
if (res == SZ_OK)
{
res = LzmaEnc_Encode2(p, progress);
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c b/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c
index 8fd86f224be7..9a29839fe8fe 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c
@@ -34,9 +34,9 @@ WRes Handle_WaitObject(HANDLE h) { return (WRes)WaitForSingleObject(h, INFINITE)
WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
{
/* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
-
+
#ifdef UNDER_CE
-
+
DWORD threadId;
*p = CreateThread(0, 0, func, param, 0, &threadId);

@@ -44,7 +44,7 @@ WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)

unsigned threadId;
*p = (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId);
-
+
#endif

/* maybe we must use errno here, but probably GetLastError() is also OK. */
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt
index d7426d38a4dd..a8d75ed7095d 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt
@@ -3,11 +3,11 @@ HISTORY of the LZMA SDK

18.05 2018-04-30
-------------------------
-- The speed for LZMA/LZMA2 compressing was increased
- by 8% for fastest/fast compression levels and
+- The speed for LZMA/LZMA2 compressing was increased
+ by 8% for fastest/fast compression levels and
by 3% for normal/maximum compression levels.
- Previous versions of 7-Zip could work incorrectly in "Large memory pages" mode in
- Windows 10 because of some BUG with "Large Pages" in Windows 10.
+ Windows 10 because of some BUG with "Large Pages" in Windows 10.
Now 7-Zip doesn't use "Large Pages" on Windows 10 up to revision 1709 (16299).
- The BUG was fixed in Lzma2Enc.c
Lzma2Enc_Encode2() function worked incorretly,
@@ -16,7 +16,7 @@ HISTORY of the LZMA SDK

18.03 beta 2018-03-04
-------------------------
-- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
+- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
for x64 with about 30% higher speed than main version of LZMA decoder written in C.
- The speed for single-thread LZMA/LZMA2 decoder written in C was increased by 3%.
- 7-Zip now can use multi-threading for 7z/LZMA2 decoding,
@@ -35,7 +35,7 @@ HISTORY of the LZMA SDK
18.00 beta 2019-01-10
-------------------------
- The BUG in xz encoder was fixed:
- There was memory leak of 16 KB for each file compressed with
+ There was memory leak of 16 KB for each file compressed with
xz compression method, if additional filter was used.


@@ -44,7 +44,7 @@ HISTORY of the LZMA SDK
- Minor speed optimization for LZMA2 (xz and 7z) multi-threading compression.
7-Zip now uses additional memory buffers for multi-block LZMA2 compression.
CPU utilization was slightly improved.
-- 7-zip now creates multi-block xz archives by default. Block size can be
+- 7-zip now creates multi-block xz archives by default. Block size can be
specified with -ms[Size]{m|g} switch.
- xz decoder now can unpack random block from multi-block xz archives.
- 7-Zip command line: @listfile now doesn't work after -- switch.
@@ -55,7 +55,7 @@ HISTORY of the LZMA SDK

17.00 beta 2017-04-29
-------------------------
-- NewHandler.h / NewHandler.cpp:
+- NewHandler.h / NewHandler.cpp:
now it redefines operator new() only for old MSVC compilers (_MSC_VER < 1900).
- C/7zTypes.h : the names of variables in interface structures were changed (vt).
- Some bugs were fixed. 7-Zip could crash in some cases.
@@ -76,51 +76,51 @@ HISTORY of the LZMA SDK
16.02 2016-05-21
-------------------------
- The BUG in 16.00 - 16.01 was fixed:
- Split Handler (SplitHandler.cpp) returned incorrect
+ Split Handler (SplitHandler.cpp) returned incorrect
total size value (kpidSize) for split archives.


16.01 2016-05-19
--------------------------
+-------------------------
- Some internal changes to reduce the number of compiler warnings.


16.00 2016-05-10
--------------------------
+-------------------------
- Some bugs were fixed.


15.12 2015-11-19
--------------------------
+-------------------------
- The BUG in C version of 7z decoder was fixed:
7zDec.c : SzDecodeLzma2()
7z decoder could mistakenly report about decoding error for some 7z archives
that use LZMA2 compression method.
- The probability to get that mistaken decoding error report was about
- one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
+ The probability to get that mistaken decoding error report was about
+ one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
- The BUG (in 9.26-15.11) in C version of 7z decoder was fixed:
7zArcIn.c : SzReadHeader2()
- 7z decoder worked incorrectly for 7z archives that contain
- empty solid blocks, that can be placed to 7z archive, if some file is
+ 7z decoder worked incorrectly for 7z archives that contain
+ empty solid blocks, that can be placed to 7z archive, if some file is
unavailable for reading during archive creation.


15.09 beta 2015-10-16
--------------------------
+-------------------------
- The BUG in LZMA / LZMA2 encoding code was fixed.
The BUG in LzFind.c::MatchFinder_ReadBlock() function.
If input data size is larger than (4 GiB - dictionary_size),
the following code worked incorrectly:
- - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
- for compressing from memory to memory.
+ - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
+ for compressing from memory to memory.
That BUG is not related to LZMA encoder version that works via streams.
- - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
- default value of chunk size (CLzma2EncProps::blockSize) is changed
+ - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
+ default value of chunk size (CLzma2EncProps::blockSize) is changed
to value larger than (4 GiB - dictionary_size).


9.38 beta 2015-01-03
--------------------------
+-------------------------
- The BUG in 9.31-9.37 was fixed:
IArchiveGetRawProps interface was disabled for 7z archives.
- The BUG in 9.26-9.36 was fixed:
@@ -128,10 +128,10 @@ HISTORY of the LZMA SDK


9.36 beta 2014-12-26
--------------------------
+-------------------------
- The BUG in command line version was fixed:
7-Zip created temporary archive in current folder during update archive
- operation, if -w{Path} switch was not specified.
+ operation, if -w{Path} switch was not specified.
The fixed 7-Zip creates temporary archive in folder that contains updated archive.
- The BUG in 9.33-9.35 was fixed:
7-Zip silently ignored file reading errors during 7z or gz archive creation,
@@ -140,14 +140,14 @@ HISTORY of the LZMA SDK


9.35 beta 2014-12-07
--------------------------
+-------------------------
- 7zr.exe now support AES encryption.
- SFX modules were added to LZMA SDK
- Some bugs were fixed.


9.21 beta 2011-04-11
--------------------------
+-------------------------
- New class FString for file names at file systems.
- Speed optimization in CRC code for big-endian CPUs.
- The BUG in Lzma2Dec.c was fixed:
@@ -155,7 +155,7 @@ HISTORY of the LZMA SDK


9.18 beta 2010-11-02
--------------------------
+-------------------------
- New small SFX module for installers (SfxSetup).


@@ -168,7 +168,7 @@ HISTORY of the LZMA SDK
9.11 beta 2010-03-15
-------------------------
- PPMd compression method support
-
+

9.09 2009-12-12
-------------------------
@@ -202,7 +202,7 @@ HISTORY of the LZMA SDK
4.61 beta 2008-11-23
-------------------------
- The bug in ANSI-C LZMA Decoder was fixed:
- If encoded stream was corrupted, decoder could access memory
+ If encoded stream was corrupted, decoder could access memory
outside of allocated range.
- Some changes in ANSI-C 7z Decoder interfaces.
- LZMA SDK is placed in the public domain.
@@ -216,7 +216,7 @@ HISTORY of the LZMA SDK
4.59 beta 2008-08-13
-------------------------
- The bug was fixed:
- LZMA Encoder in fast compression mode could access memory outside of
+ LZMA Encoder in fast compression mode could access memory outside of
allocated range in some rare cases.


@@ -229,7 +229,7 @@ HISTORY of the LZMA SDK

4.57 2007-12-12
-------------------------
-- Speed optimizations in ?++ LZMA Decoder.
+- Speed optimizations in ?++ LZMA Decoder.
- Small changes for more compatibility with some C/C++ compilers.


@@ -239,36 +239,36 @@ HISTORY of the LZMA SDK
- now it supports BCJ and BCJ2 filters
- now it supports files larger than 4 GB.
- now it supports "Last Write Time" field for files.
-- C++ code for .7z archives compressing/decompressing from 7-zip
+- C++ code for .7z archives compressing/decompressing from 7-zip
was included to LZMA SDK.
-
+

4.43 2006-06-04
-------------------------
- Small changes for more compatibility with some C/C++ compilers.
-
+

4.42 2006-05-15
-------------------------
- Small changes in .h files in ANSI-C version.
-
+

4.39 beta 2006-04-14
-------------------------
- The bug in versions 4.33b:4.38b was fixed:
- C++ version of LZMA encoder could not correctly compress
+ C++ version of LZMA encoder could not correctly compress
files larger than 2 GB with HC4 match finder (-mfhc4).
-
+

4.37 beta 2005-04-06
-------------------------
-- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.
+- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.


4.35 beta 2005-03-02
-------------------------
- The bug was fixed in C++ version of LZMA Decoder:
- If encoded stream was corrupted, decoder could access memory
+ If encoded stream was corrupted, decoder could access memory
outside of allocated range.


@@ -339,7 +339,7 @@ HISTORY of the LZMA SDK

4.17 2005-04-18
-------------------------
-- New example for RAM->RAM compressing/decompressing:
+- New example for RAM->RAM compressing/decompressing:
LZMA + BCJ (filter for x86 code):
- LzmaRam.h
- LzmaRam.cpp
@@ -350,11 +350,11 @@ HISTORY of the LZMA SDK

4.16 2005-03-29
-------------------------
-- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
+- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
If _LZMA_OUT_READ was defined, and if encoded stream was corrupted,
decoder could access memory outside of allocated range.
- Speed optimization of ANSI-C LZMA Decoder (now it's about 20% faster).
- Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
+ Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
LzmaDecodeSize.c can provide slightly smaller code than LzmaDecode.c
- Small speed optimization in LZMA C++ code
- filter for SPARC's code was added
@@ -369,7 +369,7 @@ HISTORY of the LZMA SDK

4.05 2004-08-25
-------------------------
-- Source code of filters for x86, IA-64, ARM, ARM-Thumb
+- Source code of filters for x86, IA-64, ARM, ARM-Thumb
and PowerPC code was included to SDK
- Some internal minor changes

@@ -381,8 +381,8 @@ HISTORY of the LZMA SDK

4.03 2004-06-18
-------------------------
-- "Benchmark" command was added. It measures compressing
- and decompressing speed and shows rating values.
+- "Benchmark" command was added. It measures compressing
+ and decompressing speed and shows rating values.
Also it checks hardware errors.


@@ -411,7 +411,7 @@ HISTORY of the LZMA SDK

HISTORY of the LZMA
-------------------
- 2001-2008: Improvements to LZMA compressing/decompressing code,
+ 2001-2008: Improvements to LZMA compressing/decompressing code,
keeping compatibility with original LZMA format
1996-2001: Development of LZMA compression format

@@ -419,6 +419,6 @@ HISTORY of the LZMA

2001-08-30: LZMA compression was added to 7-Zip
1999-01-02: First version of 7-Zip was released
-
+

End of document
diff --git a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt
index a3deb2094335..914bd19e90be 100644
--- a/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt
+++ b/BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt
@@ -2,15 +2,15 @@ LZMA SDK 18.05
--------------

LZMA SDK provides the documentation, samples, header files,
-libraries, and tools you need to develop applications that
+libraries, and tools you need to develop applications that
use 7z / LZMA / LZMA2 / XZ compression.

-LZMA is an improved version of famous LZ77 compression algorithm.
+LZMA is an improved version of famous LZ77 compression algorithm.
It was improved in way of maximum increasing of compression ratio,
-keeping high decompression speed and low memory requirements for
+keeping high decompression speed and low memory requirements for
decompressing.

-LZMA2 is a LZMA based compression method. LZMA2 provides better
+LZMA2 is a LZMA based compression method. LZMA2 provides better
multithreading support for compression than LZMA and some other improvements.

7z is a file format for data compression and file archiving.
@@ -19,7 +19,7 @@ multithreading support for compression than LZMA and some other improvements.
7z also supports AES-256 based encryption.

XZ is a file format for data compression that uses LZMA2 compression.
-XZ format provides additional features: SHA/CRC check, filters for
+XZ format provides additional features: SHA/CRC check, filters for
improved compression ratio, splitting to blocks and streams,


@@ -33,11 +33,11 @@ Some code in LZMA SDK is based on public domain code from another developers:
1) PPMd var.H (2001): Dmitry Shkarin
2) SHA-256: Wei Dai (Crypto++ library)

-Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
-original LZMA SDK code, either in source code form or as a compiled binary, for
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
+original LZMA SDK code, either in source code form or as a compiled binary, for
any purpose, commercial or non-commercial, and by any means.

-LZMA SDK code is compatible with open source licenses, for example, you can
+LZMA SDK code is compatible with open source licenses, for example, you can
include it to GNU GPL or GNU LGPL code.


@@ -60,7 +60,7 @@ LZMA SDK Contents
- SFX modules for installers.


-UNIX/Linux version
+UNIX/Linux version
------------------
To compile C++ version of file->file LZMA encoding, go to directory
CPP/7zip/Bundles/LzmaCon
@@ -68,11 +68,11 @@ and call make to recompile it:
make -f makefile.gcc clean all

In some UNIX/Linux versions you must compile LZMA with static libraries.
-To compile with static libraries, you can use
+To compile with static libraries, you can use
LIB = -lm -static

Also you can use p7zip (port of 7-Zip for POSIX systems like Unix or Linux):
-
+
http://p7zip.sourceforge.net/


@@ -120,7 +120,7 @@ C/ - C files (compression / decompression and other)
7z - 7z decoder program (decoding 7z files)
Lzma - LZMA program (file->file LZMA encoder/decoder).
LzmaLib - LZMA library (.DLL for Windows)
- SfxSetup - small SFX module for installers
+ SfxSetup - small SFX module for installers

CPP/ -- CPP files

@@ -135,7 +135,7 @@ CPP/ -- CPP files
7z - 7z C++ Encoder/Decoder

Bundles - Modules that are bundles of other modules (files)
-
+
Alone7z - 7zr.exe: Standalone 7-Zip console program (reduced version)
Format7zExtractR - 7zxr.dll: Reduced version of 7z DLL: extracting from 7z/LZMA/BCJ/BCJ2.
Format7zR - 7zr.dll: Reduced version of 7z DLL: extracting/compressing to 7z/LZMA/BCJ/BCJ2
@@ -152,7 +152,7 @@ CPP/ -- CPP files
Crypto - files for encryption / decompression

UI - User Interface files
-
+
Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll
Common - Common UI files
Console - Code for console program (7z.exe)
@@ -178,7 +178,7 @@ Java/ - Java files
RangeCoder - Range Coder (special code of compression/decompression)


-Note:
+Note:
Asm / C / C++ source code of LZMA SDK is part of 7-Zip's source code.
7-Zip's source code can be downloaded from 7-Zip's SourceForge page:

@@ -190,13 +190,13 @@ LZMA features
-------------
- Variable dictionary size (up to 1 GB)
- Estimated compressing speed: about 2 MB/s on 2 GHz CPU
- - Estimated decompressing speed:
+ - Estimated decompressing speed:
- 20-30 MB/s on modern 2 GHz cpu
- 1-2 MB/s on 200 MHz simple RISC cpu: (ARM, MIPS, PowerPC)
- Small memory requirements for decompressing (16 KB + DictionarySize)
- Small code size for decompressing: 5-8 KB

-LZMA decoder uses only integer operations and can be
+LZMA decoder uses only integer operations and can be
implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).

Some critical operations that affect the speed of LZMA decompression:
@@ -205,7 +205,7 @@ Some critical operations that affect the speed of LZMA decompression:
3) 32-bit shift and arithmetic operations

The speed of LZMA decompressing mostly depends from CPU speed.
-Memory speed has no big meaning. But if your CPU has small data cache,
+Memory speed has no big meaning. But if your CPU has small data cache,
overall weight of memory speed will slightly increase.


@@ -221,53 +221,53 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]

d: decode file

- b: Benchmark. There are two tests: compressing and decompressing
- with LZMA method. Benchmark shows rating in MIPS (million
- instructions per second). Rating value is calculated from
+ b: Benchmark. There are two tests: compressing and decompressing
+ with LZMA method. Benchmark shows rating in MIPS (million
+ instructions per second). Rating value is calculated from
measured speed and it is normalized with Intel's Core 2 results.
- Also Benchmark checks possible hardware errors (RAM
+ Also Benchmark checks possible hardware errors (RAM
errors in most cases). Benchmark uses these settings:
- (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
+ (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
Also you can change the number of iterations. Example for 30 iterations:
LZMA b 30
Default number of iterations is 10.

<Switches>
-
+

-a{N}: set compression mode 0 = fast, 1 = normal
default: 1 (normal)

d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB)
The maximum value for dictionary size is 1 GB = 2^30 bytes.
- Dictionary size is calculated as DictionarySize = 2^N bytes.
- For decompressing file compressed by LZMA method with dictionary
+ Dictionary size is calculated as DictionarySize = 2^N bytes.
+ For decompressing file compressed by LZMA method with dictionary
size D = 2^N you need about D bytes of memory (RAM).

-fb{N}: set number of fast bytes - [5, 273], default: 128
- Usually big number gives a little bit better compression ratio
+ Usually big number gives a little bit better compression ratio
and slower compression process.

-lc{N}: set number of literal context bits - [0, 8], default: 3
Sometimes lc=4 gives gain for big files.

-lp{N}: set number of literal pos bits - [0, 4], default: 0
- lp switch is intended for periodical data when period is
- equal 2^N. For example, for 32-bit (4 bytes)
- periodical data you can use lp=2. Often it's better to set lc0,
+ lp switch is intended for periodical data when period is
+ equal 2^N. For example, for 32-bit (4 bytes)
+ periodical data you can use lp=2. Often it's better to set lc0,
if you change lp switch.

-pb{N}: set number of pos bits - [0, 4], default: 2
- pb switch is intended for periodical data
+ pb switch is intended for periodical data
when period is equal 2^N.

- -mf{MF_ID}: set Match Finder. Default: bt4.
- Algorithms from hc* group doesn't provide good compression
- ratio, but they often works pretty fast in combination with
+ -mf{MF_ID}: set Match Finder. Default: bt4.
+ Algorithms from hc* group doesn't provide good compression
+ ratio, but they often works pretty fast in combination with
fast mode (-a0).

- Memory requirements depend from dictionary size
- (parameter "d" in table below).
+ Memory requirements depend from dictionary size
+ (parameter "d" in table below).

MF_ID Memory Description

@@ -276,8 +276,8 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]
bt4 d * 11.5 + 4MB Binary Tree with 4 bytes hashing.
hc4 d * 7.5 + 4MB Hash Chain with 4 bytes hashing.

- -eos: write End Of Stream marker. By default LZMA doesn't write
- eos marker, since LZMA decoder knows uncompressed size
+ -eos: write End Of Stream marker. By default LZMA doesn't write
+ eos marker, since LZMA decoder knows uncompressed size
stored in .lzma file header.

-si: Read data from stdin (it will write End Of Stream marker).
@@ -286,16 +286,16 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]

Examples:

-1) LZMA e file.bin file.lzma -d16 -lc0
+1) LZMA e file.bin file.lzma -d16 -lc0

-compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
-and 0 literal context bits. -lc0 allows to reduce memory requirements
+compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
+and 0 literal context bits. -lc0 allows to reduce memory requirements
for decompression.


2) LZMA e file.bin file.lzma -lc0 -lp2

-compresses file.bin to file.lzma with settings suitable
+compresses file.bin to file.lzma with settings suitable
for 32-bit periodical data (for example, ARM or MIPS code).

3) LZMA d file.lzma file.bin
@@ -309,9 +309,9 @@ Compression ratio hints
Recommendations
---------------

-To increase the compression ratio for LZMA compressing it's desirable
+To increase the compression ratio for LZMA compressing it's desirable
to have aligned data (if it's possible) and also it's desirable to locate
-data in such order, where code is grouped in one place and data is
+data in such order, where code is grouped in one place and data is
grouped in other place (it's better than such mixing: code, data, code,
data, ...).

@@ -319,19 +319,19 @@ data, ...).
Filters
-------
You can increase the compression ratio for some data types, using
-special filters before compressing. For example, it's possible to
-increase the compression ratio on 5-10% for code for those CPU ISAs:
+special filters before compressing. For example, it's possible to
+increase the compression ratio on 5-10% for code for those CPU ISAs:
x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.

You can find C source code of such filters in C/Bra*.* files

-You can check the compression ratio gain of these filters with such
+You can check the compression ratio gain of these filters with such
7-Zip commands (example for ARM code):
No filter:
7z a a1.7z a.bin -m0=lzma

With filter for little-endian ARM code:
- 7z a a2.7z a.bin -m0=arm -m1=lzma
+ 7z a a2.7z a.bin -m0=arm -m1=lzma

It works in such manner:
Compressing = Filter_encoding + LZMA_encoding
@@ -339,11 +339,11 @@ Decompressing = LZMA_decoding + Filter_decoding

Compressing and decompressing speed of such filters is very high,
so it will not increase decompressing time too much.
-Moreover, it reduces decompression time for LZMA_decoding,
+Moreover, it reduces decompression time for LZMA_decoding,
since compression ratio with filtering is higher.

-These filters convert CALL (calling procedure) instructions
-from relative offsets to absolute addresses, so such data becomes more
+These filters convert CALL (calling procedure) instructions
+from relative offsets to absolute addresses, so such data becomes more
compressible.

For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
diff --git a/BaseTools/Source/C/Makefiles/app.makefile b/BaseTools/Source/C/Makefiles/app.makefile
index fcadb4ed2194..6a2a8f5e8a0e 100644
--- a/BaseTools/Source/C/Makefiles/app.makefile
+++ b/BaseTools/Source/C/Makefiles/app.makefile
@@ -12,9 +12,9 @@ include $(MAKEROOT)/Makefiles/header.makefile
APPLICATION = $(MAKEROOT)/bin/$(APPNAME)

.PHONY:all
-all: $(MAKEROOT)/bin $(APPLICATION)
+all: $(MAKEROOT)/bin $(APPLICATION)

-$(APPLICATION): $(OBJECTS)
+$(APPLICATION): $(OBJECTS)
$(LINKER) -o $(APPLICATION) $(BUILD_LFLAGS) $(OBJECTS) -L$(MAKEROOT)/libs $(LIBS)

$(OBJECTS): $(MAKEROOT)/Include/Common/BuildVersion.h
diff --git a/BaseTools/Source/C/Makefiles/footer.makefile b/BaseTools/Source/C/Makefiles/footer.makefile
index e823246cfbb4..85c3374224f2 100644
--- a/BaseTools/Source/C/Makefiles/footer.makefile
+++ b/BaseTools/Source/C/Makefiles/footer.makefile
@@ -14,10 +14,10 @@ $(MAKEROOT)/libs-$(HOST_ARCH):
install: $(MAKEROOT)/libs-$(HOST_ARCH) $(LIBRARY)
cp $(LIBRARY) $(MAKEROOT)/libs-$(HOST_ARCH)

-$(LIBRARY): $(OBJECTS)
+$(LIBRARY): $(OBJECTS)
$(BUILD_AR) crs $@ $^

-%.o : %.c
+%.o : %.c
$(BUILD_CC) -c $(BUILD_CPPFLAGS) $(BUILD_CFLAGS) $< -o $@

%.o : %.cpp
diff --git a/BaseTools/Source/C/Makefiles/header.makefile b/BaseTools/Source/C/Makefiles/header.makefile
index 52cbffcb4423..4e9b36d98bdb 100644
--- a/BaseTools/Source/C/Makefiles/header.makefile
+++ b/BaseTools/Source/C/Makefiles/header.makefile
@@ -61,7 +61,7 @@ else
$(error Bad HOST_ARCH)
endif

-INCLUDE = $(TOOL_INCLUDE) -I $(MAKEROOT) -I $(MAKEROOT)/Include/Common -I $(MAKEROOT)/Include/ -I $(MAKEROOT)/Include/IndustryStandard -I $(MAKEROOT)/Common/ -I .. -I . $(ARCH_INCLUDE)
+INCLUDE = $(TOOL_INCLUDE) -I $(MAKEROOT) -I $(MAKEROOT)/Include/Common -I $(MAKEROOT)/Include/ -I $(MAKEROOT)/Include/IndustryStandard -I $(MAKEROOT)/Common/ -I .. -I . $(ARCH_INCLUDE)
BUILD_CPPFLAGS = $(INCLUDE)

# keep EXTRA_OPTFLAGS last
@@ -82,7 +82,7 @@ BUILD_CXXFLAGS = -Wno-unused-result

ifeq ($(HOST_ARCH), IA32)
#
-# Snow Leopard is a 32-bit and 64-bit environment. uname -m returns i386, but gcc defaults
+# Snow Leopard is a 32-bit and 64-bit environment. uname -m returns i386, but gcc defaults
# to x86_64. So make sure tools match uname -m. You can manual have a 64-bit kernal on Snow Leopard
# so only do this is uname -m returns i386.
#
@@ -96,7 +96,7 @@ endif
# keep BUILD_OPTFLAGS last
BUILD_CFLAGS += $(BUILD_OPTFLAGS)
BUILD_CXXFLAGS += $(BUILD_OPTFLAGS)
-
+
# keep EXTRA_LDFLAGS last
BUILD_LFLAGS += $(EXTRA_LDFLAGS)

@@ -107,7 +107,7 @@ BUILD_LFLAGS += $(EXTRA_LDFLAGS)
all:

$(MAKEROOT)/libs:
- mkdir $(MAKEROOT)/libs
+ mkdir $(MAKEROOT)/libs

$(MAKEROOT)/bin:
mkdir $(MAKEROOT)/bin
diff --git a/BaseTools/Source/C/Makefiles/lib.makefile b/BaseTools/Source/C/Makefiles/lib.makefile
index a9965fc628d9..2577c15380a9 100644
--- a/BaseTools/Source/C/Makefiles/lib.makefile
+++ b/BaseTools/Source/C/Makefiles/lib.makefile
@@ -9,6 +9,6 @@ include $(MAKEROOT)/Makefiles/header.makefile

LIBRARY = $(MAKEROOT)/libs/lib$(LIBNAME).a

-all: $(MAKEROOT)/libs $(LIBRARY)
+all: $(MAKEROOT)/libs $(LIBRARY)

include $(MAKEROOT)/Makefiles/footer.makefile
diff --git a/BaseTools/Source/C/Makefiles/ms.common b/BaseTools/Source/C/Makefiles/ms.common
index 75c9bb43a32c..f5f77fdc0bc5 100644
--- a/BaseTools/Source/C/Makefiles/ms.common
+++ b/BaseTools/Source/C/Makefiles/ms.common
@@ -57,6 +57,6 @@ LINKER = $(LD)

INC = -I . -I $(SOURCE_PATH)\Include -I $(ARCH_INCLUDE) -I $(SOURCE_PATH)\Common $(INC)

-CFLAGS = $(CFLAGS) /nologo /Zi /c /O2 /MT /W4 /WX /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
-CPPFLAGS = $(CPPFLAGS) /EHsc /nologo /Zi /c /O2 /MT /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
+CFLAGS = $(CFLAGS) /nologo /Zi /c /O2 /MT /W4 /WX /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE
+CPPFLAGS = $(CPPFLAGS) /EHsc /nologo /Zi /c /O2 /MT /D _CRT_SECURE_NO_DEPRECATE /D _CRT_NONSTDC_NO_DEPRECATE

diff --git a/BaseTools/Source/C/VfrCompile/GNUmakefile b/BaseTools/Source/C/VfrCompile/GNUmakefile
index 8b94c73bbefa..42e3d7da020f 100644
--- a/BaseTools/Source/C/VfrCompile/GNUmakefile
+++ b/BaseTools/Source/C/VfrCompile/GNUmakefile
@@ -36,9 +36,9 @@ include $(MAKEROOT)/Makefiles/header.makefile
APPLICATION = $(MAKEROOT)/bin/$(APPNAME)

.PHONY:all
-all: $(MAKEROOT)/bin $(APPLICATION)
+all: $(MAKEROOT)/bin $(APPLICATION)

-$(APPLICATION): $(OBJECTS)
+$(APPLICATION): $(OBJECTS)
$(LINKER) -o $(APPLICATION) $(VFR_LFLAGS) $(OBJECTS) -L$(MAKEROOT)/libs $(LIBS)

VfrCompiler.o: ../Include/Common/BuildVersion.h
@@ -68,7 +68,7 @@ AParser.o: Pccts/h/AParser.cpp

VfrSyntax.o: VfrSyntax.cpp
$(BUILD_CXX) -c $(VFR_CPPFLAGS) $(INC) $(VFR_CXXFLAGS) $? -o $@
-
+
clean: localClean

localClean:
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
index 500d84f2e890..5ca0915a141b 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
+++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt
@@ -489,7 +489,7 @@ o Cleaned up the dup() stuff in AST hierarchy to use shallowCopy() to
{
return new AST(*this);
}
-
+
if you have defined a copy constructor such as

AST(const AST &t) // shallow copy constructor
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
index 4d84d1c19cfe..3f9f7a676697 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
+++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt
@@ -17,53 +17,53 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
Note: Items #153 to #1 are now in a separate file named
CHANGES_FROM_133_BEFORE_MR13.txt
-------------------------------------------------------
-
+
#312. (Changed in MR33) Bug caused by change #299.

In change #299 a warning message was suppressed when there was
- no LT(1) in a semantic predicate and max(k,ck) was 1. The
+ no LT(1) in a semantic predicate and max(k,ck) was 1. The
changed caused the code which set a default predicate depth for
the semantic predicate to be left as 0 rather than set to 1.
-
+
This manifested as an error at line #1559 of mrhost.c
-
+
Reported by Peter Dulimov.
-
+
#311. (Changed in MR33) Added sorcer/lib to Makefile.

Reported by Dale Martin.
-
+
#310. (Changed in MR32) In C mode zzastPush was spelled zzastpush in one case.

Reported by Jean-Claude Durand
-
+
#309. (Changed in MR32) Renamed baseName because of VMS name conflict

Renamed baseName to pcctsBaseName to avoid library name conflict with
VMS library routine. Reported by Jean-François PIÉRONNE.
-
+
#308. (Changed in MR32) Used "template" as name of formal in C routine

In astlib.h routine ast_scan a formal was named "template". This caused
problems when the C code was compiled with a C++ compiler. Reported by
Sabyasachi Dey.
-
+
#307. (Changed in MR31) Compiler dependent bug in function prototype generation
-
+
The code which generated function prototypes contained a bug which
was compiler/optimization dependent. Under some circumstance an
extra character would be included in portions of a function prototype.
-
+
Reported by David Cook.
-
+
#306. (Changed in MR30) Validating predicate following a token

- A validating predicate which immediately followed a token match
+ A validating predicate which immediately followed a token match
consumed the token after the predicate rather than before. Prior
to this fix (in the following example) isValidTimeScaleValue() in
the predicate would test the text for TIMESCALE rather than for
NUMBER:
-
+
time_scale :
TIMESCALE
<<isValidTimeScaleValue(LT(1)->getText())>>?
@@ -71,23 +71,23 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
( us:MICROSECOND << tVal = ...>>
| ns:NANOSECOND << tVal = ... >>
)
-
+
Reported by Adalbert Perbandt.
-
+
#305. (Changed in MR30) Alternatives with guess blocks inside (...)* blocks.

In MR14 change #175 fixed a bug in the prediction expressions for guess
blocks which were of the form (alpha)? beta. Unfortunately, this
resulted in a new bug as exemplified by the example below, which computed
the first set for r as {B} rather than {B C}:
-
+
r : ( (A)? B
| C
)*
-
+
This example doesn't make any sense as A is not a prefix of B, but it
illustrates the problem. This bug did not appear for:
-
+
r : ( (A)?
| C
)*
@@ -98,29 +98,29 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
constructs which appear to have identical ambiguities (between repeating
the loop vs. exiting the loop). MR30 retains this fix, but the implementation
is slightly different.
-
+
r_star : ( (A B)? )* A ;
r_plus : ( (A B)? )+ A ;

Reported by Arpad Beszedes (beszedes inf.u-szeged.hu).
-
+
#304. (Changed in MR30) Crash when mismatch between output value counts.

For a rule such as:
-
+
r1 : r2>[i,j];
r2 >[int i, int j] : A;
-
+
If there were extra actuals for the reference to rule r2 from rule r1
there antlr would crash. This bug was introduced by change #276.

Reported by Sinan Karasu.
-
+
#303. (Changed in MR30) DLGLexerBase::replchar

- DLGLexerBase::replchar and the C mode routine zzreplchar did not work
+ DLGLexerBase::replchar and the C mode routine zzreplchar did not work
properly when the new character was 0.
-
+
Reported with fix by Philippe Laporte

#302. (Changed in MR28) Fix significant problems in initial release of MR27.
@@ -129,29 +129,29 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

To have antlr generate true tabs rather than spaces, use "antlr -tab 0".
To generate 4 spaces per tab stop use "antlr -tab 4"
-
+
#300. (Changed in MR27)

Consider the following methods of constructing an AST from ID:
-
+
rule1!
: id:ID << #0 = #[id]; >> ;
-
+
rule2!
: id:ID << #0 = #id; >> ;
-
+
rule3
: ID ;
-
+
rule4
: id:ID << #0 = #id; >> ;
-
+
For rule_2, the AST corresponding to id would always be NULL. This
is because the user explicitly suppressed AST construction using the
"!" operator on the rule. In MR27 the use of an AST expression
such as #id overrides the "!" operator and forces construction of
the AST.
-
+
This fix does not apply to C mode ASTs when the ASTs are referenced
using numbers rather than symbols.

@@ -167,28 +167,28 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
then pccts doesn't know how many lookahead tokens to use for context.
However, if max(k,ck) is 1 then there is really only one choice and
the warning is unnecessary.
-
+
#298. (Changed in MR27) Removed "register" for lastpos in dlgauto.c zzgettok

#297. (Changed in MR27) Incorrect prototypes when used with classic C

There were a number of errors in function headers when antlr was
built with compilers that do not have __STDC__ or __cplusplus set.
-
+
The functions which have variable length argument lists now use
PCCTS_USE_STDARG rather than __USE_PROTOTYPES__ to determine
whether to use stdargs or varargs.

#296. (Changed in MR27) Complex return types in rules.

- The following return type was not properly handled when
+ The following return type was not properly handled when
unpacking a struct with containing multiple return values:
-
- rule > [int i, IIR_Bool (IIR_Decl::*constraint)()] : ...
+
+ rule > [int i, IIR_Bool (IIR_Decl::*constraint)()] : ...

Instead of using "constraint", the program got lost and used
an empty string.
-
+
Reported by P.A. Wilsey.

#295. (Changed in MR27) Extra ";" following zzGUESS_DONE sometimes.
@@ -197,15 +197,15 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
preceding the "else" clause of an "if".

Reported by P.A. Wilsey.
-
+
#294. (Changed in MR27) Infinite loop in antlr for nested blocks

An oversight in detecting an empty alternative sometimes led
to an infinite loop in antlr when it encountered a rule with
nested blocks and guess blocks.
-
+
Reported by P.A. Wilsey.
-
+
#293. (Changed in MR27) Sorcerer optimization of _t->type()

Sorcerer generated code may contain many calls to _t->type() in a
@@ -224,21 +224,21 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

Fix to serious code generation error in MR23 for (...)+ block.

-#290. (Changed in MR23)
+#290. (Changed in MR23)

Item #247 describes a change in the way {...} blocks handled
an error. Consider:

r1 : {A} b ;
b : B;
-
+
with input "C".

Prior to change #247, the error would resemble "expected B -
found C". This is correct but incomplete, and therefore
misleading. In #247 it was changed to "expected A, B - found
C". This was fine, except for users of parser exception
- handling because the exception was generated in the epilogue
+ handling because the exception was generated in the epilogue
for {...} block rather than in rule b. This made it difficult
for users of parser exception handling because B was not
expected in that context. Those not using parser exception
@@ -252,7 +252,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
an empty production and it is the last alternative of a sub-block.
In contrast, (something | epsilon | something) should generate the
same code as before, even when exceptions are used.
-
+
Reported by Philippe Laporte (philippe at transvirtual.com).

#289. (Changed in MR23) Bug in matching complement of a #tokclass
@@ -261,43 +261,43 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
and uncomplemented form, the bit set generated for its first use was used
for both cases. However, the prediction expression was correctly computed
in both cases. This meant that the second case would never be matched
- because, for the second appearance, the prediction expression and the
+ because, for the second appearance, the prediction expression and the
set to be matched would be complements of each other.
-
+
Consider:
-
+
#token A "a"
#token B "b"
#token C "c"
#tokclass AB {A B}
-
+
r1 : AB /* alt 1x */
| ~AB /* alt 1y */
;
-
+
Prior to MR23, this resulted in alternative 1y being unreachable. Had it
been written:
-
+
r2 : ~AB /* alt 2x */
: AB /* alt 2y */
-
- then alternative 2y would have become unreachable.
-
+
+ then alternative 2y would have become unreachable.
+
This bug was only for the case of complemented #tokclass. For complemented
- #token the proper code was generated.
-
+ #token the proper code was generated.
+
#288. (Changed in MR23) #errclass not restricted to choice points

The #errclass directive is supposed to allow a programmer to define
print strings which should appear in syntax error messages as a replacement
for some combinations of tokens. For instance:
-
+
#errclass Operator {PLUS MINUS TIMES DIVIDE}
-
+
If a syntax message includes all four of these tokens, and there is no
"better" choice of error class, the word "Operator" will be used rather
than a list of the four token names.
-
+
Prior to MR23 the #errclass definitions were used only at choice points
(which call the FAIL macro). In other cases where there was no choice
(e.g. where a single token or token class were matched) the #errclass
@@ -307,7 +307,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
when matching a #tokclass, a wildcard (i.e. "*"), or the complement of a
#token or #tokclass (e.g. ~Operator).

- Please note that #errclass may now be defined using #tokclass names
+ Please note that #errclass may now be defined using #tokclass names
(see Item #284).

Reported by Philip A. Wilsey.
@@ -317,25 +317,25 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
Item #148 describes how to give a print name to a #token so that,for
example, #token ID could have the expression "identifier" in syntax
error messages. This has been extended to #tokclass:
-
+
#token ID("identifier") "[a-zA-Z]+"
- #tokclass Primitive("primitive type")
- {INT, FLOAT, CHAR, FLOAT, DOUBLE, BOOL}
+ #tokclass Primitive("primitive type")
+ {INT, FLOAT, CHAR, FLOAT, DOUBLE, BOOL}

This is really a cosmetic change, since #tokclass names do not appear
in any error messages.
-
+
#286. (Changed in MR23) Makefile change to use of cd

In cases where a pccts subdirectory name matched a directory identified
in a $CDPATH environment variable the build would fail. All makefile
cd commands have been changed from "cd xyz" to "cd ./xyz" in order
to avoid this problem.
-
+
#285. (Changed in MR23) Check for null pointers in some dlg structures

An invalid regular expression can cause dlg to build an invalid
- structure to represent the regular expression even while it issues
+ structure to represent the regular expression even while it issues
error messages. Additional pointer checks were added.

Reported by Robert Sherry.
@@ -354,7 +354,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

Problem reported by Mike Dimmick (mike dimmick.demon.co.uk).

-#283. (Changed in MR23) Option -tmake invoke's parser's tmake
+#283. (Changed in MR23) Option -tmake invoke's parser's tmake

When the string #(...) appears in an action antlr replaces it with
a call to ASTBase::tmake(...) to construct an AST. It is sometimes
@@ -364,15 +364,15 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

The antlr option -tmake replaces the call to ASTBase::tmake with a call
to a user supplied tmake routine.
-
+
#282. (Changed in MR23) Initialization error for DBG_REFCOUNTTOKEN

- When the pre-processor symbol DBG_REFCOUNTTOKEN is defined
+ When the pre-processor symbol DBG_REFCOUNTTOKEN is defined
incorrect code is generated to initialize ANTLRRefCountToken::ctor and
dtor.

Fix reported by Sven Kuehn (sven sevenkuehn.de).
-
+
#281. (Changed in MR23) Addition of -noctor option for Sorcerer

Added a -noctor option to suppress generation of the blank ctor
@@ -395,29 +395,29 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
alternatives which caused problems when there was a block contained
in an alternative. For instance, in the following rule;

- statement : IF S { ELSE S }
+ statement : IF S { ELSE S }
exception ....
;

- the exception would be attached to the {...} block instead of the
+ the exception would be attached to the {...} block instead of the
entire alternative because it was attached, in error, to the last
alternative instead of the last OPEN alternative.

Reported by Ty Mordane (tymordane hotmail.com).
-
+
#278. (Changed in MR23) makefile changes

Contributed by Tomasz Babczynski (faster lab05-7.ict.pwr.wroc.pl).

The -cfile option is not absolutely needed: when extension of
- source file is one of the well-known C/C++ extensions it is
+ source file is one of the well-known C/C++ extensions it is
treated as C/C++ source

The gnu make defines the CXX variable as the default C++ compiler
name, so I added a line to copy this (if defined) to the CCC var.

Added a -sor option: after it any -class command defines the class
- name for sorcerer, not for ANTLR. A file extended with .sor is
+ name for sorcerer, not for ANTLR. A file extended with .sor is
treated as sorcerer input. Because sorcerer can be called multiple
times, -sor option can be repeated. Any files and classes (one class
per group) after each -sor makes one tree parser.
@@ -448,7 +448,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
rule : <<my_predicate>>? [my_fail_action] A
| ...

-
+
the code for my_fail_action would have to contain logic for handling
the guess part of the zzfailed_pred macro. The user should not have
to be aware of the guess logic in writing the fail action.
@@ -501,7 +501,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
Foo _retv = expr;
...
}
-
+
A rule with more than one return argument:

r2 > [Foo f = expr1, Bar b = expr2 ] :
@@ -567,13 +567,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

Multi-threaded DLL
Debug Multi-threaded DLL
-
- Suggested by Bill Menees (bill.menees gogallagher.com)
-
+
+ Suggested by Bill Menees (bill.menees gogallagher.com)
+
#272. (Changed in MR23) Failed semantic predicate reported via virtual function

In the past, a failed semantic predicated reported the problem via a
- macro which used fprintf(). The macro now expands into a call on
+ macro which used fprintf(). The macro now expands into a call on
the virtual function ANTLRParser::failedSemanticPredicate().

#271. (Changed in MR23) Warning for LT(i), LATEXT(i) in token match actions
@@ -594,7 +594,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

This behavior should be changed, but it appears in too many programs
now. Another problem, perhaps more significant, is that the obvious
- fix (moving the consume() call to before the action) could change the
+ fix (moving the consume() call to before the action) could change the
order in which input is requested and output appears in existing programs.

This problem was reported, along with a fix by Benjamin Mandel
@@ -610,7 +610,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

The output from dlg contains a construct similar to the
following:
-
+
struct XXX {
static const int size;
static int array1[5];
@@ -619,7 +619,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
const int XXX::size = 4;
int XXX::array1[size+1];

-
+
The problem is that although the expression "size+1" used in
the definition of array1 is equal to 5 (the expression used to
declare array), it is not considered equivalent by some compilers.
@@ -634,10 +634,10 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
appropriate one. The appropriate one is computed by comparing
the token codes of lookahead token i (for i = 1 to k) with
the FIRST(i) set.
-
+
This has been corrected in ANTLRParser::syn().

- Reported by Bill Menees (bill.menees gogallagher.com)
+ Reported by Bill Menees (bill.menees gogallagher.com)

#267. (Changed in MR23) AST traversal functions client data argument

@@ -651,8 +651,8 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
**** Warning: this changes the AST signature. ***
**** Be sure to revise your AST functions of the same name ***

- Bill Menees (bill.menees gogallagher.com)
-
+ Bill Menees (bill.menees gogallagher.com)
+
#266. (Changed in MR23) virtual function printMessage()

Bill Menees (bill.menees gogallagher.com) has completed the
@@ -669,7 +669,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
In C++ mode labase++ is called when a token is matched.
It appears that labase is not used in C++ mode at all, so
this code has been commented out.
-
+
#264. (Changed in MR23) Complete rewrite of ParserBlackBox.h

The parser black box (PBlackBox.h) was completely rewritten
@@ -694,7 +694,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

#260. (MR22) Raise default lex buffer size from 8,000 to 32,000 bytes.

- ZZLEXBUFSIZE is the size (in bytes) of the buffer used by dlg
+ ZZLEXBUFSIZE is the size (in bytes) of the buffer used by dlg
generated lexers. The default value has been raised to 32,000 and
the value used by antlr, dlg, and sorcerer has also been raised to
32,000.
@@ -759,12 +759,12 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
#256. (MR21a) Malformed syntax graph causes crash after error message.

In the past, certain kinds of errors in the very first grammar
- element could cause the construction of a malformed graph
+ element could cause the construction of a malformed graph
representing the grammar. This would eventually result in a
fatal internal error. The code has been changed to be more
resistant to this particular error.

-#255. (MR21a) ParserBlackBox(FILE* f)
+#255. (MR21a) ParserBlackBox(FILE* f)

This constructor set openByBlackBox to the wrong value.

@@ -813,14 +813,14 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
AParser.h. If this preprocessor symbol was not properly
set the first time AParser.h was #included, the declaration
of zzTRACEdata would be omitted (it is used by the -gd option).
- Subsequent #includes of AParser.h would be skipped because of
+ Subsequent #includes of AParser.h would be skipped because of
the #ifdef guard, so the declaration of zzTracePrevRuleName would
- never be made. The result was that proper compilation was very
+ never be made. The result was that proper compilation was very
order dependent.

The declaration of zzTRACEdata was made unconditional and the
problem of removing unused declarations will be left to optimizers.
-
+
Diagnosed by Douglas E. Forester (dougf projtech.com).

#250. (MR21) Option for EXPERIMENTAL change to error sets for blocks
@@ -835,13 +835,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
the most appropriate tokens in the error message. The error sets used
in pccts error messages are approximations of the exact error set when
optional elements in (...)* or (...)+ are involved. While entirely
- correct, the error messages are sometimes not 100% accurate.
+ correct, the error messages are sometimes not 100% accurate.

There is also a minor philosophical issue. For example, suppose the
- grammar expects the token to be an optional A followed by Z, and it
+ grammar expects the token to be an optional A followed by Z, and it
is X. X, of course, is neither A nor Z, so an error message is appropriate.
Is it appropriate to say "Expected Z" ? It is correct, it is accurate,
- but it is not complete.
+ but it is not complete.

When k>1 or ck>1 the problem of providing the exactly correct
list of tokens for the syntax error messages ends up becoming
@@ -852,7 +852,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
This application uses the error set in an interactive command language
to provide prompts which list the alternatives available at that
point in the parser. The user can then enter additional tokens to
- complete the command line. To do this required more accurate error
+ complete the command line. To do this required more accurate error
sets then previously provided by pccts.

In some cases the default pccts behavior may lead to more robust error
@@ -972,7 +972,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

This includes the choice of looping back to the
star block.
-
+
#249. (MR21) Changes for DEC/VMS systems

Jean-François Piéronne (jfp altavista.net) has updated some
@@ -991,7 +991,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
rr : #FirstSetSymbol(rr_FirstSet) ( Foo | Bar ) ;

This will generate the symbol rr_FirstSet of type SetWordType with
- elements Foo and Bar set. The bits can be tested using code similar
+ elements Foo and Bar set. The bits can be tested using code similar
to the following:

if (set_el(Foo, &rr_FirstSet)) { ...
@@ -999,9 +999,9 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
This can be combined with the C array zztokens[] or the C++ routine
tokenName() to get the print name of the token in the first set.

- The size of the set is given by the newly added enum SET_SIZE, a
+ The size of the set is given by the newly added enum SET_SIZE, a
protected member of the generated parser's class. The number of
- elements in the generated set will not be exactly equal to the
+ elements in the generated set will not be exactly equal to the
value of SET_SIZE because of synthetic tokens created by #tokclass,
#errclass, the -ge option, and meta-tokens such as epsilon, and
end-of-file.
@@ -1015,11 +1015,11 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
rr_bad : #FirstSetSymbol(rr_bad_FirstSet) Foo; // Illegal

rr_ok : #FirstSetSymbol(rr_ok_FirstSet) (Foo); // Legal
-
+
Do not confuse FirstSetSymbol sets with the sets used for testing
lookahead. The sets used for FirstSetSymbol have one element per bit,
so the number of bytes is approximately the largest token number
- divided by 8. The sets used for testing lookahead store 8 lookahead
+ divided by 8. The sets used for testing lookahead store 8 lookahead
sets per byte, so the length of the array is approximately the largest
token number.

@@ -1033,7 +1033,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
===================================================

Prior to MR21, tokens which were optional did not appear in syntax
- error messages if the block which immediately followed detected a
+ error messages if the block which immediately followed detected a
syntax error.

Consider the following grammar which accepts Number, Word, and Other:
@@ -1071,7 +1071,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
}
}
match(Word);
-
+
The code generated for optional blocks in MR21 is slightly longer
than the previous versions, but it should give better error messages.

@@ -1098,14 +1098,14 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

The following command line options have been added to genmk:

- -cfiles ...
-
+ -cfiles ...
+
To add a user's C or C++ files into makefile automatically.
The list of files must be enclosed in apostrophes. This
option may be specified multiple times.

-compiler ...
-
+
The name of the compiler to use for $(CCC) or $(CC). The
default in C++ mode is "CC". The default in C mode is "cc".

@@ -1139,15 +1139,15 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
*** NOT IMPLEMENTED ***
***********************

- The PURIFY macro was changed to a no-op because it was causing
+ The PURIFY macro was changed to a no-op because it was causing
problems when passing C++ objects.
-
+
The old definition:
-
+
#define PURIFY(r,s) memset((char *) &(r),'\\0',(s));
-
+
The new definition:
-
+
#define PURIFY(r,s) /* nothing */
#endif

@@ -1174,10 +1174,10 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
Should have known better.

#237. (Changed in MR21) ParserBlackBox(FILE*)
-
+
In the past, ParserBlackBox would close the FILE in the dtor
even though it was not opened by ParserBlackBox. The problem
- is that there were two constructors, one which accepted a file
+ is that there were two constructors, one which accepted a file
name and did an fopen, the other which accepted a FILE and did
not do an fopen. There is now an extra member variable which
remembers whether ParserBlackBox did the open or not.
@@ -1186,7 +1186,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

#236. (Changed in MR21) tmake now reports down pointer problem

- When ASTBase::tmake attempts to update the down pointer of
+ When ASTBase::tmake attempts to update the down pointer of
an AST it checks to see if the down pointer is NULL. If it
is not NULL it does not do the update and returns NULL.
An attempt to update the down pointer is almost always a
@@ -1221,7 +1221,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
#232. (Changed in MR20) Make setwd bit vectors protected in parser.h

The access for the setwd array in the parser header was not
- specified. As a result, it would depend on the code which
+ specified. As a result, it would depend on the code which
preceded it. In MR20 it will always have access "protected".

Reported by Piotr Eljasiak (eljasiak zt.gdansk.tpsa.pl).
@@ -1273,8 +1273,8 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
resized for deeply nested blocks. This has been fixed.

#226. (Changed in MR20) -pedantic conformance
-
- G. Hobbelt (i_a mbh.org) and THM made many, many minor
+
+ G. Hobbelt (i_a mbh.org) and THM made many, many minor
changes to create prototypes for all the functions and
bring antlr, dlg, and sorcerer into conformance with
the gcc -pedantic option.
@@ -1284,7 +1284,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

#225 (Changed in MR20) AST stack adjustment in C mode

- The fix in #214 for AST stack adjustment in C mode missed
+ The fix in #214 for AST stack adjustment in C mode missed
some cases.

Reported with fix by Ger Hobbelt (i_a mbh.org).
@@ -1299,7 +1299,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

#223 (Changed in MR20) Addition of IBM_VISUAL_AGE directory

- Build files for antlr, dlg, and sorcerer under IBM Visual Age
+ Build files for antlr, dlg, and sorcerer under IBM Visual Age
have been contributed by Anton Sergeev (ags mlc.ru). They have
been placed in the pccts/IBM_VISUAL_AGE directory.

@@ -1317,7 +1317,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
The arguments to strcat are reversed when creating a print
name for a hash table entry for use with #pred feature.

- Problem diagnosed and fix reported by Scott Harrington
+ Problem diagnosed and fix reported by Scott Harrington
(seh4 ix.netcom.com).

#219. (Changed in MR19) C Mode routine zzfree_ast
@@ -1334,7 +1334,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
Implemented by SAKAI Kiyotaka (ksakai isr.co.jp).

#217. (Changed in MR19) Error message when dlg -i and -CC options selected
-
+
*** This change was rescinded by item #257 ***

The parsers generated by pccts in C++ mode are not able to support the
@@ -1353,13 +1353,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
This requires max(k,ck) tokens of lookahead. For some applications
this can cause deadlock problems. For example, there may be cases
when the parser can't tell when the input has been completely consumed
- until the parse is complete, but the parse can't be completed because
+ until the parse is complete, but the parse can't be completed because
the input routines are waiting for additional tokens to fill the
lookahead buffer.
-
- When the ANTLRParser class is built with the pre-processor option
+
+ When the ANTLRParser class is built with the pre-processor option
ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred
- until LA(i) or LT(i) is called.
+ until LA(i) or LT(i) is called.

To test whether this option has been built into the ANTLRParser class
use "isDeferFetchEnabled()".
@@ -1368,8 +1368,8 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
routines will defeat the effort to defer the fetch because the
trace routines print out information about the lookahead token at
the start of the rule.
-
- Because the tracein and traceout routines are virtual it is
+
+ Because the tracein and traceout routines are virtual it is
easy to redefine them in your parser:

class MyParser {
@@ -1379,9 +1379,9 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
virtual void traceout(ANTLRChar * ruleName)
{ fprintf(stderr,"Leaving: %s\n", ruleName); }
>>
-
+
The originals for those routines are pccts/h/AParser.cpp
-
+
This requires use of the dlg option -i (interactive lexer).

This is implemented only for C++ mode.
@@ -1434,9 +1434,9 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
pccts/sorcerer/sor.r
pccts/sorcerer/sor68K.make
pccts/sorcerer/sorPPC.make
-
+
They completely replace the previous Mac installation files.
-
+
b. The most significant is a change in the MAC_FILE_CREATOR symbol
in pcctscfg.h:

@@ -1468,7 +1468,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
PCCTS in the same source file. The problem is caused by the
redefinition of setjmp in the MS header file setjmp.h. In
setjmp.h the pre-processor symbol setjmp was redefined to be
- _setjmp. A later effort to execute #include <setjmp.h> resulted
+ _setjmp. A later effort to execute #include <setjmp.h> resulted
in an effort to #include <_setjmp.h>. I'm not sure whether this
is a bug or a feature. In any case, I decided to fix it by
avoiding the use of pre-processor symbols in #include statements
@@ -1484,7 +1484,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

#ifndef __PCCTS_SETJMP_H__
#define __PCCTS_SETJMP_H__
-
+
#ifdef PCCTS_USE_NAMESPACE_STD
#include <Csetjmp>
#else
@@ -1492,7 +1492,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
#endif

#endif
-
+
A similar change has been made for other standard header files
required by pccts and sorcerer: stdlib.h, stdarg.h, stdio.h, etc.

@@ -1522,13 +1522,13 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS

if ($$.letter > $2.letter) {
error("invalid range ", zzline);
- }
+ }

The fix is:

if ($$.letter > $2.letter && 255 != $$2.letter) {
error("invalid range ", zzline);
- }
+ }

#206. (Changed in MR16) Free zzFAILtext in ANTLRParser destructor

@@ -1544,7 +1544,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
Suggested by Dale Davis (daldavis spectrace.com)

#204. (Changed in MR15a) Change __WATCOM__ to __WATCOMC__ in pcctscfg.h
-
+
Reported by Oleg Dashevskii (olegdash my-dejanews.com).

#203. (Changed in MR15) Addition of sorcerer to distribution kit
@@ -1562,7 +1562,7 @@ List of Implemented Fixes and Changes for Maintenance Releases of PCCTS
.cpp files in the pccts/h directory.

The library build will create pccts_debug.lib or pccts_release.lib
- according to the configuration selected.
+ according to the configuration selected.

If you don't want to build pccts 1.33MR15 you can download a
ready-to-run kit for win32 from http://www.polhode.com/win32.zip.
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
index 33d7d20a6a3c..b95615d8a3c1 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
+++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt
@@ -2143,7 +2143,7 @@

--------------------------------------------------
Note: This was incorrect. The contexts should be
- ORed together. This has been fixed. A more
+ ORed together. This has been fixed. A more
complete description is available in item #152.
---------------------------------------------------

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
index 7134500e2fbf..2c371954661f 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
+++ b/BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt
@@ -42,9 +42,9 @@

#216. Defer token fetch for C++ mode

- When the ANTLRParser class is built with the pre-processor option
+ When the ANTLRParser class is built with the pre-processor option
ZZDEFER_FETCH defined, the fetch of new tokens by consume() is deferred
- until LA(i) or LT(i) is called.
+ until LA(i) or LT(i) is called.

#215. Use reset() to reset DLGLexerBase
#188. Added pccts/h/DLG_stream_input.h
@@ -1684,7 +1684,7 @@

--------------------------------------------------
Note: This was incorrect. The contexts should be
- ORed together. This has been fixed. A more
+ ORed together. This has been fixed. A more
complete description is available in item #152.
---------------------------------------------------

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt
index 539cf775257b..cc5cad73897e 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt
+++ b/BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt
@@ -8,28 +8,28 @@
See item #207.

Reported by Frank Hartmann.
-
+
#16. A note about "&&" predicates (Mike Dimmick)

Mike Dimmick has pointed out a potential pitfall in the use of the
"&&" style predicate. Consider:
-
+
r0: (g)? => <<P>>? r1
| ...
;
r1: A | B;
-
+
If the context guard g is not a subset of the lookahead context for r1
- (in other words g is neither A nor B) then the code may execute r1
+ (in other words g is neither A nor B) then the code may execute r1
even when the lookahead context is not satisfied. This is an error
by the person coding the grammar, and the error should be reported to
the user, but it isn't. expect. Some examples I've run seem to
indicate that such an error actually results in the rule becoming
unreachable.
-
+
When g is properly coded the code is correct, the problem is when g
is not properly coded.
-
+
A second problem reported by Mike Dimmick is that the test for a
failed validation predicate is equivalent to a test on the predicate
along. In other words, if the "&&" has not been hoisted then it may
@@ -53,7 +53,7 @@

This behavior should be changed, but it appears in too many programs
now. Another problem, perhaps more significant, is that the obvious
- fix (moving the consume() call to before the action) could change the
+ fix (moving the consume() call to before the action) could change the
order in which input is requested and output appears in existing programs.

This problem was reported, along with a fix by Benjamin Mandel
@@ -85,12 +85,12 @@
GraphPtr g;
{
Graph g1, g2;
-
+
if ( andExpr(&g1) == -1 )
{
return -1;
}
-
+
while ( token == '|' )
{
int a;
@@ -100,7 +100,7 @@
else if ( !a ) return 1; /* empty alternative */
g1 = BuildNFA_AorB(g1, g2);
}
-
+
if ( token!='\0' ) return -1;
*****
***** It appears to fail here becuause token is 125 - the closing '}'
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c
index 58d0b134b9d8..c71f6cc31aa3 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c
@@ -59,7 +59,7 @@ static int class_nest_level = 0;

/* MR20 G. Hobbelt extern definitions moved to antlr.h */

-
+

void
#ifdef __USE_PROTOS
@@ -82,7 +82,7 @@ grammar()
if ( (LA(1)==94) ) {
zzmatch(94); zzCONSUME;
zzmatch(Action);
-
+
if ( HdrAction==NULL ) {
HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
@@ -96,7 +96,7 @@ grammar()
if ( (LA(1)==95) ) {
zzmatch(95); zzCONSUME;
zzmatch(Action);
-
+
if ( FirstAction==NULL ) {
FirstAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(FirstAction!=NULL, "rule grammar: cannot allocate #first action");
@@ -111,7 +111,7 @@ grammar()
if ( (LA(1)==96) ) {
zzmatch(96); zzCONSUME;
zzmatch(QuotedTerm);
-
+
if ( GenCC ) {
warn("#parser meta-op incompatible with -CC; ignored");
}
@@ -221,7 +221,7 @@ grammar()
else {
if ( (LA(1)==98) ) {
zzmatch(98);
-
+
if ( class_nest_level==0 )
warn("missing class definition for trailing '}'");
class_nest_level--;
@@ -257,7 +257,7 @@ grammar()
rule();
if ( zzaArg(zztasp2,1 ).left!=NULL ) {
g.right = NULL;
-
+
/* MR21a */ /* Avoid use of a malformed graph when CannotContinue */
/* MR21a */ /* is already set */
/* MR21a */
@@ -293,7 +293,7 @@ grammar()
else {
if ( (LA(1)==98) ) {
zzmatch(98);
-
+
if ( class_nest_level==0 )
warn("missing class definition for trailing '}'");
class_nest_level--;
@@ -361,7 +361,7 @@ grammar()
else {
if ( (LA(1)==98) ) {
zzmatch(98);
-
+
if ( class_nest_level==0 )
warn("missing class definition for trailing '}'");
class_nest_level--;
@@ -387,7 +387,7 @@ grammar()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd1, 0x10);
}
@@ -428,7 +428,7 @@ class_def()
zzEXIT(zztasp2);
}
}
-
+
if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
&& GenCC ) {
err("only one grammar class allowed in this release");
@@ -468,7 +468,7 @@ class_def()
}
}
zzmatch(102);
-
+
no_classes_found = 0;
if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
else class_nest_level++;
@@ -478,7 +478,7 @@ class_def()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd1, 0x40);
}
@@ -495,8 +495,8 @@ rule()
zzBLOCK(zztasp1);
zzMake0;
{
-
-
+
+
ExceptionGroup *eg;
RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
set toksrefd, rulesrefd;
@@ -621,7 +621,7 @@ rule()
zzEXIT(zztasp2);
}
}
-
+
if ( GenEClasseForRules && q!=NULL ) {
e = newECnode;
require(e!=NULL, "cannot allocate error class node");
@@ -672,9 +672,9 @@ rule()
CurRuleBlk->end = p;
if ( q!=NULL ) q->rulenum = NumRules;
zzaArg(zztasp1,7) = r;
-
+
/* MR23 */ CurBlockID_array[BlkLevel] = (-1);
- /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
--BlkLevel;
altFixup();leFixup();egFixup();
zzmatch(107);
@@ -727,7 +727,7 @@ rule()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd2, 0x10);
}
@@ -747,7 +747,7 @@ laction()
char *a;
zzmatch(108); zzCONSUME;
zzmatch(Action);
-
+
a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(a!=NULL, "rule laction: cannot allocate action");
strcpy(a, LATEXT(1));
@@ -758,7 +758,7 @@ laction()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd2, 0x20);
}
@@ -778,7 +778,7 @@ lmember()
char *a;
zzmatch(109); zzCONSUME;
zzmatch(Action);
-
+
/* MR1 */ if (! GenCC) {
/* MR1 */ err("Use #lexmember only in C++ mode (to insert code in DLG class header");
/* MR1 */ } else {
@@ -794,7 +794,7 @@ lmember()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd2, 0x40);
}
@@ -814,7 +814,7 @@ lprefix()
char *a;
zzmatch(110); zzCONSUME;
zzmatch(Action);
-
+
/* MR1 */ if (! GenCC) {
/* MR1 */ err("Use #lexprefix only in C++ mode (to insert code in DLG class header");
/* MR1 */ } else {
@@ -830,7 +830,7 @@ lprefix()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd2, 0x80);
}
@@ -855,7 +855,7 @@ aPred()
int save_line;
int predExprPresent=0;
zzmatch(111);
-
+
MR_usingPredNames=1; /* will need to use -mrhoist version of genPredTree */
zzCONSUME;

@@ -863,13 +863,13 @@ aPred()
name=mystrdup(LATEXT(1));
zzCONSUME;

-
+
/* don't free - referenced in predicates */
-
+
CurPredName=(char *)calloc(1,strlen(name) + 10);
strcat(CurPredName,"#pred ");
strcat(CurPredName,name);
-
+
predEntry=(PredEntry *) hash_get(Pname,name);
if (predEntry != NULL) {
warnFL(eMsg1("#pred %s previously defined - ignored",name),
@@ -905,12 +905,12 @@ aPred()
}
}
if (predLiteral != NULL && name != NULL) {
-
+
/*
* predExpr may be NULL due to syntax errors
* or simply omitted by the user
*/
-
+
predEntry=newPredEntry(name);
predEntry->file=save_file;
predEntry->line=save_line;
@@ -997,7 +997,7 @@ predOrExpr()
Predicate **tail=NULL;
predExpr = predAndExpr();

-
+
ORnode=new_pred();
ORnode->expr=PRED_OR_LIST;
if (predExpr != NULL) {
@@ -1012,7 +1012,7 @@ predOrExpr()
zzmatch(112); zzCONSUME;
predExpr = predAndExpr();

-
+
if (predExpr != NULL) {
*tail=predExpr;
tail=&predExpr->right;
@@ -1022,14 +1022,14 @@ predOrExpr()
zzEXIT(zztasp2);
}
}
-
+
_retv=ORnode;
ORnode=NULL;
zzEXIT(zztasp1);
return _retv;
fail:
zzEXIT(zztasp1);
- predicate_free(ORnode);
+ predicate_free(ORnode);
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd3, 0x20);
return _retv;
@@ -1054,7 +1054,7 @@ predAndExpr()
Predicate **tail=NULL;
predExpr = predPrimary();

-
+
ANDnode=new_pred();
ANDnode->expr=PRED_AND_LIST;
if (predExpr != NULL) {
@@ -1069,7 +1069,7 @@ predAndExpr()
zzmatch(113); zzCONSUME;
predExpr = predPrimary();

-
+
if (predExpr != NULL) {
*tail=predExpr;
tail=&predExpr->right;
@@ -1079,14 +1079,14 @@ predAndExpr()
zzEXIT(zztasp2);
}
}
-
+
_retv=ANDnode;
ANDnode=NULL;
zzEXIT(zztasp1);
return _retv;
fail:
zzEXIT(zztasp1);
- predicate_free(ANDnode);
+ predicate_free(ANDnode);
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd3, 0x40);
return _retv;
@@ -1106,7 +1106,7 @@ predPrimary()
PCCTS_PURIFY(_retv,sizeof(Predicate * ))
zzMake0;
{
-
+
char *name=NULL;
PredEntry *predEntry=NULL;
Predicate *predExpr=NULL;
@@ -1115,7 +1115,7 @@ predPrimary()
name=mystrdup(LATEXT(1));
zzCONSUME;

-
+
predEntry=(PredEntry *) hash_get(Pname,name);
if (predEntry == NULL) {
warnFL(eMsg1("no previously defined #pred with name \"%s\"",name),
@@ -1134,7 +1134,7 @@ predPrimary()
predExpr = predOrExpr();

zzmatch(115);
-
+
_retv=predExpr;
zzCONSUME;

@@ -1144,7 +1144,7 @@ predPrimary()
zzmatch(103); zzCONSUME;
predExpr = predPrimary();

-
+
predExpr->inverted=!predExpr->inverted;
_retv=predExpr;
}
@@ -1155,7 +1155,7 @@ predPrimary()
return _retv;
fail:
zzEXIT(zztasp1);
-
+
predicate_free(predExpr);
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd3, 0x80);
@@ -1183,7 +1183,7 @@ aLexclass()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd4, 0x1);
}
@@ -1323,7 +1323,7 @@ error()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd4, 0x4);
}
@@ -1390,7 +1390,7 @@ tclass()
zzEXIT(zztasp2);
}
}
-
+
/* MR23 */ if (p!= NULL && akaString != NULL) {
/* MR23 */ if (p->akaString != NULL) {
/* MR23 */ if (strcmp(p->akaString,akaString) != 0) {
@@ -1493,7 +1493,7 @@ tclass()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd4, 0x20);
}
@@ -1599,7 +1599,7 @@ token()
{
if ( (LA(1)==Action) ) {
zzmatch(Action);
-
+
a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(a!=NULL, "rule token: cannot allocate action");
strcpy(a, LATEXT(1));
@@ -1648,7 +1648,7 @@ token()
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd5, 0x10);
}
@@ -1667,7 +1667,7 @@ set *rulesrefd ;
zzBLOCK(zztasp1);
zzMake0;
{
-
+
Graph g, b;
set saveblah;
int saveinalt = inAlt;
@@ -1678,12 +1678,12 @@ set *rulesrefd ;
CurBlockID++;
/* MR23 */ CurBlockID_array[BlkLevel] = CurBlockID;
CurAltNum = 1;
- /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
+ /* MR23 */ CurAltNum_array[BlkLevel] = CurAltNum;
saveblah = attribsRefdFromAction;
attribsRefdFromAction = empty;
alt( toksrefd,rulesrefd );
b = g = zzaArg(zztasp1,1);
-
+
if ( ((Junction *)g.left)->p1->ntype == nAction )
{
ActionNode *actionNode=(ActionNode *)
@@ -1705,7 +1705,7 @@ set *rulesrefd ;
while ( (LA(1)==133) ) {
eg = exception_group();

-
+
if ( eg!=NULL ) {
/* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
/* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
@@ -1729,7 +1729,7 @@ set *rulesrefd ;

alt( toksrefd,rulesrefd );
g = Or(g, zzaArg(zztasp2,2));
-
+
((Junction *)g.left)->blockid = CurBlockID;
{
zzBLOCK(zztasp3);
@@ -1738,7 +1738,7 @@ set *rulesrefd ;
while ( (LA(1)==133) ) {
eg = exception_group();

-
+
if ( eg!=NULL ) {
/* MR7 ***** eg->altID = makeAltID(CurBlockID,CurAltNum); *****/
/* MR7 ***** CurAltStart->exception_label = eg->altID; *****/
@@ -1762,7 +1762,7 @@ set *rulesrefd ;
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd5, 0x20);
}
@@ -1784,7 +1784,7 @@ set *rulesrefd ;
int n=0; Graph g; int e_num=0, old_not=0; Node *node; set elems, dif;
int first_on_line = 1, use_def_MT_handler = 0;
g.left=NULL; g.right=NULL;
-
+
CurAltStart = NULL;
elems = empty;
inAlt = 1;
@@ -1834,7 +1834,7 @@ set *rulesrefd ;
node = element( old_not, first_on_line, use_def_MT_handler );

if ( node!=NULL && node->ntype!=nAction ) first_on_line = 0;
-
+
if ( zzaArg(zztasp2,2 ).left!=NULL ) {
g = Cat(g, zzaArg(zztasp2,2));
n++;
@@ -1888,7 +1888,7 @@ inAlt = 0;
return;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd6, 0x2);
}
@@ -1912,7 +1912,7 @@ element_label()
lab = mystrdup(LATEXT(1));
zzCONSUME;

-
+
UsedNewStyleLabel = 1;
if ( UsedOldStyleAttrib ) err("cannot mix with new-style labels with old-style $i");
t = (TermEntry *) hash_get(Tname, lab);
@@ -1970,7 +1970,7 @@ int use_def_MT_handler ;
PCCTS_PURIFY(_retv,sizeof(Node * ))
zzMake0;
{
-
+
Attrib blk;
Predicate *pred = NULL;
int local_use_def_MT_handler=0;
@@ -1985,9 +1985,9 @@ int use_def_MT_handler ;
int ampersandStyle;
int height; /* MR11 */
int equal_height; /* MR11 */
-
+
char* pFirstSetSymbol = NULL; /* MR21 */
-
+
_retv = NULL;
if ( (setwd6[LA(1)]&0x8) ) {
{
@@ -2012,7 +2012,7 @@ int use_def_MT_handler ;
{
if ( (LA(1)==TokenTerm) ) {
zzmatch(TokenTerm);
-
+
term = (TermEntry *) hash_get(Tname, LATEXT(1));
if ( term==NULL && UserDefdTokens ) {
err("implicit token definition not allowed with #tokdefs");
@@ -2069,7 +2069,7 @@ int use_def_MT_handler ;
zzEXIT(zztasp3);
}
}
-
+
if ( p!=NULL && (p->upper_range!=0 || p->tclass || old_not) )
list_add(&MetaTokenNodes, (void *)p);
{
@@ -2117,7 +2117,7 @@ int use_def_MT_handler ;
zzEXIT(zztasp3);
}
}
-
+
if ( p!=NULL && first_on_line ) {
CurAltStart = (Junction *)zzaRet.left;
altAdd(CurAltStart); /* MR7 */
@@ -2130,7 +2130,7 @@ int use_def_MT_handler ;
else {
if ( (LA(1)==QuotedTerm) ) {
zzmatch(QuotedTerm);
-
+
term = (TermEntry *) hash_get(Texpr, LATEXT(1));
if ( term==NULL && UserDefdTokens ) {
err("implicit token definition not allowed with #tokdefs");
@@ -2228,10 +2228,10 @@ int use_def_MT_handler ;
zzEXIT(zztasp3);
}
}
-
+
if ( p!=NULL && (p->upper_range!=0 || p->tclass || old_not) )
list_add(&MetaTokenNodes, (void *)p);
-
+
if ( first_on_line ) {
CurAltStart = (Junction *)zzaRet.left;
altAdd(CurAltStart); /* MR7 */
@@ -2276,7 +2276,7 @@ int use_def_MT_handler ;
}
}
list_add(&MetaTokenNodes, (void *)p);
-
+
if ( first_on_line ) {
CurAltStart = (Junction *)zzaRet.left;
altAdd(CurAltStart); /* MR7 */
@@ -2356,7 +2356,7 @@ int use_def_MT_handler ;
if ( (LA(1)==105) ) {
zzmatch(105); zzCONSUME;
zzmatch(PassAction);
-
+
a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(a!=NULL, "rule element: cannot allocate assignment");
strcpy(a, LATEXT(1));
@@ -2372,7 +2372,7 @@ int use_def_MT_handler ;
zzEXIT(zztasp3);
}
}
-
+
if ( label!=NULL ) {
rr->el_label = label->str;
label->elem = (Node *)rr;
@@ -2424,7 +2424,7 @@ int use_def_MT_handler ;
char *a;
if ( (LA(1)==PassAction) ) {
zzmatch(PassAction);
-
+
a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(a!=NULL, "rule element: cannot allocate predicate fail action");
strcpy(a, LATEXT(1));
@@ -2511,7 +2511,7 @@ int use_def_MT_handler ;
{
if ( (LA(1)==NonTerminal) ) {
zzmatch(NonTerminal);
-
+
/* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
/* MR21 */ sizeof(char));
/* MR21 */ require(pFirstSetSymbol!=NULL,
@@ -2524,7 +2524,7 @@ int use_def_MT_handler ;
else {
if ( (LA(1)==TokenTerm) ) {
zzmatch(TokenTerm);
-
+
/* MR21 */ pFirstSetSymbol = (char *) calloc(strlen(LATEXT(1))+1,
/* MR21 */ sizeof(char));
/* MR21 */ require(pFirstSetSymbol!=NULL,
@@ -2559,7 +2559,7 @@ int use_def_MT_handler ;
zzmatch(115);
blk = zzaRet = zzaArg(zztasp2,2);
/* MR23 */ CurBlockID_array[BlkLevel] = (-1);
- /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
--BlkLevel;
zzCONSUME;

@@ -2627,7 +2627,7 @@ int use_def_MT_handler ;
char *a;
if ( (LA(1)==PassAction) ) {
zzmatch(PassAction);
-
+
a = (char *)calloc(strlen(LATEXT(1))+1, sizeof(char));
require(a!=NULL, "rule element: cannot allocate predicate fail action");
strcpy(a, LATEXT(1));
@@ -2648,7 +2648,7 @@ int use_def_MT_handler ;
altAdd(CurAltStart); /* MR7 */
};
_retv = (Node *)act;
-
+
pred = computePredFromContextGuard(blk,&predMsgDone); /* MR10 */
if ( pred==NULL) { /* MR10 */
if ( !predMsgDone) err("invalid or missing context guard"); /* MR10 */
@@ -2707,7 +2707,7 @@ int use_def_MT_handler ;
zzEXIT(zztasp3);
}
}
-
+
if ( pred==NULL && !predMsgDone) { /* MR10 */
((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
@@ -2725,10 +2725,10 @@ int use_def_MT_handler ;
block( &toksrefd,&rulesrefd );
zzaRet = makeOpt(zzaArg(zztasp2,2),approx,pFirstSetSymbol);
/* MR23 */ CurBlockID_array[BlkLevel] = (-1);
- /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
+ /* MR23 */ CurAltNum_array[BlkLevel] = (-1);
--BlkLevel;
zzmatch(98);
-
+
((Junction *)((Junction *)zzaRet.left)->p1)->blockid = CurBlockID;
((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
@@ -2787,7 +2787,7 @@ int use_def_MT_handler ;
return _retv;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd9, 0x1);
return _retv;
@@ -2842,7 +2842,7 @@ exception_group()
char *p;
if ( (LA(1)==PassAction) ) {
zzmatch(PassAction);
-
+
p = LATEXT(1)+1;
p[strlen(p)-1] = '\0'; /* kill trailing space */
label = (LabelEntry *) hash_get(Elabel, LATEXT(1)+1);
@@ -2906,7 +2906,7 @@ exception_group()
zzEXIT(zztasp2);
}
}
-
+
if ( label!=NULL ) {
/* Record ex group in sym tab for this label */
if ( label->ex_group!=NULL ) {
@@ -2935,9 +2935,9 @@ exception_group()
} /* end switch */
/* MR6 */ }; /* end test on label->elem */
} /* end test on label->ex_group */
-
+
} /* end test on exception label */
-
+
/* MR7 */
/* MR7 */ if (BlkLevel == 1 && label == NULL) {
/* MR7 */ _retv->forRule=1;
@@ -2958,7 +2958,7 @@ exception_group()
return _retv;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd9, 0x10);
return _retv;
@@ -2980,7 +2980,7 @@ exception_handler()
{
;
zzmatch(135);
-
+
_retv = (ExceptionHandler *)calloc(1, sizeof(ExceptionHandler));
require(_retv!=NULL, "exception: cannot allocate handler");
zzCONSUME;
@@ -2991,7 +2991,7 @@ exception_handler()
{
if ( (LA(1)==NonTerminal) ) {
zzmatch(NonTerminal);
-
+
_retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
strcpy(_retv->signalname, LATEXT(1));
@@ -3001,7 +3001,7 @@ exception_handler()
else {
if ( (LA(1)==TokenTerm) ) {
zzmatch(TokenTerm);
-
+
_retv->signalname = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(_retv->signalname!=NULL, "exception: cannot allocate sig name");
strcpy(_retv->signalname, LATEXT(1));
@@ -3021,7 +3021,7 @@ exception_handler()
_retv->action = NULL;
if ( (LA(1)==Action) ) {
zzmatch(Action);
-
+
_retv->action = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
require(_retv->action!=NULL, "exception: cannot allocate action");
strcpy(_retv->action, LATEXT(1));
@@ -3040,7 +3040,7 @@ exception_handler()
return _retv;
fail:
zzEXIT(zztasp1);
- CannotContinue=TRUE;
+ CannotContinue=TRUE;
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd9, 0x40);
return _retv;
@@ -3159,15 +3159,15 @@ defines(fname)
zzCONSUME;

zzmatch(INT);
-
+
v = atoi(LATEXT(1));
/* fprintf(stderr, "#token %s=%d\n", t, v);*/
-
+
/* MR2 Andreas Magnusson (Andreas.Magnusson@mailbox.swipnet.se) */
/* MR2 Fix to bug introduced by 1.33MR1 for #tokdefs */
/* MR2 Don't let #tokdefs be confused by */
/* MR2 DLGminToken and DLGmaxToken */
-
+
if ( ! isDLGmaxToken(t)) { /* MR2 */
TokenNum = v;
if ( v>maxt ) maxt=v;
@@ -3234,7 +3234,7 @@ enum_def(fname)
zzEXIT(zztasp2);
}
}
-
+
/* fprintf(stderr, "#token %s=%d\n", t, v);*/
TokenNum = v;
if ( v>maxt ) maxt=v; /* MR3 */
@@ -3298,7 +3298,7 @@ enum_def(fname)
zzEXIT(zztasp4);
}
}
-
+
/* fprintf(stderr, "#token %s=%d\n", t, v);*/
TokenNum = v;
if ( v>maxt ) maxt=v; /* MR3 */
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c
index 5cb657bb2eee..4f36da950e1e 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c
@@ -249,7 +249,7 @@ char *eclass;
unsigned deg=0;
set a;
require(eclass!=NULL, "doEclass: NULL eset");
-
+
p = (ECnode *) eclass;
lexmode(p->lexclass); /* switch to lexclass where errclass is defined */
p->eset = empty;
@@ -717,7 +717,7 @@ GenParser_c_Hdr()
fprintf(Parser_c, " * with AHPCRC, University of Minnesota\n");
fprintf(Parser_c, " * ANTLR Version %s\n", Version);
fprintf(Parser_c, " */\n\n");
-
+
if ( FirstAction != NULL ) dumpAction(FirstAction,Parser_c, 0, -1, 0, 1); /* MR11 MR15b */

fprintf(Parser_c, "#define ANTLR_VERSION %s\n", VersionDef);
@@ -846,7 +846,7 @@ GenParser_h_Hdr()
fprintf(Parser_h, "#include \"%s\"\n\n", APARSER_H);

if ( HdrAction != NULL ) dumpAction( HdrAction, Parser_h, 0, -1, 0, 1);
-
+
/* MR10 */ if (ClassDeclStuff == NULL) {
/* MR10 */ fprintf(Parser_h, "class %s : public ANTLRParser {\n", CurrentClassName);
/* MR10 */ } else {
@@ -887,7 +887,7 @@ GenErrHdr( )
fprintf(ErrFile, " */\n\n");

if ( FirstAction != NULL ) dumpAction( FirstAction, ErrFile, 0, -1, 0, 1); /* MR11 MR15b */
-
+
fprintf(ErrFile, "#define ANTLR_VERSION %s\n", VersionDef);

fprintf(ErrFile, "#include \"pcctscfg.h\"\n");
@@ -916,7 +916,7 @@ GenErrHdr( )
if ( DemandLookahead ) fprintf(ErrFile, "#define DEMAND_LOOK\n");
fprintf(ErrFile, "#include \"antlr.h\"\n");
if ( GenAST ) fprintf(ErrFile, "#include \"ast.h\"\n");
-
+
if ( UserDefdTokens ) fprintf(ErrFile, "#include %s\n", UserTokenDefsFile);
/* still need this one as it has the func prototypes */
fprintf(ErrFile, "#include \"%s\"\n", DefFileName);
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c
index 4eb3b02af181..641fa7a1a5d7 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c
@@ -96,7 +96,7 @@ int is_predicate;
Graph g;
ActionNode *a;
require(action!=NULL, "buildAction: invalid action");
-
+
j1 = newJunction();
j2 = newJunction();
a = newActionNode();
@@ -169,7 +169,7 @@ char *text;
Graph g;
TokNode *t;
require(text!=NULL, "buildToken: invalid token name");
-
+
j1 = newJunction();
j2 = newJunction();
t = newTokNode();
@@ -203,7 +203,7 @@ char *text;
TCnode *w;
TermEntry *p;
require(text!=NULL, "buildWildCard: invalid token name");
-
+
j1 = newJunction();
j2 = newJunction();
t = newTokNode();
@@ -278,7 +278,7 @@ char *text;
RuleRefNode *r;
RuleEntry *p;
require(text!=NULL, "buildRuleRef: invalid rule name");
-
+
j1 = newJunction();
j2 = newJunction();
r = newRNode();
@@ -344,7 +344,7 @@ Graph g2;
#endif
{
Graph g;
-
+
if ( g1.left == NULL && g1.right == NULL ) return g2;
if ( g2.left == NULL && g2.right == NULL ) return g1;
((Junction *)g1.right)->p1 = g2.left;
@@ -596,7 +596,7 @@ emptyAlt( )
j1->p1 = (Node *) j2;
g.left = (Node *) j1;
g.right = (Node *) j2;
-
+
return g;
}

@@ -624,7 +624,7 @@ emptyAlt3( )
j2->p1 = (Node *) j3;
g.left = (Node *) j1;
g.right = (Node *) j3;
-
+
return g;
}

@@ -695,7 +695,7 @@ newRNode( )
p->line = zzline;
p->astnode = ASTinclude;
p->altstart = NULL;
-
+
return p;
}

@@ -790,7 +790,7 @@ makelocks( )
{
char *p = (char *) calloc(CLL_k+1, sizeof(char));
require(p!=NULL, "cannot allocate lock array");
-
+
return p;
}

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c
index 8156159f7197..2272603c6bc8 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c
@@ -6,7 +6,7 @@
#include "hash.h"
#include "generic.h"

-void
+void
#ifdef __USE_PROTOS
dumpcycles(void)
#else
@@ -40,11 +40,11 @@ dumpcycles()
};
}

-void
+void
#ifdef __USE_PROTOS
-dumpfostack(int k)
+dumpfostack(int k)
#else
-dumpfostack(k)
+dumpfostack(k)
int k;
#endif
{
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c
index ba1384dabee0..cc2b8e1de170 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c
@@ -212,7 +212,7 @@ Junction *alt;
altArray[BlkLevel]=alt;
}

-static void
+static void
#ifdef __USE_PROTOS
arrayCheck(void)
#else
@@ -252,9 +252,9 @@ arrayCheck()

/* always call leFixup() BEFORE egFixup() */

-void
+void
#ifdef __USE_PROTOS
-egFixup(void)
+egFixup(void)
#else
egFixup()
#endif
@@ -277,9 +277,9 @@ egFixup()
/* always call leFixup() BEFORE egFixup() */

#ifdef __USE_PROTOS
-void leFixup(void)
+void leFixup(void)
#else
-void leFixup()
+void leFixup()
#endif
{

@@ -301,7 +301,7 @@ void leFixup()
#ifdef __USE_PROTOS
void altFixup(void)
#else
-void altFixup()
+void altFixup()
#endif
{

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c
index ff7dcdfdd550..cba0b39c638c 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c
@@ -54,7 +54,7 @@ CacheEntry *dumpFcache1(prev)
for (p=table; p<&(table[HashTableSize]); p++) {

CacheEntry *q =(CacheEntry *) *p;
-
+
if ( q != NULL && low==0 ) low = p-table;
while ( q != NULL ) {
if (strcmp(q->str,prev) > 0) {
@@ -98,11 +98,11 @@ void reportFcache(q)
MR_dumpTokenSet(stdout,1,q->fset);
}

-void
+void
#ifdef __USE_PROTOS
-DumpFcache(void)
+DumpFcache(void)
#else
-DumpFcache()
+DumpFcache()
#endif
{

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c
index e3fac09f2a0c..c35e6163afbd 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c
@@ -231,7 +231,7 @@ set *rk;
} else {
REACH(p->p1, k, rk, a);
}
- }
+ }

/* C a c h e R e s u l t s */

@@ -273,10 +273,10 @@ set *rk;
fprintf(stderr, "\n");
#endif
}
-
+
if (p->jtype != RuleBlk && p->p2 != NULL && /* MR14 */ ! p->guess) {
REACH(p->p2, k, rk, b);
- }
+ }

if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
p->jtype==aPlusBlk || p->jtype==EndRule )
@@ -421,7 +421,7 @@ set *rk;
}

REACH(p->next, k-1, rk, a);
-
+
if (MR_MaintainBackTrace) MR_pointerStackPop(&MR_BackTraceStack);

return a;
@@ -441,7 +441,7 @@ set *rk;

require(p!=NULL, "rJunc: NULL node");
require(p->ntype==nAction, "rJunc: not action");
-
+
/* MR11 */ if (p->is_predicate && p->ampersandPred != NULL) {
/* MR11 */ Predicate *pred=p->ampersandPred;
/* MR11 */ if (k <= pred->k) {
@@ -1171,7 +1171,7 @@ int jtype;
CurAmbigbtype = sub;
CurAmbigfile = alt1->file;
CurAmbigline = alt1->line;
-
+
/* Don't do full LL(n) analysis if (...)? block because the block,
by definition, defies LL(n) analysis.
If guess (...)? block and ambiguous then don't remove anything from
@@ -1252,9 +1252,9 @@ int jtype;
free((char *)ftbl);
return;
}
-
+
/* Not resolved with (..)? block. Do full LL(n) analysis */
-
+
/* ambig is the set of k-tuples truly in common between alt 1 and alt 2 */
/* MR11 VerifyAmbig once used fset destructively */

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c
index 8a4823a05446..4a69f2e1c68f 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c
@@ -236,7 +236,7 @@ int tok;
{
Tree *p, *newblk;
static int n=0;
-
+
if ( FreeList == NULL )
{
/*fprintf(stderr, "tnode: %d more nodes\n", TreeBlockAllocSize);*/
@@ -346,7 +346,7 @@ Tree *t;
#endif
{
Tree *u;
-
+
if ( t == NULL ) return NULL;
u = tnode(t->token);
u->v.rk = t->v.rk;
@@ -365,7 +365,7 @@ Tree *t;
#endif
{
Tree *u;
-
+
if ( t == NULL ) return NULL;
u = tnode(t->token);
u->v.rk = t->v.rk;
@@ -513,7 +513,7 @@ Tree *t;
t->down = tflatten( t->down );
t->right = tflatten( t->right );
if ( t->down == NULL ) return t;
-
+
if ( t->token == ALT )
{
Tree *u;
@@ -630,7 +630,7 @@ set *rk;
/* MR14 */ guess_point=p->p1;
/* MR14 */ }
/* MR14 */ p->guess_analysis_point=guess_point;
-/* MR14 */ }
+/* MR14 */ }

if ( p->p2 == NULL )
{
@@ -691,7 +691,7 @@ set *rk_out;
set rk, rk2;
int save_halt;
RuleEntry *q = (RuleEntry *) hash_get(Rname, p->text);
-
+
#ifdef DBG_TRAV
fprintf(stderr, "tRuleRef: %s\n", p->text);
#endif
@@ -1185,7 +1185,7 @@ int k, max_k;
#endif
{
Tree *t, *u;
-
+
if ( k>max_k ) return NULL;
if ( ftbl[k][findex[k]] == nil ) return NULL;
t = permute(k+1, max_k);
@@ -1195,7 +1195,7 @@ int k, max_k;
(findex[k])++; /* try next token at this k */
return permute(k, max_k);
}
-
+
u = tmake(tnode(ftbl[k][findex[k]]), t, NULL);
if ( k == max_k ) (findex[k])++;
return u;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c
index 8e41239f4751..ebf20b55850b 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c
@@ -172,9 +172,9 @@ static void OutLineInfo(); /* MR14 */
/* MR11 a convenient place to set a break point */

#ifdef __USE_PROTOS
-void MR_break(void)
+void MR_break(void)
#else
-void MR_break()
+void MR_break()
#endif
{
return;
@@ -1198,7 +1198,7 @@ int k;
#endif
{
require(t!=NULL, "genExprTreeOriginal: NULL tree");
-
+
if ( t->token == ALT )
{
_gen("("); genExprTreeOriginal(t->down, k); _gen(")");
@@ -1369,13 +1369,13 @@ static void genExprTree(tree,k)

#if 0
/* MR20 THM This was probably an error.
- The routine should probably reference that static
+ The routine should probably reference that static
"across" and this declaration hides it.
*/

int across;
#endif
-
+
require (tree != NULL,"genExprTree: tree is NULL");
require (k > 0,"genExprTree: k <= 0");

@@ -1557,7 +1557,7 @@ int *lastAltEmpty; /* MR23 */
*need_right_curly=0;
*lastAltEmpty = 0; /* MR23 */
if ( q->p2 == NULL ) /* only one alternative? Then don't need if */
- {
+ {
if (first_item_is_guess_block((Junction *)q->p1)!=NULL )
{
if (jtype != aLoopBlk && jtype != aOptBlk && jtype != aPlusBlk) {
@@ -1575,7 +1575,7 @@ int *lastAltEmpty; /* MR23 */
for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
{
if ( alt->p2 == NULL ) /* chk for empty alt */
- {
+ {
Node *p = alt->p1;
if ( p->ntype == nJunction )
{
@@ -1586,7 +1586,7 @@ int *lastAltEmpty; /* MR23 */

r: { A } b;
b: B;
-
+
with input "C"

Before MR21 the error message would be "expecting B - found C". After MR21
@@ -1714,7 +1714,7 @@ Junction *q;
while ( q!=NULL &&
( ( q->ntype==nAction ) ||
( q->ntype==nJunction &&
- (q->jtype==Generic || q->jtype == aLoopBlk)
+ (q->jtype==Generic || q->jtype == aLoopBlk)
)
)
)
@@ -1757,7 +1757,7 @@ Junction *q;
r : ( (A)? B
| C
)*
-
+
The routine analysis_point was seeing the guess block when
it was still analyzing the loopBegin block. As a consequence,
when it looked for the analysis_point it was processing the B, but
@@ -1771,7 +1771,7 @@ Junction *q;
| +-> G C G ----------------------+ |
| |
+--- G G G -------------------------------------+
-
+
Reported by Arpad Beszedes (beszedes@inf.u-szeged.hu).

MR30 This is still more complicated. This fix caused ambiguity messages
@@ -1890,9 +1890,9 @@ char *s;
};
goto stringizeExit;
stringizeStop:
- *p++='.';
- *p++='.';
- *p++='.';
+ *p++='.';
+ *p++='.';
+ *p++='.';
stringizeExit:
*p=0;
return stringizeBuf;
@@ -2013,7 +2013,7 @@ RuleRefNode *p;

require(p!=NULL, "genRuleRef: invalid node and/or rule");
require(p->ntype==nRuleRef, "genRuleRef: not rule reference");
-
+
if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
handler_id = p->altstart->exception_label;

@@ -2276,7 +2276,7 @@ TokNode *p;
/* MR27 */ ast_label_in_action = list_search_cstring(r->ast_labels_in_actions,
/* MR27 */ p->el_label);
/* MR27 */ }
-
+
OutLineInfo(output,p->line,FileStr[p->file]);

if ( !set_nil(p->tset) ) /* implies '.', ~Tok, or tokenclass */
@@ -2595,7 +2595,7 @@ TokNode *p;
And moved into genAction
*****************************************************************************
*/
-
+
gen("if (!(");

/* make sure that '#line n' is on front of line */ /* MR14 */
@@ -2635,12 +2635,12 @@ TokNode *p;
one. This is different than the case for semantic
predicates.
*/
-
+
/* MR23 */ if (GenCC) {
/* MR23 */ if (strstr(a->action, "LT(") != NULL) LTinTokenAction = 1;
/* MR23 */ }
/* MR23 */ else {
-/* MR23 */ if (strstr(a->action, "LA(") != NULL) LTinTokenAction = 1;
+/* MR23 */ if (strstr(a->action, "LA(") != NULL) LTinTokenAction = 1;
/* MR23 */ if (strstr(a->action, "LATEXT(") != NULL) LTinTokenAction = 1;
/* MR23 */ }

@@ -2737,7 +2737,7 @@ Junction *q;
BlockPreambleOption(q,q->pFirstSetSymbol); /* MR21 */
f = genBlk(q, aOptBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
/* MR23
- Bypass error clause generation when exceptions are used in {...} block
+ Bypass error clause generation when exceptions are used in {...} block
See multi-line note in genBlk near call to isEmptyAlt.
*/
if (! FoundException) {
@@ -3066,7 +3066,7 @@ Junction *q;
BlkLevel++;

BlockPreambleOption((Junction *)q, q->pFirstSetSymbol); /* MR21 */
-
+
/* first_item_is_guess_block doesn't care what kind of node it is */

guessBlock=first_item_is_guess_block( (Junction *)q->p1); /* MR10 */
@@ -3280,7 +3280,7 @@ Junction *q;

/* MR23
Bypass error clause generation when exceptions are used in a sub block
- in which the last alternative is epsilon. Example: "(A | B | )".
+ in which the last alternative is epsilon. Example: "(A | B | )".
See multi-line note in genBlk near call to isEmptyAlt.
*/
if (FoundException && lastAltEmpty) {
@@ -3289,7 +3289,7 @@ Junction *q;
else {
if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
}
-
+
{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
freeBlkFsets(q);
--BlkLevel;
@@ -3403,9 +3403,9 @@ do { /* MR10 Change recursion into iteration */
DumpFuncHeader(q,r);
tabs++;

- /* MR23
-
- If there is a single return value then it can be initialized in
+ /* MR23
+
+ If there is a single return value then it can be initialized in
the declaration using assignment syntax. If there are multiple
return values then antlr creates a struct and initialization takes
place element by element for each element of the struct. For
@@ -3419,7 +3419,7 @@ do { /* MR10 Change recursion into iteration */
mode because C does not have constructors. However, PURIFY is
not used in C++ mode because it might overwrite information created
by elements which have their own ctor.
-
+
*/

if ( q->ret!=NULL )
@@ -3568,7 +3568,7 @@ do { /* MR10 Change recursion into iteration */
FillSet( follow );
set_free( follow );

- /* MR20 G. Hobbelt
+ /* MR20 G. Hobbelt
Isn't it so that "fail:" is ONLY referenced when:

!FoundException || FoundGuessBlk ?
@@ -3576,7 +3576,7 @@ do { /* MR10 Change recursion into iteration */
Therefore add the "if" around this piece of code generation...

Should guessing mode also use _handler label instead of "fail"
- when exception handling is active? gen can automatically put
+ when exception handling is active? gen can automatically put
"if (guessing)" there so as to skip all kinds of user code.

*/
@@ -4269,7 +4269,7 @@ Node *q;
Junction *j;
require(q!=NULL, "findImmedAction: NULL node");
require(q->ntype>=1 && q->ntype<=NumNodeTypes, "findImmedAction: invalid node");
-
+
while ( q->ntype == nJunction )
{
j = (Junction *)q;
@@ -4292,14 +4292,14 @@ RuleRefNode *ruleRefNode;
#endif
{
char *q = ret_def;
-
+
tab();
while ( *retval != '\0' && *q != '\0')
{
while ( isspace((*retval)) ) retval++;
while ( *retval!=',' && *retval!='\0' ) fputc(*retval++, output);
fprintf(output, " = _trv.");
-
+
DumpNextNameInDef(&q, output);
while ( isspace(*q) ) q++;
fputc(';', output); fputc(' ', output);
@@ -4440,7 +4440,7 @@ int usePlusBlockBypass;

if ( GenCC ) {_gen1(",err%d", DefErrSet( &f, 1, NULL ));}
else _gen1(",zzerr%d", DefErrSet( &f, 1, NULL ));
-
+
set_free(f);
}
}
@@ -4614,12 +4614,12 @@ int final_newline;
** Junction* alt1;
** Junction* p;
** set rk;
-**
+**
** require (max_k <= CLL_k, "k > CLL_k");
-**
-**
+**
+**
** for (k = 1; k <= CLL_k; k++) {set_clr(q->fset[k]); }
-**
+**
** for (k = 1; k <= max_k; k++) {
** for (alt1=q; alt1 != NULL; alt1 = (Junction *)alt1->p2)
** {
@@ -4652,7 +4652,7 @@ char * pReturn;
int nest = 0;
char *q;

- require(pReturn!=NULL, "DumpInitializer: invalid string");
+ require(pReturn!=NULL, "DumpInitializer: invalid string");

while (*p != 0) {
p = endFormal(p,
@@ -4692,7 +4692,7 @@ int bInitializer;
char *q;
int count = 0;

- require(pReturn!=NULL, "DumpFormals: invalid string");
+ require(pReturn!=NULL, "DumpFormals: invalid string");

while (*p != 0) {
p = endFormal(p,
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h b/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h
index 30cc8b603148..bceed938f98c 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h
@@ -277,7 +277,7 @@ typedef Graph Attrib;
zzenterANTLR(f); \
st; ++zzasp; \
zzleaveANTLR(f);
- #endif
+ #endif
*********************************************************/
#endif

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c
index 68fe8fd22768..32e939ecb20d 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c
@@ -73,7 +73,7 @@ newHashTable( )
#endif
{
Entry **table;
-
+
table = (Entry **) calloc(size, sizeof(Entry *));
require( table != NULL, "cannot allocate hash table");
if ( strings == NULL )
@@ -111,7 +111,7 @@ Entry *rec;
unsigned h=0;
char *p=key;
require(table!=NULL && key!=NULL && rec!=NULL, "add: invalid addition");
-
+
Hash(p,h,size);
rec->next = table[h]; /* Add to singly-linked list */
table[h] = rec;
@@ -133,7 +133,7 @@ char *key;
Entry *q;
/* require(table!=NULL && key!=NULL, "get: invalid table and/or key");*/
if ( !(table!=NULL && key!=NULL) ) *((char *) 34) = 3;
-
+
Hash(p,h,size);
for (q = table[h]; q != NULL; q = q->next)
{
@@ -155,13 +155,13 @@ Entry **table;
int i,n=0,low=0, hi=0;
Entry **p;
float avg=0.0;
-
+
for (i=0; i<20; i++) count[i] = 0;
for (p=table; p<&(table[size]); p++)
{
Entry *q = *p;
int len;
-
+
if ( q != NULL && low==0 ) low = p-table;
len = 0;
if ( q != NULL ) fprintf(stderr, "[%d]", p-table);
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c
index fddb46bbc398..3c530dfe5331 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c
@@ -291,7 +291,7 @@ genDefFile( )
if ( TokenString(i)!=NULL && i != EpToken )
{
TermEntry *p;
-
+
if ( WarningLevel>1 )
{
int j;
@@ -491,7 +491,7 @@ Junction *p;
DumpRetValStruct(f, p->ret, i);
}
fprintf(f, "\n#ifdef __USE_PROTOS\n");
-/* MR23 */ if ( hasMultipleOperands(p->ret) )
+/* MR23 */ if ( hasMultipleOperands(p->ret) )
{
fprintf(f, "extern struct _rv%d", i);
}
@@ -762,7 +762,7 @@ FILE *f;
char *pSeparator;
int nest = 0;

- require(s!=NULL, "DumpType: invalid type string");
+ require(s!=NULL, "DumpType: invalid type string");

p = endFormal(s,
&pDataType,
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c
index 051ee4ec5d28..be9b8c596983 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c
@@ -799,7 +799,7 @@ char *argv[];
buildRulePtr(); /* create mapping from rule # to RuleBlk junction */
ComputeErrorSets();
FoLink( (Node *)SynDiag ); /* add follow links to end of all rules */
-
+
if ( GenCR ) GenCrossRef( SynDiag );

if ( CodeGen )
@@ -955,11 +955,11 @@ char *argv[];
}
cleanUp();
exit(PCCTS_EXIT_SUCCESS);
- return 0; /* MR11 make compilers happy */
+ return 0; /* MR11 make compilers happy */
}

-static void
-#ifdef __USE_PROTOS
+static void
+#ifdef __USE_PROTOS
init( void )
#else
init( )
@@ -990,7 +990,7 @@ init( )
(Entry *)newSignalEntry("NoSemViableAlt"));
require(q!=NULL, "cannot alloc signal entry");
q->signum = sigNoSemViableAlt;
-
+
reserved_positions = empty;
all_tokens = empty;
imag_tokens = empty;
@@ -1041,7 +1041,7 @@ buildRulePtr( )
Junction *p = SynDiag;
RulePtr = (Junction **) calloc(NumRules+1, sizeof(Junction *));
require(RulePtr!=NULL, "cannot allocate RulePtr array");
-
+
while ( p!=NULL )
{
require(r<=NumRules, "too many rules???");
@@ -1224,7 +1224,7 @@ char *a3;
#endif
{
static char buf[250]; /* DANGEROUS as hell !!!!!! */
-
+
sprintf(buf, s, a1, a2, a3);
return( buf );
}
@@ -1240,7 +1240,7 @@ int d;
#endif
{
static char buf[250]; /* DANGEROUS as hell !!!!!! */
-
+
sprintf(buf, s, d);
return( buf );
}
@@ -1256,7 +1256,7 @@ int d2;
#endif
{
static char buf[250]; /* DANGEROUS as hell !!!!!! */
-
+
sprintf(buf, s, d1, d2);
return( buf );
}
@@ -1422,7 +1422,7 @@ exit(PCCTS_EXIT_FAILURE);
}
}

-static void
+static void
#ifdef __USE_PROTOS
CompleteContextGuards(void)
#else
@@ -1507,7 +1507,7 @@ OutMetaName(char *n)
OutMetaName(n)
char *n;
#endif
-{
+{
static char *dir_sym = DirectorySymbol;
static char newname[MaxFileName+1];
char *p;
@@ -1607,15 +1607,15 @@ int l;
char *err;
#endif
{
- fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, ErrHdr, f, l);
fprintf(stderr, " warning: %s\n", err);
}

void
#ifdef __USE_PROTOS
-warn(char *err)
+warn(char *err)
#else
-warn(err)
+warn(err)
char *err;
#endif
{
@@ -1629,7 +1629,7 @@ void
#ifdef __USE_PROTOS
warnNoCR( char *err )
#else
-warnNoCR( err )
+warnNoCR( err )
char *err;
#endif
{
@@ -1660,15 +1660,15 @@ char *f;
int l;
#endif
{
- fprintf(stderr, ErrHdr, f, l);
+ fprintf(stderr, ErrHdr, f, l);
fprintf(stderr, " error: %s\n", err);
}

void
#ifdef __USE_PROTOS
-err(char *err)
+err(char *err)
#else
-err(err)
+err(err)
char *err;
#endif
{
@@ -1680,9 +1680,9 @@ char *err;

void
#ifdef __USE_PROTOS
-errNoCR( char *err )
+errNoCR( char *err )
#else
-errNoCR( err )
+errNoCR( err )
char *err;
#endif
{
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile
index 8f2cc78c5947..9de355d0e646 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile
@@ -8,7 +8,7 @@
# company may do whatever they wish with source code distributed with
# PCCTS or the code generated by PCCTS, including the incorporation of
# PCCTS, or its output, into commerical software.
-#
+#
# We encourage users to develop software with PCCTS. However, we do ask
# that credit is given to us for developing PCCTS. By "credit",
# we mean that if you incorporate our source code into one of your
@@ -205,7 +205,7 @@ scan.o : scan.c mode.h tokens.h
set.o : $(SET)/set.c
$(BUILD_CC) $(BUILD_CFLAGS) -c -o set.o $(SET)/set.c

-%.o : %.c
+%.o : %.c
$(BUILD_CC) -c $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $< -o $@

#
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c
index 3f58da34c54b..abcb95260e3b 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c
@@ -479,7 +479,7 @@ char *term;
{
TermEntry *p;
require(term!=NULL, "Tnum: invalid terminal");
-
+
if ( *term=='"' ) p = (TermEntry *) hash_get(Texpr, term);
else p = (TermEntry *) hash_get(Tname, term);
if ( p == NULL ) return 0;
@@ -559,14 +559,14 @@ int sz;
{
Entry *p;
require(text!=NULL, "new: NULL terminal");
-
+
if ( (p = (Entry *) calloc(1,sz)) == 0 )
{
fatal_internal("newEntry: out of memory for terminals\n");
exit(PCCTS_EXIT_FAILURE);
}
p->str = mystrdup(text);
-
+
return(p);
}

@@ -671,7 +671,7 @@ int list_search_cstring(list, cstring)
}

/* F O L L O W C y c l e S t u f f */
-
+
/* make a key based upon (rulename, computation, k value).
* Computation values are 'i'==FIRST, 'o'==FOLLOW.
*/
@@ -692,7 +692,7 @@ int k;
{
static char key[MaxRuleName+2+2+1]; /* MR10 */
int i;
-
+
if ( k > 99 ) /* MR10 */
fatal("k>99 is too big for this implementation of ANTLR!\n"); /* MR10 */
if ( (i=strlen(rule)) > MaxRuleName ) /* MR10 */
@@ -839,7 +839,7 @@ int k;
for (p=FoTOS[k]; *p != r->rulenum && p >= FoStack[k]; --p) {;}
require(p>=FoStack[k], "RegisterCycle: FoStack is screwed up beyond belief");
if ( p == FoTOS[k] ) return; /* don't worry about cycles to oneself */
-
+
/* compute cyclic dependents (rules in cycle except head) */
c = newCycle;
require(c!=NULL, "RegisterCycle: couldn't alloc new cycle");
@@ -855,7 +855,7 @@ int k;
hash_add(Fcache, Fkey(RulePtr[*p]->rname,'o',k), (Entry *)f);
}
f->incomplete = TRUE;
-
+
set_orel(*p, &(c->cyclicDep)); /* mark rule as dependent of croot */
}
list_add(&(Cycles[k]), (void *)c);
@@ -890,7 +890,7 @@ int k;

unsigned *cursor; /* MR10 */
unsigned *origin; /* MR10 */
-
+
/*fprintf(stderr, "Resolving following cycles for %d\n", k);*/
while ( changed )
{
@@ -1052,7 +1052,7 @@ Junction *q;
int doing_rule;
require(q!=NULL, "pJunc: NULL node");
require(q->ntype==nJunction, "pJunc: not junction");
-
+
if ( q->pvisited == TRUE ) return;
q->pvisited = TRUE;
switch ( q->jtype )
@@ -1177,7 +1177,7 @@ RuleRefNode *p;
{
require(p!=NULL, "pRuleRef: NULL node");
require(p->ntype==nRuleRef, "pRuleRef: not rule ref node");
-
+
printf( " %s", p->text);
PRINT(p->next);
}
@@ -1210,7 +1210,7 @@ ActionNode *p;
{
require(p!=NULL, "pAction: NULL node");
require(p->ntype==nAction, "pAction: not action node");
-
+
PRINT(p->next);
}

@@ -1424,7 +1424,7 @@ Junction *p;
hand written code ?

Examples of input:
-
+
Foo f,
Foo f = Foo(1),
Foo f = Foo(1,2),
@@ -1521,7 +1521,7 @@ int *pNest;
#endif
{
char *p = pStart;
-
+
int nest = 0;

*pNest = (-1);
@@ -1544,11 +1544,11 @@ int *pNest;
nest--;
p++;
break;
-
+
case '"' :
p = skipStringLiteral(p);
break;
-
+
case '\'' :
p = skipCharLiteral(p);
break;
@@ -1609,7 +1609,7 @@ char * pStart;
char *pSeparator;
int nest = 0;

- require(pStart!=NULL, "getInitializer: invalid string");
+ require(pStart!=NULL, "getInitializer: invalid string");

p = endFormal(pStart,
&pDataType,
@@ -1686,7 +1686,7 @@ static char strBetweenWorkArea[MAX_STR_BETWEEN_WORK_AREA];
to a work area. The start of the string is pStart. The end of the string
is the character before pNext, or if pNext is null then the character before
pStop. Trailing spaces are not included in the copy operation.
-
+
This is used when a string contains several parts. The pNext part may be
optional. The pStop will stop the scan when the optional part is not present
(is a null pointer).
@@ -1740,7 +1740,7 @@ char *pStop;
Example: pointer to "f".

ppEqualSign Returns a pointer to the equal sign separating the
- formal symbol from the initial value. If there is
+ formal symbol from the initial value. If there is
no "=" then this will be NULL.

ppValue Returns a pointer to the initial value part of the
@@ -1755,8 +1755,8 @@ char *pStop;
for a successful parse of this portion of the formal
list.

-*/
-
+*/
+
#ifdef __USE_PROTOS
char * endFormal(char *pStart,
char **ppDataType,
@@ -1803,7 +1803,7 @@ int *pNest;
/* We are not looking for the symbol, we are looking
for the separator that follows the symbol. Then
we'll back up.
-
+
Search for the ',' or '=" or null terminator.
*/

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c
index b57f5ded846c..0d048dd6bf68 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c
@@ -1026,7 +1026,7 @@ void MR_complete_tree(predDepth,t,incomplete)

rk2=empty;

- while ( !set_nil(*incomplete) ) {
+ while ( !set_nil(*incomplete) ) {
k2 = set_int(*incomplete);
if (k2 > (unsigned) predDepth) break; /* <=== another exit from loop */
set_rm(k2,*incomplete);
@@ -2727,7 +2727,7 @@ int MR_suppressK_client(tree,tokensInChain)
/*** constrain = &(fset[1]); ***/

MR_setConstrainPointer(&(fset[1])); /* MR18 */
-
+
MR_pointerStackReset(&MR_BackTraceStack);

TRAV(suppressNode,maxk,&incomplete,t);
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c
index eb11c4d9504f..0ef4824ef2a6 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c
@@ -320,7 +320,7 @@ Node *alt;
case nJunction :
{
Predicate *a, *b;
- Junction *p = (Junction *) alt;
+ Junction *p = (Junction *) alt;

/* lock nodes */
if ( p->jtype==aLoopBlk || p->jtype==RuleBlk ||
@@ -672,7 +672,7 @@ Predicate *a;

/* any k left to do? if so, link onto tree */
while ( !set_nil(a->completionTree) )
- {
+ {
k2 = set_int(a->completionTree);
set_rm(k2, a->completionTree);
u = NULL;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c b/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c
index 9b4bde08e6ea..67c6aa0323bf 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c
@@ -68,7 +68,7 @@ char *inline_set();

int tokenActionActive=0; /* MR1 */

-
+



@@ -81,18 +81,18 @@ char *toStr, *fromStr;
#endif
{
int i, j, k;
-
+
if (!fromStr || !toStr) return toStr;
-
+
/* find the first " */
-
+
for (i=0;
(i<MaxFileName) &&
(fromStr[i] != '\n') &&
(fromStr[i] != '\r') &&
(fromStr[i] != '\"');
i++) /* nothing */ ;
-
+
if ( (i == MaxFileName) ||
(fromStr[i] == '\n') ||
(fromStr[i] == '\r') ) {
@@ -135,7 +135,7 @@ toStr[i-k-1] = fromStr[i];

/* MR14 end of a block to support #line in antlr source code */

-
+


#ifdef __USE_PROTOS
@@ -153,7 +153,7 @@ LabelEntry *le;
}

static void act1()
-{
+{
NLA = Eof;
/* L o o k F o r A n o t h e r F i l e */
{
@@ -169,362 +169,362 @@ static void act1()


static void act2()
-{
+{
NLA = 76;
- zzskip();
+ zzskip();
}


static void act3()
-{
+{
NLA = 77;
- zzline++; zzskip();
+ zzline++; zzskip();
}


static void act4()
-{
+{
NLA = 78;
zzmode(ACTIONS); zzmore();
istackreset();
- pushint(']');
+ pushint(']');
}


static void act5()
-{
+{
NLA = 79;
action_file=CurFile; action_line=zzline;
zzmode(ACTIONS); zzmore();
list_free(&CurActionLabels,0); /* MR10 */
numericActionLabel=0; /* MR10 */
istackreset();
- pushint('>');
+ pushint('>');
}


static void act6()
-{
+{
NLA = 80;
- zzmode(STRINGS); zzmore();
+ zzmode(STRINGS); zzmore();
}


static void act7()
-{
+{
NLA = 81;
- zzmode(COMMENTS); zzskip();
+ zzmode(COMMENTS); zzskip();
}


static void act8()
-{
+{
NLA = 82;
- warn("Missing /*; found dangling */"); zzskip();
+ warn("Missing /*; found dangling */"); zzskip();
}


static void act9()
-{
+{
NLA = 83;
- zzmode(CPP_COMMENTS); zzskip();
+ zzmode(CPP_COMMENTS); zzskip();
}


static void act10()
-{
+{
NLA = 84;
-
+
zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
}


static void act11()
-{
+{
NLA = 85;
-
+
zzline++; zzmore();
}


static void act12()
-{
+{
NLA = 86;
- warn("Missing <<; found dangling >>"); zzskip();
+ warn("Missing <<; found dangling >>"); zzskip();
}


static void act13()
-{
+{
NLA = WildCard;
}


static void act14()
-{
+{
NLA = 88;
FoundException = 1; /* MR6 */
- FoundAtOperator = 1;
+ FoundAtOperator = 1;
}


static void act15()
-{
+{
NLA = Pragma;
}


static void act16()
-{
+{
NLA = FirstSetSymbol;
}


static void act17()
-{
+{
NLA = 94;
}


static void act18()
-{
+{
NLA = 95;
}


static void act19()
-{
+{
NLA = 96;
}


static void act20()
-{
+{
NLA = 97;
}


static void act21()
-{
+{
NLA = 98;
}


static void act22()
-{
+{
NLA = 99;
}


static void act23()
-{
+{
NLA = 102;
}


static void act24()
-{
+{
NLA = 103;
}


static void act25()
-{
+{
NLA = 104;
}


static void act26()
-{
+{
NLA = 105;
}


static void act27()
-{
+{
NLA = 106;
}


static void act28()
-{
+{
NLA = 107;
}


static void act29()
-{
+{
NLA = 108;
}


static void act30()
-{
+{
NLA = 109;
}


static void act31()
-{
+{
NLA = 110;
}


static void act32()
-{
+{
NLA = 111;
}


static void act33()
-{
+{
NLA = 112;
}


static void act34()
-{
+{
NLA = 113;
}


static void act35()
-{
+{
NLA = 114;
}


static void act36()
-{
+{
NLA = 115;
}


static void act37()
-{
+{
NLA = 116;
}


static void act38()
-{
+{
NLA = 117;
}


static void act39()
-{
+{
NLA = 118;
}


static void act40()
-{
+{
NLA = 119;
}


static void act41()
-{
+{
NLA = 120;
}


static void act42()
-{
+{
NLA = 121;
}


static void act43()
-{
+{
NLA = 122;
}


static void act44()
-{
+{
NLA = 123;
}


static void act45()
-{
+{
NLA = 124;
}


static void act46()
-{
+{
NLA = 125;
}


static void act47()
-{
+{
NLA = 126;
}


static void act48()
-{
+{
NLA = 127;
}


static void act49()
-{
+{
NLA = 128;
}


static void act50()
-{
+{
NLA = 129;
}


static void act51()
-{
+{
NLA = 130;
}


static void act52()
-{
+{
NLA = 131;
}


static void act53()
-{
+{
NLA = 132;
}


static void act54()
-{
+{
NLA = 133;
}


static void act55()
-{
+{
NLA = 134;
}


static void act56()
-{
+{
NLA = 135;
}


static void act57()
-{
+{
NLA = NonTerminal;
-
+
while ( zzchar==' ' || zzchar=='\t' ) {
zzadvance();
}
@@ -533,9 +533,9 @@ static void act57()


static void act58()
-{
+{
NLA = TokenTerm;
-
+
while ( zzchar==' ' || zzchar=='\t' ) {
zzadvance();
}
@@ -544,58 +544,58 @@ static void act58()


static void act59()
-{
+{
NLA = 136;
- warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip();
+ warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip();
}

static unsigned char shift0[257] = {
- 0, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 1, 2, 58, 58, 3, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 1, 40, 6, 9, 58, 58, 45,
- 58, 46, 47, 8, 52, 58, 58, 18, 7, 16,
- 14, 15, 16, 16, 16, 16, 16, 16, 16, 41,
- 42, 5, 48, 17, 53, 19, 56, 56, 56, 56,
- 56, 26, 56, 56, 56, 56, 56, 51, 56, 56,
- 56, 56, 56, 56, 29, 56, 56, 56, 56, 56,
- 56, 56, 4, 20, 58, 50, 57, 58, 23, 31,
- 38, 34, 13, 35, 24, 33, 11, 55, 36, 10,
- 25, 12, 32, 21, 55, 22, 27, 28, 54, 55,
- 55, 43, 30, 55, 39, 44, 37, 49, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
- 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 0, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 1, 2, 58, 58, 3, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 1, 40, 6, 9, 58, 58, 45,
+ 58, 46, 47, 8, 52, 58, 58, 18, 7, 16,
+ 14, 15, 16, 16, 16, 16, 16, 16, 16, 41,
+ 42, 5, 48, 17, 53, 19, 56, 56, 56, 56,
+ 56, 26, 56, 56, 56, 56, 56, 51, 56, 56,
+ 56, 56, 56, 56, 29, 56, 56, 56, 56, 56,
+ 56, 56, 4, 20, 58, 50, 57, 58, 23, 31,
+ 38, 34, 13, 35, 24, 33, 11, 55, 36, 10,
+ 25, 12, 32, 21, 55, 22, 27, 28, 54, 55,
+ 55, 43, 30, 55, 39, 44, 37, 49, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
+ 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
58, 58, 58, 58, 58, 58, 58
};


static void act60()
-{
+{
NLA = Eof;
}


static void act61()
-{
+{
NLA = QuotedTerm;
- zzmode(START);
+ zzmode(START);
}


static void act62()
-{
+{
NLA = 3;
-
+
zzline++;
warn("eoln found in string");
zzskip();
@@ -603,72 +603,72 @@ static void act62()


static void act63()
-{
+{
NLA = 4;
- zzline++; zzmore();
+ zzline++; zzmore();
}


static void act64()
-{
+{
NLA = 5;
- zzmore();
+ zzmore();
}


static void act65()
-{
+{
NLA = 6;
- zzmore();
+ zzmore();
}

static unsigned char shift1[257] = {
- 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
};


static void act66()
-{
+{
NLA = Eof;
}


static void act67()
-{
+{
NLA = 7;
- zzmode(ACTIONS); zzmore();
+ zzmode(ACTIONS); zzmore();
}


static void act68()
-{
+{
NLA = 8;
-
+
zzline++;
warn("eoln found in string (in user action)");
zzskip();
@@ -676,72 +676,72 @@ static void act68()


static void act69()
-{
+{
NLA = 9;
- zzline++; zzmore();
+ zzline++; zzmore();
}


static void act70()
-{
+{
NLA = 10;
- zzmore();
+ zzmore();
}


static void act71()
-{
+{
NLA = 11;
- zzmore();
+ zzmore();
}

static unsigned char shift2[257] = {
- 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 1, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
};


static void act72()
-{
+{
NLA = Eof;
}


static void act73()
-{
+{
NLA = 12;
- zzmode(ACTIONS); zzmore();
+ zzmode(ACTIONS); zzmore();
}


static void act74()
-{
+{
NLA = 13;
-
+
zzline++;
warn("eoln found in char literal (in user action)");
zzskip();
@@ -749,393 +749,393 @@ static void act74()


static void act75()
-{
+{
NLA = 14;
- zzmore();
+ zzmore();
}


static void act76()
-{
+{
NLA = 15;
- zzmore();
+ zzmore();
}

static unsigned char shift3[257] = {
- 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 1, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 2, 5, 5, 3, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 1, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 4, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
};


static void act77()
-{
+{
NLA = Eof;
}


static void act78()
-{
+{
NLA = 16;
- zzmode(ACTIONS); zzmore();
+ zzmode(ACTIONS); zzmore();
}


static void act79()
-{
+{
NLA = 17;
- zzmore();
+ zzmore();
}


static void act80()
-{
+{
NLA = 18;
- zzline++; zzmore(); DAWDLE;
+ zzline++; zzmore(); DAWDLE;
}


static void act81()
-{
+{
NLA = 19;
- zzmore();
+ zzmore();
}

static unsigned char shift4[257] = {
- 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
};


static void act82()
-{
+{
NLA = Eof;
}


static void act83()
-{
+{
NLA = 20;
zzmode(PARSE_ENUM_FILE);
- zzmore();
+ zzmore();
}


static void act84()
-{
+{
NLA = 21;
- zzmore();
+ zzmore();
}


static void act85()
-{
+{
NLA = 22;
- zzline++; zzmore(); DAWDLE;
+ zzline++; zzmore(); DAWDLE;
}


static void act86()
-{
+{
NLA = 23;
- zzmore();
+ zzmore();
}

static unsigned char shift5[257] = {
- 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
};


static void act87()
-{
+{
NLA = Eof;
}


static void act88()
-{
+{
NLA = 24;
- zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE;
+ zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE;
}


static void act89()
-{
+{
NLA = 25;
- zzskip();
+ zzskip();
}

static unsigned char shift6[257] = {
- 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3
};


static void act90()
-{
+{
NLA = Eof;
}


static void act91()
-{
+{
NLA = 26;
- zzline++; zzmode(ACTIONS); zzmore(); DAWDLE;
+ zzline++; zzmode(ACTIONS); zzmore(); DAWDLE;
}


static void act92()
-{
+{
NLA = 27;
- zzmore();
+ zzmore();
}

static unsigned char shift7[257] = {
- 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3
};


static void act93()
-{
+{
NLA = Eof;
}


static void act94()
-{
+{
NLA = 28;
- zzline++; zzmode(START); zzskip(); DAWDLE;
+ zzline++; zzmode(START); zzskip(); DAWDLE;
}


static void act95()
-{
+{
NLA = 29;
- zzskip();
+ zzskip();
}

static unsigned char shift8[257] = {
- 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 1, 3, 3, 2, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3
};


static void act96()
-{
+{
NLA = Eof;
}


static void act97()
-{
+{
NLA = 30;
- zzmode(START); zzskip();
+ zzmode(START); zzskip();
}


static void act98()
-{
+{
NLA = 31;
- zzskip();
+ zzskip();
}


static void act99()
-{
+{
NLA = 32;
- zzline++; zzskip(); DAWDLE;
+ zzline++; zzskip(); DAWDLE;
}


static void act100()
-{
+{
NLA = 33;
- zzskip();
+ zzskip();
}

static unsigned char shift9[257] = {
- 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 0, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 3, 5, 5, 4, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 1, 5, 5, 5, 5, 2, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5
};


static void act101()
-{
+{
NLA = Eof;
}


static void act102()
-{
+{
NLA = Action;
/* these do not nest */
zzmode(START);
@@ -1146,17 +1146,17 @@ static void act102()
if ( zzbufovf ) {
err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE));
}
-
+
/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */
/* MR1 in DLG action */
/* MR1 Doesn't matter what kind of action it is - reset*/
-
+
tokenActionActive=0; /* MR1 */
}


static void act103()
-{
+{
NLA = Pred;
/* these do not nest */
zzmode(START);
@@ -1183,7 +1183,7 @@ static void act103()


static void act104()
-{
+{
NLA = PassAction;
if ( topint() == ']' ) {
popint();
@@ -1212,9 +1212,9 @@ static void act104()


static void act105()
-{
+{
NLA = 37;
-
+
zzmore();
zzreplstr(inline_set(zzbegexpr+
strlen("consumeUntil(")));
@@ -1222,53 +1222,53 @@ static void act105()


static void act106()
-{
+{
NLA = 38;
- zzmore();
+ zzmore();
}


static void act107()
-{
+{
NLA = 39;
- zzline++; zzmore(); DAWDLE;
+ zzline++; zzmore(); DAWDLE;
}


static void act108()
-{
+{
NLA = 40;
- zzmore();
+ zzmore();
}


static void act109()
-{
+{
NLA = 41;
- zzmore();
+ zzmore();
}


static void act110()
-{
+{
NLA = 42;
if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();}
- else err("$$ use invalid in C++ mode");
+ else err("$$ use invalid in C++ mode");
}


static void act111()
-{
+{
NLA = 43;
if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();}
- else err("$[] use invalid in C++ mode");
+ else err("$[] use invalid in C++ mode");
}


static void act112()
-{
+{
NLA = 44;
-
+
pushint(']');
if ( !GenCC ) zzreplstr("zzconstr_attr(");
else err("$[..] use invalid in C++ mode");
@@ -1277,7 +1277,7 @@ static void act112()


static void act113()
-{
+{
NLA = 45;
{
static char buf[100];
@@ -1299,7 +1299,7 @@ static void act113()


static void act114()
-{
+{
NLA = 46;
{
static char buf[100];
@@ -1322,7 +1322,7 @@ static void act114()


static void act115()
-{
+{
NLA = 47;
{
static char buf[100];
@@ -1356,7 +1356,7 @@ static void act115()


static void act116()
-{
+{
NLA = 48;
{ static char buf[300]; LabelEntry *el;
zzbegexpr[0] = ' ';
@@ -1408,14 +1408,14 @@ zzmore();


static void act117()
-{
+{
NLA = 49;
- zzreplstr("(*_root)"); zzmore(); chkGTFlag();
+ zzreplstr("(*_root)"); zzmore(); chkGTFlag();
}


static void act118()
-{
+{
NLA = 50;
if ( GenCC ) {
if (NewAST) zzreplstr("(newAST)");
@@ -1426,14 +1426,14 @@ static void act118()


static void act119()
-{
+{
NLA = 51;
- zzreplstr("NULL"); zzmore(); chkGTFlag();
+ zzreplstr("NULL"); zzmore(); chkGTFlag();
}


static void act120()
-{
+{
NLA = 52;
{
static char buf[100];
@@ -1450,26 +1450,26 @@ static void act120()


static void act121()
-{
+{
NLA = 53;
-
+
zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore();
getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr);
}


static void act122()
-{
+{
NLA = 54;
-
+
zzline++; zzmore();
}


static void act123()
-{
+{
NLA = 55;
-
+
if ( !(strcmp(zzbegexpr, "#ifdef")==0 ||
strcmp(zzbegexpr, "#if")==0 ||
strcmp(zzbegexpr, "#else")==0 ||
@@ -1494,9 +1494,9 @@ static void act123()


static void act124()
-{
+{
NLA = 56;
-
+
pushint(']');
if ( GenCC ) {
if (NewAST) zzreplstr("(newAST(");
@@ -1508,9 +1508,9 @@ static void act124()


static void act125()
-{
+{
NLA = 57;
-
+
pushint('}');
if ( GenCC ) {
if (tmakeInParser) {
@@ -1529,16 +1529,16 @@ static void act125()


static void act126()
-{
+{
NLA = 58;
- zzmore();
+ zzmore();
}


static void act127()
-{
+{
NLA = 59;
-
+
if ( istackempty() )
zzmore();
else if ( topint()==')' ) {
@@ -1554,39 +1554,39 @@ static void act127()


static void act128()
-{
+{
NLA = 60;
-
+
pushint('|'); /* look for '|' to terminate simple [...] */
zzmore();
}


static void act129()
-{
+{
NLA = 61;
-
+
pushint(')');
zzmore();
}


static void act130()
-{
+{
NLA = 62;
- zzreplstr("]"); zzmore();
+ zzreplstr("]"); zzmore();
}


static void act131()
-{
+{
NLA = 63;
- zzreplstr(")"); zzmore();
+ zzreplstr(")"); zzmore();
}


static void act132()
-{
+{
NLA = 64;
if (! tokenActionActive) zzreplstr(">"); /* MR1 */
zzmore(); /* MR1 */
@@ -1594,274 +1594,274 @@ static void act132()


static void act133()
-{
+{
NLA = 65;
- zzmode(ACTION_CHARS); zzmore();
+ zzmode(ACTION_CHARS); zzmore();
}


static void act134()
-{
+{
NLA = 66;
- zzmode(ACTION_STRINGS); zzmore();
+ zzmode(ACTION_STRINGS); zzmore();
}


static void act135()
-{
+{
NLA = 67;
- zzreplstr("$"); zzmore();
+ zzreplstr("$"); zzmore();
}


static void act136()
-{
+{
NLA = 68;
- zzreplstr("#"); zzmore();
+ zzreplstr("#"); zzmore();
}


static void act137()
-{
+{
NLA = 69;
- zzline++; zzmore();
+ zzline++; zzmore();
}


static void act138()
-{
+{
NLA = 70;
- zzmore();
+ zzmore();
}


static void act139()
-{
+{
NLA = 71;
- zzmore();
+ zzmore();
}


static void act140()
-{
+{
NLA = 72;
- zzmode(ACTION_COMMENTS); zzmore();
+ zzmode(ACTION_COMMENTS); zzmore();
}


static void act141()
-{
+{
NLA = 73;
- warn("Missing /*; found dangling */ in action"); zzmore();
+ warn("Missing /*; found dangling */ in action"); zzmore();
}


static void act142()
-{
+{
NLA = 74;
- zzmode(ACTION_CPP_COMMENTS); zzmore();
+ zzmode(ACTION_CPP_COMMENTS); zzmore();
}


static void act143()
-{
+{
NLA = 75;
- zzmore();
+ zzmore();
}

static unsigned char shift10[257] = {
- 0, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 16, 19, 33, 33, 20, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 16, 33, 28, 27, 21, 33, 33,
- 30, 15, 18, 32, 33, 33, 33, 25, 31, 23,
- 24, 24, 24, 24, 24, 24, 24, 24, 24, 33,
- 33, 33, 33, 1, 2, 33, 26, 26, 26, 26,
- 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
- 26, 26, 26, 26, 26, 26, 11, 26, 26, 26,
- 26, 26, 22, 29, 3, 33, 26, 33, 26, 26,
- 4, 26, 10, 26, 26, 26, 13, 26, 26, 14,
- 9, 6, 5, 26, 26, 26, 7, 12, 8, 26,
- 26, 26, 26, 26, 17, 33, 34, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 0, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 16, 19, 33, 33, 20, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 16, 33, 28, 27, 21, 33, 33,
+ 30, 15, 18, 32, 33, 33, 33, 25, 31, 23,
+ 24, 24, 24, 24, 24, 24, 24, 24, 24, 33,
+ 33, 33, 33, 1, 2, 33, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 11, 26, 26, 26,
+ 26, 26, 22, 29, 3, 33, 26, 33, 26, 26,
+ 4, 26, 10, 26, 26, 26, 13, 26, 26, 14,
+ 9, 6, 5, 26, 26, 26, 7, 12, 8, 26,
+ 26, 26, 26, 26, 17, 33, 34, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33
};


static void act144()
-{
+{
NLA = Eof;
- ;
+ ;
}


static void act145()
-{
+{
NLA = 137;
- zzskip();
+ zzskip();
}


static void act146()
-{
+{
NLA = 138;
- zzline++; zzskip();
+ zzline++; zzskip();
}


static void act147()
-{
+{
NLA = 139;
- zzmode(TOK_DEF_CPP_COMMENTS); zzmore();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzmore();
}


static void act148()
-{
+{
NLA = 140;
- zzmode(TOK_DEF_COMMENTS); zzskip();
+ zzmode(TOK_DEF_COMMENTS); zzskip();
}


static void act149()
-{
+{
NLA = 141;
- zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
}


static void act150()
-{
+{
NLA = 142;
- zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
}


static void act151()
-{
+{
NLA = 143;
- ;
+ ;
}


static void act152()
-{
+{
NLA = 144;
- zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
}


static void act153()
-{
+{
NLA = 145;
- zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
}


static void act154()
-{
+{
NLA = 146;
- zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
}


static void act155()
-{
+{
NLA = 147;
- zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
+ zzmode(TOK_DEF_CPP_COMMENTS); zzskip();
}


static void act156()
-{
+{
NLA = 149;
}


static void act157()
-{
+{
NLA = 151;
}


static void act158()
-{
+{
NLA = 152;
}


static void act159()
-{
+{
NLA = 153;
}


static void act160()
-{
+{
NLA = 154;
}


static void act161()
-{
+{
NLA = 155;
}


static void act162()
-{
+{
NLA = 156;
}


static void act163()
-{
+{
NLA = INT;
}


static void act164()
-{
+{
NLA = ID;
}

static unsigned char shift11[257] = {
- 0, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 1, 2, 27, 27, 3, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 1, 27, 27, 6, 27, 27, 27,
- 27, 27, 27, 5, 27, 22, 27, 27, 4, 25,
- 25, 25, 25, 25, 25, 25, 25, 25, 25, 27,
- 24, 27, 21, 27, 27, 27, 26, 26, 26, 26,
- 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
- 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
- 26, 26, 27, 27, 27, 27, 26, 27, 26, 26,
- 26, 9, 10, 8, 26, 26, 7, 26, 26, 12,
- 15, 11, 17, 16, 26, 18, 13, 19, 14, 26,
- 26, 26, 26, 26, 20, 27, 23, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 0, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 1, 2, 27, 27, 3, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 1, 27, 27, 6, 27, 27, 27,
+ 27, 27, 27, 5, 27, 22, 27, 27, 4, 25,
+ 25, 25, 25, 25, 25, 25, 25, 25, 25, 27,
+ 24, 27, 21, 27, 27, 27, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 27, 27, 27, 27, 26, 27, 26, 26,
+ 26, 9, 10, 8, 26, 26, 7, 26, 26, 12,
+ 15, 11, 17, 16, 26, 18, 13, 19, 14, 26,
+ 26, 26, 26, 26, 20, 27, 23, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27
};

@@ -1869,1811 +1869,1811 @@ static unsigned char shift11[257] = {
typedef unsigned short DfaState;

static DfaState st0[60] = {
- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
- 11, 11, 11, 12, 13, 13, 13, 14, 15, 16,
- 17, 11, 11, 18, 11, 11, 19, 11, 11, 19,
- 11, 11, 11, 11, 20, 11, 11, 21, 22, 23,
- 24, 25, 26, 11, 27, 28, 29, 30, 31, 32,
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 11, 11, 12, 13, 13, 13, 14, 15, 16,
+ 17, 11, 11, 18, 11, 11, 19, 11, 11, 19,
+ 11, 11, 11, 11, 20, 11, 11, 21, 22, 23,
+ 24, 25, 26, 11, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 11, 11, 19, 436, 436, 436
};

static DfaState st1[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st2[60] = {
- 436, 2, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 2, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st3[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st4[60] = {
- 436, 436, 37, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 37, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st5[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st6[60] = {
- 436, 436, 436, 436, 436, 38, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 38, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st7[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st8[60] = {
- 436, 436, 436, 436, 436, 436, 436, 39, 40, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 39, 40, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st9[60] = {
- 436, 436, 436, 436, 436, 436, 436, 41, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 41, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st10[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 42, 43, 43, 44, 43, 43, 43, 436, 436, 436,
- 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
- 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 42, 43, 43, 44, 43, 43, 43, 436, 436, 436,
+ 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
+ 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st11[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st12[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 51, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 51, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st13[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 13, 13, 13, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 13, 13, 13, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st14[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 52, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 52, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st15[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 53, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 53, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st16[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st17[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 54,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 54,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st18[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 55, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 55, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st19[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
- 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
- 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
- 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
436, 56, 436, 436, 56, 56, 56, 56, 436, 436
};

static DfaState st20[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 57, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 57, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st21[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st22[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 58, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 59, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 58, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 59, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st23[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st24[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st25[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st26[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st27[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 60, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 60, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st28[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 61, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 61, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st29[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st30[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st31[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 62, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 62, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st32[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st33[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st34[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
- 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
- 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
- 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
436, 63, 436, 436, 56, 56, 56, 56, 436, 436
};

static DfaState st35[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st36[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st37[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st38[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st39[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st40[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st41[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st42[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 64, 43, 65, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 64, 43, 65, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st43[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st44[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 66, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 66, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st45[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 67, 68, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 67, 68, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st46[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 69, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 69, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st47[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 70, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 70, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st48[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 71, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 71, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st49[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 72, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 72, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st50[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st51[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 73, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 73, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st52[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st53[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st54[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 74, 43, 43, 44, 43, 43, 43, 436, 436, 436,
- 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
- 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 74, 43, 43, 44, 43, 43, 43, 436, 436, 436,
+ 436, 45, 43, 43, 43, 43, 46, 43, 47, 43,
+ 43, 43, 43, 48, 43, 49, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st55[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 75, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 75, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st56[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
- 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
- 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
- 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 436, 436, 436, 436,
436, 56, 436, 436, 56, 56, 56, 56, 436, 436
};

static DfaState st57[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 76, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 76, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st58[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 77, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 77, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st59[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 78, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 78, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st60[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st61[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st62[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st63[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
- 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
- 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
- 436, 436, 436, 56, 436, 436, 79, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 56, 56, 56, 56, 56, 56, 56, 436, 436, 436,
+ 436, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 436, 56, 436,
+ 436, 436, 436, 56, 436, 436, 79, 436, 436, 436,
436, 56, 436, 436, 56, 56, 56, 56, 436, 436
};

static DfaState st64[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 80, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 80, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st65[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 81, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 81, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st66[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 82, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 82, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st67[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 83, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 84, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 83, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 84, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st68[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 85, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 85, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st69[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 86, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 86, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st70[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 87, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 87, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st71[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 88, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 88, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st72[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 89, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 89, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st73[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 90, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 90, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st74[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 65, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 65, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st75[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 91, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 91, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st76[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 92, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 92, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st77[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 93, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 93, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st78[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 94, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 94, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st79[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 95, 96, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 95, 96, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st80[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 97, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 97, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st81[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 98, 43, 99, 43, 100, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 101, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 98, 43, 99, 43, 100, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 101, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st82[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 102, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 102, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st83[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 103, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 103, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st84[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 104, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 104, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st85[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 105, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 105, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st86[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 106, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 106, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st87[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 107, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 108, 43, 43, 436, 109, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 107, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 108, 43, 43, 436, 109, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st88[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 110, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 110, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st89[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 111, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 111, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st90[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 112, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 112, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st91[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 113, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 113, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st92[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 114, 50, 50, 50, 436, 436
};

static DfaState st93[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 115, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 115, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st94[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 116, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 116, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st95[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 117, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 117, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st96[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 118, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 118, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st97[60] = {
- 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
- 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
- 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
- 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
- 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
+ 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
+ 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
+ 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
+ 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
+ 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
122, 123, 122, 122, 123, 123, 123, 123, 122, 436
};

static DfaState st98[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 125, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 125, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st99[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 126, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 126, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st100[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 127, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 127, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st101[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 128, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 128, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st102[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 129, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 129, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st103[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st104[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 130, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 130, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st105[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 131, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 131, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st106[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 132, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 132, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st107[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 133, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 133, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st108[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 134, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 134, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st109[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 135, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 135, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st110[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 136, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 136, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st111[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 137, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 137, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st112[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 138, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 138, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st113[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 139, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 139, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st114[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 140, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 140, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st115[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st116[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st117[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st118[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st119[60] = {
- 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 119, 120, 121, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st120[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st121[60] = {
- 436, 436, 142, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 142, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st122[60] = {
- 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st123[60] = {
- 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
- 123, 123, 123, 123, 123, 123, 123, 122, 122, 122,
- 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
- 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
- 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
+ 436, 122, 120, 121, 122, 122, 122, 122, 122, 122,
+ 123, 123, 123, 123, 123, 123, 123, 122, 122, 122,
+ 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
+ 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
+ 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
122, 123, 122, 122, 123, 123, 123, 123, 122, 436
};

static DfaState st124[60] = {
- 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
- 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
- 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
- 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
- 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
+ 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
+ 123, 123, 123, 123, 124, 124, 124, 122, 122, 122,
+ 122, 123, 123, 123, 123, 123, 123, 123, 123, 123,
+ 123, 123, 123, 123, 123, 123, 123, 122, 123, 122,
+ 122, 122, 122, 123, 122, 122, 122, 122, 122, 122,
122, 123, 122, 122, 123, 123, 123, 123, 122, 436
};

static DfaState st125[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 147, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 147, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st126[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 148, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 148, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st127[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 149, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 149, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st128[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 150, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 150, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st129[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 151, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 151, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st130[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 152, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 152, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st131[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 153, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 153, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st132[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 154,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 154,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st133[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st134[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 155, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 155, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st135[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 156, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 156, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st136[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 157, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 157, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st137[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st138[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 158, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 158, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st139[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st140[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 159, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 159, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st141[60] = {
- 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
- 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 143, 144, 145, 122, 122, 146, 122, 122, 122,
+ 122, 122, 122, 122, 141, 141, 141, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st142[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st143[60] = {
- 436, 143, 120, 121, 122, 122, 146, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 143, 120, 121, 122, 122, 146, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st144[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st145[60] = {
- 436, 436, 160, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 160, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st146[60] = {
- 436, 161, 162, 163, 161, 161, 122, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 436, 161, 162, 163, 161, 161, 122, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
161, 161, 161, 161, 161, 161, 161, 161, 161, 436
};

static DfaState st147[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 164, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 164, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st148[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 165, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 165, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st149[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 166, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 166, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st150[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 167, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 167, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st151[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 168, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 168, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st152[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st153[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st154[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 169, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 169, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st155[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 170, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 170, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st156[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 171, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 171, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st157[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st158[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 172, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 172, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st159[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st160[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st161[60] = {
- 436, 161, 162, 163, 161, 161, 173, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
- 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 436, 161, 162, 163, 161, 161, 173, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
+ 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
161, 161, 161, 161, 161, 161, 161, 161, 161, 436
};

static DfaState st162[60] = {
- 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
174, 174, 174, 174, 174, 174, 174, 174, 174, 436
};

static DfaState st163[60] = {
- 436, 174, 176, 174, 174, 174, 175, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 436, 174, 176, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
174, 174, 174, 174, 174, 174, 174, 174, 174, 436
};

static DfaState st164[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 177, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 177, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st165[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 178, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 178, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st166[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 179, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 179, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st167[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 180, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 180, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st168[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 181, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 181, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st169[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 182, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 182, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st170[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st171[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 183, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 183, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st172[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 184, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 184, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st173[60] = {
- 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st174[60] = {
- 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
174, 174, 174, 174, 174, 174, 174, 174, 174, 436
};

static DfaState st175[60] = {
- 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st176[60] = {
- 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 436, 174, 174, 174, 174, 174, 175, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
+ 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
174, 174, 174, 174, 174, 174, 174, 174, 174, 436
};

static DfaState st177[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 191, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 191, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st178[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 192, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 192, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st179[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 193, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 193, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st180[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st181[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st182[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 194,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 194,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st183[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st184[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
- 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
- 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
- 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 50, 50, 50, 50, 50, 50, 50, 436, 436, 436,
+ 436, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+ 50, 50, 50, 50, 50, 50, 50, 436, 50, 436,
+ 436, 436, 436, 50, 436, 436, 436, 436, 436, 436,
436, 50, 436, 436, 50, 50, 50, 50, 436, 436
};

static DfaState st185[60] = {
- 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st186[60] = {
- 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
- 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 436, 185, 144, 145, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 186, 186, 186, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
+ 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
122, 122, 122, 122, 122, 122, 122, 122, 122, 436
};

static DfaState st187[60] = {
- 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st188[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st189[60] = {
- 436, 436, 195, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 195, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st190[60] = {
- 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 187, 188, 189, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 190, 190, 190, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st191[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st192[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st193[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st194[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 196, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 196, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st195[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st196[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 197, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 197, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st197[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 198, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 198, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st198[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 199, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 199, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st199[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 200, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 200, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

static DfaState st200[60] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
- 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
- 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
- 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 43, 43, 43, 43, 43, 43, 43, 436, 436, 436,
+ 436, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+ 43, 43, 43, 43, 43, 43, 43, 436, 43, 436,
+ 436, 436, 436, 43, 436, 436, 436, 436, 436, 436,
436, 43, 436, 436, 43, 43, 43, 43, 436, 436
};

@@ -3978,1067 +3978,1067 @@ static DfaState st275[7] = {
};

static DfaState st276[36] = {
- 277, 278, 279, 280, 281, 279, 279, 279, 279, 279,
- 279, 279, 279, 279, 279, 282, 279, 279, 283, 284,
- 285, 286, 287, 279, 279, 279, 279, 288, 289, 290,
+ 277, 278, 279, 280, 281, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 282, 279, 279, 283, 284,
+ 285, 286, 287, 279, 279, 279, 279, 288, 289, 290,
291, 292, 293, 279, 279, 436
};

static DfaState st277[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st278[36] = {
- 436, 294, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 294, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st279[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st280[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st281[36] = {
- 436, 436, 279, 436, 279, 295, 279, 279, 279, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 295, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st282[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st283[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st284[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st285[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 296,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 296,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st286[36] = {
- 436, 436, 436, 436, 297, 297, 297, 297, 297, 297,
- 297, 297, 297, 297, 297, 436, 436, 436, 436, 436,
- 436, 298, 299, 300, 300, 436, 297, 436, 436, 436,
+ 436, 436, 436, 436, 297, 297, 297, 297, 297, 297,
+ 297, 297, 297, 297, 297, 436, 436, 436, 436, 436,
+ 436, 298, 299, 300, 300, 436, 297, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st287[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st288[36] = {
- 436, 436, 436, 436, 301, 301, 301, 301, 301, 301,
- 301, 301, 301, 301, 302, 303, 436, 436, 436, 436,
- 436, 436, 304, 305, 306, 436, 301, 436, 436, 436,
+ 436, 436, 436, 436, 301, 301, 301, 301, 301, 301,
+ 301, 301, 301, 301, 302, 303, 436, 436, 436, 436,
+ 436, 436, 304, 305, 306, 436, 301, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st289[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st290[36] = {
- 436, 307, 308, 309, 308, 308, 308, 308, 308, 308,
- 308, 308, 308, 308, 308, 308, 308, 308, 310, 311,
- 312, 313, 308, 308, 308, 308, 308, 314, 308, 308,
+ 436, 307, 308, 309, 308, 308, 308, 308, 308, 308,
+ 308, 308, 308, 308, 308, 308, 308, 308, 310, 311,
+ 312, 313, 308, 308, 308, 308, 308, 314, 308, 308,
308, 308, 308, 308, 308, 436
};

static DfaState st291[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st292[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 315, 316, 436, 436, 436
};

static DfaState st293[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 317, 279, 279, 279, 436
};

static DfaState st294[36] = {
- 436, 436, 318, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 318, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st295[36] = {
- 436, 436, 279, 436, 279, 279, 319, 279, 279, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 319, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st296[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st297[36] = {
- 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
- 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
- 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
+ 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
+ 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
+ 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st298[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st299[36] = {
- 436, 436, 436, 321, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 321, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st300[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 300, 300, 322, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 300, 300, 322, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st301[36] = {
- 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
- 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
- 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st302[36] = {
- 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
- 323, 323, 323, 324, 323, 436, 436, 436, 436, 436,
- 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 323, 323, 323, 324, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st303[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 325, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 325, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st304[36] = {
- 436, 436, 436, 326, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 326, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st305[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st306[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 306, 306, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st307[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st308[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st309[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st310[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st311[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st312[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 327,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 327,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st313[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st314[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st315[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st316[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st317[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st318[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st319[36] = {
- 436, 436, 279, 436, 279, 279, 279, 328, 279, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 328, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st320[36] = {
- 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
- 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
- 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
+ 436, 436, 436, 436, 320, 320, 320, 320, 320, 320,
+ 320, 320, 320, 320, 320, 436, 436, 436, 436, 436,
+ 436, 436, 436, 320, 320, 436, 320, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st321[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st322[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st323[36] = {
- 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
- 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
- 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st324[36] = {
- 436, 436, 436, 436, 323, 323, 330, 323, 323, 323,
- 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
- 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 323, 323, 330, 323, 323, 323,
+ 323, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st325[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st326[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st327[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st328[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 331, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 331, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st329[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 329, 329, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st330[36] = {
- 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
- 332, 323, 323, 323, 323, 436, 436, 436, 436, 436,
- 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
+ 436, 436, 436, 436, 323, 323, 323, 323, 323, 323,
+ 332, 323, 323, 323, 323, 436, 436, 436, 436, 436,
+ 436, 436, 436, 323, 323, 436, 323, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st331[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 333,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 333,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st332[36] = {
- 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
- 335, 335, 335, 335, 335, 334, 336, 334, 334, 337,
- 338, 334, 334, 339, 339, 334, 335, 334, 334, 334,
+ 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
+ 335, 335, 335, 335, 335, 334, 336, 334, 334, 337,
+ 338, 334, 334, 339, 339, 334, 335, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st333[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 340, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 340, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st334[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 334, 334, 334, 337,
- 338, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 334, 334, 334, 337,
+ 338, 334, 334, 334, 334, 334, 334, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st335[36] = {
- 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
- 335, 335, 335, 335, 335, 334, 334, 334, 334, 337,
- 338, 334, 334, 335, 335, 334, 335, 334, 334, 334,
+ 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
+ 335, 335, 335, 335, 335, 334, 334, 334, 334, 337,
+ 338, 334, 334, 335, 335, 334, 335, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st336[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 336, 334, 334, 337,
- 338, 334, 334, 341, 341, 334, 334, 334, 334, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 336, 334, 334, 337,
+ 338, 334, 334, 341, 341, 334, 334, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st337[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st338[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 342,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 342,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st339[36] = {
- 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
- 335, 335, 335, 335, 335, 334, 343, 334, 334, 344,
- 345, 334, 334, 339, 339, 334, 335, 334, 346, 334,
+ 436, 334, 334, 334, 335, 335, 335, 335, 335, 335,
+ 335, 335, 335, 335, 335, 334, 343, 334, 334, 344,
+ 345, 334, 334, 339, 339, 334, 335, 334, 346, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st340[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 347, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 347, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st341[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 343, 334, 334, 344,
- 345, 334, 334, 341, 341, 334, 334, 334, 346, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 343, 334, 334, 344,
+ 345, 334, 334, 341, 341, 334, 334, 334, 346, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st342[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st343[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 343, 334, 334, 337,
- 338, 334, 334, 334, 334, 334, 334, 334, 346, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 343, 334, 334, 337,
+ 338, 334, 334, 334, 334, 334, 334, 334, 346, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st344[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st345[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 348,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 348,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st346[36] = {
- 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
- 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
- 351, 349, 349, 349, 349, 349, 349, 349, 334, 349,
+ 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
+ 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
+ 351, 349, 349, 349, 349, 349, 349, 349, 334, 349,
349, 349, 349, 349, 349, 436
};

static DfaState st347[36] = {
- 436, 436, 279, 436, 279, 279, 352, 279, 279, 279,
- 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 352, 279, 279, 279,
+ 279, 279, 279, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st348[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st349[36] = {
- 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
- 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
- 351, 349, 349, 349, 349, 349, 349, 349, 353, 349,
+ 436, 349, 349, 349, 349, 349, 349, 349, 349, 349,
+ 349, 349, 349, 349, 349, 349, 349, 349, 349, 350,
+ 351, 349, 349, 349, 349, 349, 349, 349, 353, 349,
349, 349, 349, 349, 349, 436
};

static DfaState st350[36] = {
- 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
354, 354, 354, 354, 354, 436
};

static DfaState st351[36] = {
- 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 356,
- 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 356,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
354, 354, 354, 354, 354, 436
};

static DfaState st352[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 279, 357, 279, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 357, 279, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st353[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
- 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
+ 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st354[36] = {
- 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
354, 354, 354, 354, 354, 436
};

static DfaState st355[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
- 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
+ 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st356[36] = {
- 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
- 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
+ 436, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 354, 354,
+ 354, 354, 354, 354, 354, 354, 354, 354, 355, 354,
354, 354, 354, 354, 354, 436
};

static DfaState st357[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 279, 279, 364, 279, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 364, 279, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st358[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
- 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
+ 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st359[36] = {
- 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
- 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
- 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
+ 436, 334, 334, 334, 334, 334, 334, 334, 334, 334,
+ 334, 334, 334, 334, 334, 334, 358, 334, 334, 344,
+ 345, 334, 334, 359, 359, 334, 334, 334, 334, 334,
334, 334, 334, 334, 334, 436
};

static DfaState st360[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
- 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
+ 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st361[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st362[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 365,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 365,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st363[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
- 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 360, 436, 436, 361,
+ 362, 436, 436, 363, 363, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st364[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 279, 279, 279, 366, 436, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 366, 436, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st365[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st366[36] = {
- 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
- 279, 279, 279, 279, 279, 367, 279, 279, 436, 436,
- 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
+ 436, 436, 279, 436, 279, 279, 279, 279, 279, 279,
+ 279, 279, 279, 279, 279, 367, 279, 279, 436, 436,
+ 436, 436, 436, 279, 279, 279, 279, 436, 436, 436,
436, 436, 279, 279, 279, 436
};

static DfaState st367[36] = {
- 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
- 368, 368, 368, 368, 368, 368, 369, 370, 436, 368,
- 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 369, 370, 436, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
368, 368, 368, 368, 368, 436
};

static DfaState st368[36] = {
- 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
- 368, 368, 368, 368, 368, 368, 368, 368, 371, 368,
- 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 371, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
368, 368, 368, 368, 368, 436
};

static DfaState st369[36] = {
- 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
- 368, 368, 368, 368, 368, 368, 369, 370, 371, 368,
- 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 369, 370, 371, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
368, 368, 368, 368, 368, 436
};

static DfaState st370[36] = {
- 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
- 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
- 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
372, 372, 372, 372, 368, 436
};

static DfaState st371[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st372[36] = {
- 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
- 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
- 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 436, 372, 372, 372, 372, 372, 372, 372, 372, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 373, 372,
+ 372, 372, 372, 372, 372, 372, 372, 372, 372, 372,
372, 372, 372, 372, 374, 436
};

static DfaState st373[36] = {
- 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
- 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
- 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
375, 375, 375, 375, 376, 436
};

static DfaState st374[36] = {
- 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
- 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
- 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
368, 368, 368, 368, 368, 436
};

static DfaState st375[36] = {
- 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
- 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
- 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 436, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
+ 375, 375, 375, 375, 375, 375, 375, 375, 375, 375,
375, 375, 375, 375, 376, 436
};

static DfaState st376[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st377[36] = {
- 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
- 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
- 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 436, 368, 368, 368, 368, 368, 368, 368, 368, 368,
+ 368, 368, 368, 368, 368, 368, 377, 368, 378, 368,
+ 368, 368, 368, 368, 368, 368, 368, 368, 368, 368,
368, 368, 368, 368, 368, 436
};

static DfaState st378[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st379[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 379, 436, 380, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st380[36] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436
};

static DfaState st381[28] = {
- 382, 383, 384, 385, 386, 436, 387, 388, 388, 388,
- 389, 388, 388, 388, 388, 388, 388, 388, 388, 388,
+ 382, 383, 384, 385, 386, 436, 387, 388, 388, 388,
+ 389, 388, 388, 388, 388, 388, 388, 388, 388, 388,
390, 391, 392, 393, 394, 395, 388, 436
};

static DfaState st382[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st383[28] = {
- 436, 383, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 383, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st384[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st385[28] = {
- 436, 436, 396, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 396, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st386[28] = {
- 436, 436, 436, 436, 397, 398, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 397, 398, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st387[28] = {
- 436, 436, 436, 436, 436, 436, 436, 399, 436, 400,
- 401, 436, 436, 436, 402, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 399, 436, 400,
+ 401, 436, 436, 436, 402, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st388[28] = {
- 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
- 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
436, 436, 436, 436, 436, 403, 403, 436
};

static DfaState st389[28] = {
- 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
- 403, 404, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 404, 403, 403, 403, 403, 403, 403, 403, 403,
436, 436, 436, 436, 436, 403, 403, 436
};

static DfaState st390[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st391[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st392[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st393[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st394[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st395[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 395, 436, 436
};

static DfaState st396[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st397[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st398[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st399[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 405, 436,
- 436, 436, 436, 436, 436, 406, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 405, 436,
+ 436, 436, 436, 436, 436, 406, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st400[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 407, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 407, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st401[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 408, 409, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 408, 409, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st402[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 410, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 410, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st403[28] = {
- 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
- 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
436, 436, 436, 436, 436, 403, 403, 436
};

static DfaState st404[28] = {
- 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
- 403, 403, 403, 403, 411, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 411, 403, 403, 403, 403, 403,
436, 436, 436, 436, 436, 403, 403, 436
};

static DfaState st405[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 412,
- 436, 413, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 412,
+ 436, 413, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st406[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 414, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 414, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st407[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 415, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 415, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st408[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 416,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 416,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st409[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 417, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 417, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st410[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 418,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 418,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st411[28] = {
- 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
- 403, 403, 403, 403, 403, 419, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 419, 403, 403, 403, 403,
436, 436, 436, 436, 436, 403, 403, 436
};

static DfaState st412[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 420, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 420, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st413[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 421,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 421,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st414[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 422, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 422, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st415[28] = {
- 436, 436, 436, 436, 436, 436, 436, 423, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 423, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st416[28] = {
- 436, 436, 436, 436, 436, 436, 436, 424, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 424, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st417[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 425, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 425, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st418[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 426, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 426, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st419[28] = {
- 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
- 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
+ 436, 436, 436, 436, 436, 436, 436, 403, 403, 403,
+ 403, 403, 403, 403, 403, 403, 403, 403, 403, 403,
436, 436, 436, 436, 436, 403, 403, 436
};

static DfaState st420[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 427, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 427, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st421[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 428, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 428, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st422[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 429, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 429, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st423[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 430, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 430, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st424[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 431, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 431, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st425[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st426[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 432, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 432, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st427[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st428[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 433, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 433, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st429[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 434,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 434,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st430[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 435, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 435, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st431[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st432[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st433[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st434[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

static DfaState st435[28] = {
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
- 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
+ 436, 436, 436, 436, 436, 436, 436, 436, 436, 436,
436, 436, 436, 436, 436, 436, 436, 436
};

@@ -5484,49 +5484,49 @@ DfaState *dfa[436] = {


DfaState accepts[437] = {
- 0, 1, 2, 3, 3, 4, 25, 6, 0, 50,
- 59, 57, 57, 43, 26, 13, 14, 0, 57, 58,
- 57, 21, 57, 23, 24, 27, 28, 44, 0, 35,
- 36, 42, 45, 46, 58, 51, 52, 3, 5, 9,
- 7, 8, 59, 59, 59, 59, 59, 59, 59, 59,
- 57, 57, 12, 40, 59, 57, 58, 57, 57, 57,
- 33, 34, 53, 58, 59, 59, 59, 59, 59, 59,
- 59, 59, 59, 57, 59, 57, 57, 57, 57, 0,
- 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
- 57, 57, 57, 57, 57, 0, 0, 59, 59, 59,
- 59, 59, 59, 32, 59, 59, 59, 59, 59, 59,
- 59, 59, 57, 57, 57, 22, 56, 48, 49, 0,
- 11, 11, 0, 59, 59, 59, 59, 59, 59, 59,
- 59, 59, 59, 41, 59, 59, 59, 18, 57, 47,
- 57, 0, 11, 0, 10, 10, 0, 59, 59, 59,
- 59, 59, 15, 19, 59, 59, 59, 17, 57, 55,
- 10, 0, 11, 11, 59, 59, 59, 59, 59, 59,
- 20, 59, 57, 0, 0, 0, 11, 59, 59, 59,
- 37, 38, 59, 39, 54, 0, 0, 0, 10, 10,
- 0, 31, 29, 30, 59, 10, 59, 59, 59, 59,
- 16, 0, 60, 61, 62, 62, 0, 65, 62, 64,
- 63, 63, 63, 0, 66, 67, 68, 68, 0, 71,
- 68, 70, 69, 69, 69, 0, 72, 73, 74, 74,
- 0, 76, 74, 75, 0, 77, 79, 81, 80, 80,
- 78, 80, 0, 82, 84, 86, 85, 85, 83, 85,
- 0, 87, 88, 88, 89, 88, 0, 90, 91, 91,
- 92, 91, 0, 93, 94, 94, 95, 94, 0, 96,
- 98, 100, 99, 99, 97, 99, 0, 101, 108, 143,
- 104, 143, 129, 127, 107, 107, 109, 128, 126, 134,
- 0, 133, 139, 143, 102, 143, 107, 116, 110, 112,
- 113, 123, 123, 125, 124, 117, 120, 132, 138, 130,
- 131, 137, 137, 135, 136, 142, 140, 141, 103, 143,
- 116, 111, 114, 123, 123, 119, 118, 137, 143, 115,
- 123, 143, 123, 143, 0, 123, 0, 122, 122, 123,
- 143, 0, 122, 0, 121, 121, 0, 143, 121, 0,
- 122, 122, 143, 0, 0, 0, 122, 143, 0, 0,
- 0, 121, 121, 0, 143, 121, 143, 0, 0, 0,
- 0, 106, 0, 106, 0, 0, 0, 0, 105, 0,
- 105, 0, 144, 145, 146, 146, 0, 0, 164, 164,
- 158, 159, 160, 161, 162, 163, 146, 147, 148, 0,
- 0, 0, 0, 164, 164, 150, 0, 0, 0, 0,
- 0, 164, 0, 0, 0, 0, 0, 0, 0, 157,
- 0, 0, 0, 0, 0, 152, 0, 149, 0, 0,
+ 0, 1, 2, 3, 3, 4, 25, 6, 0, 50,
+ 59, 57, 57, 43, 26, 13, 14, 0, 57, 58,
+ 57, 21, 57, 23, 24, 27, 28, 44, 0, 35,
+ 36, 42, 45, 46, 58, 51, 52, 3, 5, 9,
+ 7, 8, 59, 59, 59, 59, 59, 59, 59, 59,
+ 57, 57, 12, 40, 59, 57, 58, 57, 57, 57,
+ 33, 34, 53, 58, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 57, 59, 57, 57, 57, 57, 0,
+ 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
+ 57, 57, 57, 57, 57, 0, 0, 59, 59, 59,
+ 59, 59, 59, 32, 59, 59, 59, 59, 59, 59,
+ 59, 59, 57, 57, 57, 22, 56, 48, 49, 0,
+ 11, 11, 0, 59, 59, 59, 59, 59, 59, 59,
+ 59, 59, 59, 41, 59, 59, 59, 18, 57, 47,
+ 57, 0, 11, 0, 10, 10, 0, 59, 59, 59,
+ 59, 59, 15, 19, 59, 59, 59, 17, 57, 55,
+ 10, 0, 11, 11, 59, 59, 59, 59, 59, 59,
+ 20, 59, 57, 0, 0, 0, 11, 59, 59, 59,
+ 37, 38, 59, 39, 54, 0, 0, 0, 10, 10,
+ 0, 31, 29, 30, 59, 10, 59, 59, 59, 59,
+ 16, 0, 60, 61, 62, 62, 0, 65, 62, 64,
+ 63, 63, 63, 0, 66, 67, 68, 68, 0, 71,
+ 68, 70, 69, 69, 69, 0, 72, 73, 74, 74,
+ 0, 76, 74, 75, 0, 77, 79, 81, 80, 80,
+ 78, 80, 0, 82, 84, 86, 85, 85, 83, 85,
+ 0, 87, 88, 88, 89, 88, 0, 90, 91, 91,
+ 92, 91, 0, 93, 94, 94, 95, 94, 0, 96,
+ 98, 100, 99, 99, 97, 99, 0, 101, 108, 143,
+ 104, 143, 129, 127, 107, 107, 109, 128, 126, 134,
+ 0, 133, 139, 143, 102, 143, 107, 116, 110, 112,
+ 113, 123, 123, 125, 124, 117, 120, 132, 138, 130,
+ 131, 137, 137, 135, 136, 142, 140, 141, 103, 143,
+ 116, 111, 114, 123, 123, 119, 118, 137, 143, 115,
+ 123, 143, 123, 143, 0, 123, 0, 122, 122, 123,
+ 143, 0, 122, 0, 121, 121, 0, 143, 121, 0,
+ 122, 122, 143, 0, 0, 0, 122, 143, 0, 0,
+ 0, 121, 121, 0, 143, 121, 143, 0, 0, 0,
+ 0, 106, 0, 106, 0, 0, 0, 0, 105, 0,
+ 105, 0, 144, 145, 146, 146, 0, 0, 164, 164,
+ 158, 159, 160, 161, 162, 163, 146, 147, 148, 0,
+ 0, 0, 0, 164, 164, 150, 0, 0, 0, 0,
+ 0, 164, 0, 0, 0, 0, 0, 0, 0, 157,
+ 0, 0, 0, 0, 0, 152, 0, 149, 0, 0,
0, 153, 154, 151, 155, 156, 0
};

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c
index 2d473ec8b663..e4ec2b77938b 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c
@@ -51,7 +51,7 @@ dfa_node *dfa_model_node;
hash_list *dfa_hash[HASH_SIZE]; /* used to quickly find */
/* desired dfa node */

-void
+void
#ifdef __USE_PROTOS
make_dfa_model_node(int width)
#else
@@ -143,7 +143,7 @@ nfa_node *start;
/* Make t a dfa state */
d_state = dfastate(t);
last_done = DFA_NO(d_state);
-
+
do {
/* Mark dfa state x as "done" */
d_state->done = TRUE;
@@ -177,7 +177,7 @@ nfa_node *start;
return dfa_array;
}

-void
+void
#ifdef __USE_PROTOS
clear_hash(void)
#else
@@ -250,7 +250,7 @@ set nfa_states;


/* this reach assumes the closure has been done already on set */
-int
+int
#ifdef __USE_PROTOS
reach(unsigned *nfa_list, register int a, unsigned *reach_list)
#else
@@ -282,7 +282,7 @@ unsigned *reach_list;

/* finds all the nodes that can be reached by epsilon transitions
from the set of a nodes and returns puts them back in set b */
-set
+set
#ifdef __USE_PROTOS
closure(set *b, unsigned *reach_list)
#else
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h
index 97d1718c70ef..022e2de1bae7 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h
@@ -28,7 +28,7 @@

/* MR1 Move pcctscfg.h to top of file */

-#include "pcctscfg.h"
+#include "pcctscfg.h"

/* turn off warnings for unreferenced labels */

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c
index 0b8982cf2a09..e4380c6c4e6c 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c
@@ -76,7 +76,7 @@ void xxputc(int c) { /* MR1 */
fputc(c,OUT); /* MR1 */
}; /* MR1 */
} /* MR1 */
-
+
#ifdef __USE_PROTOS
void xxprintf(char *format,char *string) { /* MR1 */
#else
@@ -94,46 +94,46 @@ void xxputc(int c) { /* MR1 */
} /* MR1 */

static void act1()
-{
+{
NLA = 1;
}


static void act2()
-{
+{
NLA = 2;
- zzskip();
+ zzskip();
}


static void act3()
-{
+{
NLA = 3;
- zzline++; zzskip(); DAWDLE;
+ zzline++; zzskip(); DAWDLE;
}


static void act4()
-{
+{
NLA = L_EOF;
}


static void act5()
-{
+{
NLA = PER_PER;
}


static void act6()
-{
+{
NLA = NAME_PER_PER;
- p_mode_def(&zzlextext[2],lex_mode_counter++);
+ p_mode_def(&zzlextext[2],lex_mode_counter++);
}


static void act7()
-{
+{
NLA = LEXMEMBER;
lexMember=1; /* MR1 */
if (firstLexMember != 0) { /* MR1 */
@@ -145,14 +145,14 @@ static void act7()


static void act8()
-{
+{
NLA = LEXACTION;
- lexAction=1;zzmode(ACT);
+ lexAction=1;zzmode(ACT);
}


static void act9()
-{
+{
NLA = PARSERCLASS;
parserClass=1; /* MR1 */
zzmode(ACT); /* MR1 */
@@ -160,14 +160,14 @@ static void act9()


static void act10()
-{
+{
NLA = LEXPREFIX;
- lexPrefix=1;zzmode(ACT);
+ lexPrefix=1;zzmode(ACT);
}


static void act11()
-{
+{
NLA = ACTION;
if (func_action)
fprintf(OUT,"\n%s %sact%d()\n{ ",
@@ -178,184 +178,184 @@ static void act11()


static void act12()
-{
+{
NLA = GREAT_GREAT;
}


static void act13()
-{
+{
NLA = L_BRACE;
}


static void act14()
-{
+{
NLA = R_BRACE;
}


static void act15()
-{
+{
NLA = L_PAR;
}


static void act16()
-{
+{
NLA = R_PAR;
}


static void act17()
-{
+{
NLA = L_BRACK;
}


static void act18()
-{
+{
NLA = R_BRACK;
}


static void act19()
-{
+{
NLA = ZERO_MORE;
}


static void act20()
-{
+{
NLA = ONE_MORE;
}


static void act21()
-{
+{
NLA = OR;
}


static void act22()
-{
+{
NLA = RANGE;
}


static void act23()
-{
+{
NLA = NOT;
}


static void act24()
-{
+{
NLA = OCTAL_VALUE;
- {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}
+ {int t; sscanf(&zzlextext[1],"%o",&t); zzlextext[0] = t;}
}


static void act25()
-{
+{
NLA = HEX_VALUE;
- {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}
+ {int t; sscanf(&zzlextext[3],"%x",&t); zzlextext[0] = t;}
}


static void act26()
-{
+{
NLA = DEC_VALUE;
- {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}
+ {int t; sscanf(&zzlextext[1],"%d",&t); zzlextext[0] = t;}
}


static void act27()
-{
+{
NLA = TAB;
- zzlextext[0] = '\t';
+ zzlextext[0] = '\t';
}


static void act28()
-{
+{
NLA = NL;
- zzlextext[0] = '\n';
+ zzlextext[0] = '\n';
}


static void act29()
-{
+{
NLA = CR;
- zzlextext[0] = '\r';
+ zzlextext[0] = '\r';
}


static void act30()
-{
+{
NLA = BS;
- zzlextext[0] = '\b';
+ zzlextext[0] = '\b';
}


static void act31()
-{
+{
NLA = CONTINUATION;
- zzline++; zzskip();
+ zzline++; zzskip();
}


static void act32()
-{
+{
NLA = LIT;
- zzlextext[0] = zzlextext[1];
+ zzlextext[0] = zzlextext[1];
}


static void act33()
-{
+{
NLA = REGCHAR;
}

static unsigned char shift0[257] = {
- 0, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 1, 2, 40, 40, 1, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 1, 40, 40, 40, 40, 4, 40,
- 40, 30, 31, 34, 35, 40, 37, 40, 40, 23,
- 24, 24, 24, 24, 24, 24, 24, 25, 25, 40,
- 40, 26, 40, 27, 40, 3, 21, 21, 21, 21,
- 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
- 22, 22, 22, 22, 22, 22, 22, 22, 22, 20,
- 22, 22, 32, 39, 33, 40, 22, 40, 11, 9,
- 12, 21, 6, 19, 22, 22, 14, 22, 22, 5,
- 8, 16, 15, 17, 22, 10, 18, 13, 22, 22,
- 22, 7, 22, 22, 28, 36, 29, 38, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 0, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 1, 2, 40, 40, 1, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 1, 40, 40, 40, 40, 4, 40,
+ 40, 30, 31, 34, 35, 40, 37, 40, 40, 23,
+ 24, 24, 24, 24, 24, 24, 24, 25, 25, 40,
+ 40, 26, 40, 27, 40, 3, 21, 21, 21, 21,
+ 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 20,
+ 22, 22, 32, 39, 33, 40, 22, 40, 11, 9,
+ 12, 21, 6, 19, 22, 22, 14, 22, 22, 5,
+ 8, 16, 15, 17, 22, 10, 18, 13, 22, 22,
+ 22, 7, 22, 22, 28, 36, 29, 38, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+ 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40
};


static void act34()
-{
+{
NLA = 1;
- error("unterminated action", zzline); zzmode(START);
+ error("unterminated action", zzline); zzmode(START);
}


static void act35()
-{
+{
NLA = ACTION;
if (func_action) fprintf(OUT,"}\n\n");
zzmode(START);
@@ -364,7 +364,7 @@ static void act35()
/* MR1 via <<%%lexmember ...>> */
/* MR1 This is a consequence of not saving actions */
/* MR1 */
- /* MR1 */ parserClass=0;
+ /* MR1 */ parserClass=0;
/* MR1 */ lexPrefix=0;
/* MR1 */ lexAction=0;
/* MR1 */ lexMember=0;
@@ -372,35 +372,35 @@ static void act35()


static void act36()
-{
+{
NLA = 34;
- xxputc(zzlextext[0]); zzskip();
+ xxputc(zzlextext[0]); zzskip();
}


static void act37()
-{
+{
NLA = 35;
- xxputc('>'); zzskip();
+ xxputc('>'); zzskip();
}


static void act38()
-{
+{
NLA = 36;
- xxputc('\\'); zzskip();
+ xxputc('\\'); zzskip();
}


static void act39()
-{
+{
NLA = 37;
- xxputc(zzlextext[0]); ++zzline; zzskip();
+ xxputc(zzlextext[0]); ++zzline; zzskip();
}


static void act40()
-{
+{
NLA = 38;
zzmode(ACTION_COMMENTS); /* MR1 */
xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
@@ -408,7 +408,7 @@ static void act40()


static void act41()
-{
+{
NLA = 39;
zzmode(ACTION_CPP_COMMENTS); /* MR1 */
xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
@@ -416,49 +416,49 @@ static void act41()


static void act42()
-{
+{
NLA = 40;
- xxputc(zzlextext[0]); zzskip();
+ xxputc(zzlextext[0]); zzskip();
}

static unsigned char shift1[257] = {
- 0, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 3, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 5, 6, 6, 6, 6, 4, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 1, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 2, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 0, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 3, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 5, 6, 6, 6, 6, 4, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 1, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 2, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6
};


static void act43()
-{
+{
NLA = 1;
}


static void act44()
-{
+{
NLA = 41;
zzmode(ACT); /* MR1 */
xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
@@ -466,56 +466,56 @@ static void act44()


static void act45()
-{
+{
NLA = 42;
- zzline++; xxputc(zzlextext[0]); zzskip();
+ zzline++; xxputc(zzlextext[0]); zzskip();
}


static void act46()
-{
+{
NLA = 43;
- xxputc(zzlextext[0]); zzskip();
+ xxputc(zzlextext[0]); zzskip();
}

static unsigned char shift2[257] = {
- 0, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 3, 4, 4, 3, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 1, 4, 4, 4, 4, 2, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 0, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 3, 4, 4, 3, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 1, 4, 4, 4, 4, 2, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4
};


static void act47()
-{
+{
NLA = 1;
}


static void act48()
-{
+{
NLA = 44;
zzmode(ACT); zzline++; /* MR1 */
xxprintf("%s", &(zzlextext[0])); zzskip(); /* MR1 */
@@ -523,37 +523,37 @@ static void act48()


static void act49()
-{
+{
NLA = 45;
- xxputc(zzlextext[0]); zzskip();
+ xxputc(zzlextext[0]); zzskip();
}

static unsigned char shift3[257] = {
- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 1, 2, 2, 1, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 1, 2, 2, 1, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2
};

@@ -561,586 +561,586 @@ static unsigned char shift3[257] = {
typedef unsigned char DfaState;

static DfaState st0[42] = {
- 1, 2, 3, 4, 5, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 7, 8, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ 1, 2, 3, 4, 5, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
6, 94
};

static DfaState st1[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st2[42] = {
- 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st3[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st4[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st5[42] = {
- 94, 94, 94, 94, 22, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 22, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st6[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st7[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 23, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 23, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st8[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 24, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 24, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st9[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st10[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st11[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st12[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st13[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st14[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st15[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st16[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st17[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st18[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st19[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st20[42] = {
- 94, 25, 26, 25, 25, 25, 25, 25, 25, 27,
- 28, 25, 25, 29, 25, 25, 30, 25, 25, 25,
- 25, 25, 25, 31, 32, 32, 25, 25, 25, 25,
- 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+ 94, 25, 26, 25, 25, 25, 25, 25, 25, 27,
+ 28, 25, 25, 29, 25, 25, 30, 25, 25, 25,
+ 25, 25, 25, 31, 32, 32, 25, 25, 25, 25,
+ 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
25, 94
};

static DfaState st21[42] = {
- 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 21, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st22[42] = {
- 94, 94, 94, 94, 94, 33, 33, 33, 33, 33,
- 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
- 33, 33, 33, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st23[42] = {
- 94, 94, 94, 94, 34, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 34, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st24[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st25[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st26[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st27[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st28[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st29[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st30[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st31[42] = {
- 94, 94, 94, 94, 94, 94, 94, 35, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 35, 94, 94, 36, 36, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 35, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 35, 94, 94, 36, 36, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st32[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st33[42] = {
- 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
- 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
- 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st34[42] = {
- 94, 94, 94, 94, 39, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 39, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st35[42] = {
- 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
- 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
- 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
+ 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
+ 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st36[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 36, 36, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 36, 36, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st37[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 37, 37, 37, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st38[42] = {
- 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
- 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
- 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38,
+ 38, 38, 38, 38, 38, 38, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st39[42] = {
- 94, 94, 94, 94, 94, 41, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 42, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 41, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 42, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st40[42] = {
- 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
- 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
- 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 40, 94, 94, 40,
+ 94, 40, 40, 94, 94, 94, 94, 94, 94, 40,
+ 94, 40, 94, 40, 40, 40, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st41[42] = {
- 94, 94, 94, 94, 94, 94, 43, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 43, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st42[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 44, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 44, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st43[42] = {
- 94, 94, 94, 94, 94, 94, 94, 45, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 45, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st44[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 46, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 46, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st45[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 47, 94,
- 94, 48, 94, 94, 94, 94, 94, 49, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 47, 94,
+ 94, 48, 94, 94, 94, 94, 94, 49, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st46[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 50, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 50, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st47[42] = {
- 94, 94, 94, 94, 94, 94, 51, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 51, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st48[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 52, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 52, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st49[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 53, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 53, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st50[42] = {
- 94, 94, 94, 94, 94, 94, 54, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 54, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st51[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 55, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 55, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st52[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 56, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 56, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st53[42] = {
- 94, 94, 94, 94, 94, 94, 57, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 57, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st54[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 58, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 58, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st55[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 59,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 59,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st56[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 60, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 60, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st57[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 61,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 61,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st58[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 62, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 62, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st59[42] = {
- 94, 94, 94, 94, 94, 94, 63, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 63, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st60[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 64, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 64, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st61[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 65, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 65, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st62[42] = {
- 94, 94, 94, 94, 94, 66, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 66, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st63[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 67, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 67, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st64[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 68, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 68, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st65[42] = {
- 94, 94, 94, 94, 94, 94, 94, 69, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 69, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st66[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 70, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 70, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st67[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st68[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st69[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st70[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 71, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 71, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st71[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 72, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 72, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

static DfaState st72[42] = {
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
- 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94
};

@@ -1328,15 +1328,15 @@ DfaState *dfa[94] = {


DfaState accepts[95] = {
- 0, 1, 2, 3, 4, 33, 33, 33, 33, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 0, 2, 5, 11, 12, 32, 31, 30, 29, 27,
- 28, 24, 26, 6, 0, 0, 24, 26, 6, 0,
- 25, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 7, 8, 10,
- 0, 0, 9, 0, 34, 36, 38, 39, 42, 42,
- 35, 37, 41, 40, 0, 43, 46, 46, 45, 44,
+ 0, 1, 2, 3, 4, 33, 33, 33, 33, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 0, 2, 5, 11, 12, 32, 31, 30, 29, 27,
+ 28, 24, 26, 6, 0, 0, 24, 26, 6, 0,
+ 25, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 7, 8, 10,
+ 0, 0, 9, 0, 34, 36, 38, 39, 42, 42,
+ 35, 37, 41, 40, 0, 43, 46, 46, 45, 44,
0, 47, 48, 49, 0
};

diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c
index fbaf93afc63c..70101282e432 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c
@@ -31,7 +31,7 @@
ANTLR_INFO


-/* MR20 G. Hobbelt
+/* MR20 G. Hobbelt
Fix for Borland C++ 4.x & 5.x compiling with ALL warnings enabled
*/

@@ -53,7 +53,7 @@ int flag_paren = FALSE;
int flag_brace = FALSE;
int mode_counter = 0; /* keep track of number of %%names */

-
+

void
#ifdef __USE_PROTOS
@@ -199,7 +199,7 @@ do_conversion()
{
new_automaton_mode(); func_action = TRUE;
rule_list();
-
+
dfa_class_nop[mode_counter] =
relabel(zzaArg(zztasp1,1 ).l,comp_level);
if (comp_level)
@@ -365,7 +365,7 @@ and_expr()
zzMake0;
{
repeat_expr();
-
+
zzaRet.l=zzaArg(zztasp1,1 ).l; zzaRet.r=zzaArg(zztasp1,1 ).r;
{
zzBLOCK(zztasp2);
@@ -482,7 +482,7 @@ expr()
zzmatch(L_BRACK); zzCONSUME;
atom_list();
zzmatch(R_BRACK);
-
+
/* MR23 */ if (zzaRet.l != NULL) {
(zzaRet.l)->trans[0] = zzaRet.r;
(zzaRet.l)->label = set_dup(zzaArg(zztasp1,2 ).label);
@@ -497,7 +497,7 @@ expr()
zzmatch(L_BRACK); zzCONSUME;
atom_list();
zzmatch(R_BRACK);
-
+
/* MR23 */ if (zzaRet.l != NULL) {
(zzaRet.l)->trans[0] = zzaRet.r;
(zzaRet.l)->label = set_dif(normal_chars,zzaArg(zztasp1,3 ).label);
@@ -511,8 +511,8 @@ expr()
zzmatch(L_PAR); zzCONSUME;
reg_expr();
zzmatch(R_PAR);
-
- /* MR23 */ if (zzaRet.l != NULL) {
+
+ /* MR23 */ if (zzaRet.l != NULL) {
(zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
if (zzaArg(zztasp1,2 ).r) {
(zzaArg(zztasp1,2 ).r)->trans[1] = zzaRet.r; /* MR20 */
@@ -526,7 +526,7 @@ expr()
zzmatch(L_BRACE); zzCONSUME;
reg_expr();
zzmatch(R_BRACE);
-
+
/* MR23 */ if (zzaRet.l != NULL) {
(zzaRet.l)->trans[0] = zzaArg(zztasp1,2 ).l;
(zzaRet.l)->trans[1] = zzaRet.r;
@@ -540,7 +540,7 @@ expr()
else {
if ( (setwd3[LA(1)]&0x1) ) {
atom();
-
+
/* MR23 */ if (zzaRet.l != NULL) {
(zzaRet.l)->trans[0] = zzaRet.r;
(zzaRet.l)->label = set_dup(zzaArg(zztasp1,1 ).label);
@@ -636,7 +636,7 @@ near_atom()
int debugLetter1 = zzaRet.letter;
int debugLetter2 = zzaArg(zztasp2,2 ).letter;
}
- if (zzaRet.letter > zzaArg(zztasp2,2 ).letter
+ if (zzaRet.letter > zzaArg(zztasp2,2 ).letter
&& zzaArg(zztasp2,2 ).letter != 0xff){ /* MR16 */
error("invalid range ", zzline);
}
@@ -792,7 +792,7 @@ anychar()
return;
fail:
zzEXIT(zztasp1);
- /* empty action */
+ /* empty action */
zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
zzresynch(setwd3, 0x80);
}
@@ -808,7 +808,7 @@ new_nfa_node()
{
register nfa_node *t;
static int nfa_size=0; /* elements nfa_array[] can hold */
-
+
++nfa_allocated;
if (nfa_size<=nfa_allocated){
/* need to redo array */
@@ -879,7 +879,7 @@ set s;
#endif
{
unsigned int *x;
-
+
fprintf(f, "n = %d,", s.n);
if (s.setword){
fprintf(f, "setword = %x, ", s.setword);
@@ -909,7 +909,7 @@ int last_node;
{
register int i;
nfa_node *t;
-
+
for (i=first_node; i<=last_node; ++i){
t = NFA(i);
if (!t) break;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c
index 35bd827f8c9e..41ec653b4e97 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c
@@ -136,7 +136,7 @@ Opt options[] = {
{ "-o", 1, (WildFunc)p_outdir, OutputDirectoryOption},
{ "-", 0, (WildFunc)p_stdio, "Use standard i/o rather than file"},
{ "*", 0, (WildFunc)p_file, ""}, /* anything else is a file */
- { NULL, 0, NULL }
+ { NULL, 0, NULL }
};

#ifdef __USE_PROTOS
@@ -149,7 +149,7 @@ Opt *options;
#endif
{
Opt *p;
-
+
while ( argc-- > 0 )
{
p = options;
@@ -240,7 +240,7 @@ char *argv[];
}

/* initialize all the variables */
-void
+void
#ifdef __USE_PROTOS
init(void)
#else
@@ -265,11 +265,11 @@ init()
clear_hash();
/* NOTE: need to set this flag before the lexer starts getting */
/* tokens */
- func_action = FALSE;
+ func_action = FALSE;
}

/* stuff that needs to be reset when a new automaton is being built */
-void
+void
#ifdef __USE_PROTOS
new_automaton_mode(void) /* MR1 */
#else
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile
index b3a34d3b4613..9f79b3fbdd84 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile
@@ -149,7 +149,7 @@ main.$(OBJ_EXT) : main.c dlg.h
set.$(OBJ_EXT) : $(SET)/set.c
$(BUILD_CC) -c $(BUILD_CFLAGS) $(SET)/set.c

-%.o : %.c
+%.o : %.c
$(BUILD_CC) -c $(BUILD_CFLAGS) $(BUILD_CPPFLAGS) $< -o $@

lint:
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c
index 2e56a6d8c190..0366ea67e69f 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c
@@ -143,7 +143,7 @@ char *s;
#ifdef __USE_PROTOS
void p_class_hdr(void)
#else
-void p_class_hdr()
+void p_class_hdr()
#endif
{
if ( class_stream == NULL ) return;
@@ -845,6 +845,6 @@ set label;
printf("\n");
free(t);
}
-
+
}
#endif
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c
index f2dce30f5fe5..94906f3887a5 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c
@@ -67,7 +67,7 @@ nfa_node *start;
#endif
{
if (level){
- set_free(used_classes);
+ set_free(used_classes);
partition(start,level);
label_with_classes(start);
}else{
@@ -146,7 +146,7 @@ set *maximal_class;
{
/* pick a new operation number */
++operation_no;
- r_intersect(start,maximal_class);
+ r_intersect(start,maximal_class);
}

#ifdef __USE_PROTOS
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c b/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c
index 84fe99d69cb8..83665402587a 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c
@@ -211,7 +211,7 @@ char *OutMetaName(char *n)
char *OutMetaName(n)
char *n;
#endif
-{
+{
static char *dir_sym = DirectorySymbol;
static char newname[MaxFileName+1];
char *p;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp
index 720fe75af1d7..d54e9db2098f 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp
@@ -400,7 +400,7 @@ resynch(SetWordType *wd,SetWordType mask)
/* if current token is in resynch set, we've got what we wanted */

/* MR8 */ if ( wd[LA(1)]&mask || LA(1) == eofToken ) {resynchConsumed=0; return;}
-
+
/* scan until we find something in the resynch set */

while ( !(wd[LA(1)]&mask) && LA(1) != eofToken ) {consume();}
@@ -419,7 +419,7 @@ resynch(SetWordType *wd,SetWordType mask)
returns the text, so the text representation of the token
must be passed explicitly. I think.
*/
-
+
void ANTLRParser::
syn(_ANTLRTokenPtr /*tok MR23*/, ANTLRChar *egroup, SetWordType *eset,
ANTLRTokenType etok, int k)
@@ -432,7 +432,7 @@ syn(_ANTLRTokenPtr /*tok MR23*/, ANTLRChar *egroup, SetWordType *eset,

/* MR23 If the token is not an EOF token, then use the ->getText() value.

- If the token is the EOF token the text returned by ->getText()
+ If the token is the EOF token the text returned by ->getText()
may be garbage. If the text from the token table is "@" use
"<eof>" instead, because end-users don't know what "@" means.
If the text is not "@" then use that text, which must have been
@@ -526,7 +526,7 @@ void
ANTLRParser::FAIL(int k, ...)
{
//
-// MR1 10-Apr-97
+// MR1 10-Apr-97
//

if (zzFAILtext == NULL) zzFAILtext=new char [1000]; // MR9
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h
index fe405f416770..9b833a13cc46 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h
@@ -228,7 +228,7 @@ public:
virtual ~ANTLRParser();

virtual void init();
-
+
ANTLRTokenType LA(int i)
{
//
@@ -274,7 +274,7 @@ public:
SetWordType *whatFollows);
virtual int _match_wdfltsig(ANTLRTokenType tokenWanted,
SetWordType *whatFollows);
-
+
const ANTLRChar * parserTokenName(int tok); // MR1

int traceOptionValueDefault; // MR11
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp
index a94f080c8671..af1737dd2a84 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp
@@ -90,7 +90,7 @@ ASTBase::preorder(void* pData /*= NULL*/ /* MR23 */)
while ( tree!= NULL )
{
if ( tree->_down != NULL ) {
- tree->preorder_before_action(pData); // MR1
+ tree->preorder_before_action(pData); // MR1
};
tree->preorder_action(pData);
if ( tree->_down!=NULL )
@@ -136,7 +136,7 @@ ASTBase::tmake(ASTBase *root, ...)
va_start(ap, root);

if ( root != NULL )
- if ( root->_down != NULL ) {
+ if ( root->_down != NULL ) {
root->reportOverwriteOfDownPointer(); /* MR21 Report problem which almost always an error */
return NULL;
}
@@ -162,7 +162,7 @@ ASTBase *
ASTBase::dup()
{
ASTBase *u, *t=this;
-
+
if ( t == NULL ) return NULL;
/*
u = new ASTBase;
@@ -189,7 +189,7 @@ ASTBase *
ASTDoublyLinkedBase::dup()
{
ASTDoublyLinkedBase *u, *t=this;
-
+
if ( t == NULL ) return NULL;
u = (ASTDoublyLinkedBase *)this->shallowCopy();
u->_up = NULL; /* set by calling invocation */
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp
index 9a2f2fc88b81..9c1c3c20990b 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp
@@ -340,12 +340,12 @@ getParser() { // MR1
} // MR1

void ANTLRTokenBuffer::panic(const char *msg) // MR23
-{
+{
if (parser) //MR23
parser->panic(msg); //MR23
else //MR23
- exit(PCCTS_EXIT_FAILURE);
-}
+ exit(PCCTS_EXIT_FAILURE);
+}

//MR23
int ANTLRTokenBuffer::printMessage(FILE* pFile, const char* pFormat, ...)
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h b/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h
index f3b4b79e8a8b..e80afce946fc 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h
@@ -38,24 +38,24 @@ template <
class DLG_stream_input : public DLGInputStream
{
public:
-
+
DLG_stream_input(::std::basic_istream<E,T> * p_input_stream)
: input(p_input_stream)
{
// nothing to do!
};
-
+
DLG_stream_input(const DLG_stream_input & a_recopier)
: input(a_recopier.input)
{
// nothing to do!
};
-
+
virtual ~DLG_stream_input()
{
this->purge(); // bloody templarized lookup...
};
-
+
DLG_stream_input operator = (const DLG_stream_input & a_affecter)
{
if (this != &a_affecter)
@@ -65,13 +65,13 @@ public:

return(*this);
};
-
+
virtual int nextChar()
{
E extracted_stuff;
-
+
input->get(extracted_stuff);
-
+
if (*input)
{
return(int(extracted_stuff));
@@ -81,13 +81,13 @@ public:
return(EOF);
}
};
-
+
protected:
-
+
::std::basic_istream<E,T> * input;
-
+
private:
-
+
void purge()
{
// nothing to do!
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp
index b218afc03811..2ade02c3ccde 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp
@@ -83,7 +83,7 @@ DLGLexerBase(DLGInputStream *in,
this->lexErrCount=0; // MR11
}

-// MR19 THM
+// MR19 THM

void DLGLexerBase::reset()
{
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h b/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h
index d25b8d69392c..8532f8fa72a0 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h
@@ -55,7 +55,7 @@ private:

// no copy assignment allowed
ParserBlackBox & operator=(ParserBlackBox const &);
-
+
protected:
DLGFileInput *in;
Lexer *scan;
@@ -65,7 +65,7 @@ protected:
FILE *file;
int openByBlackBox; /* MR21 Don't close what we haven't opened */
public:
-
+
ParserBlackBox(FILE *f)
: in(0)
, scan(0)
@@ -77,7 +77,7 @@ public:
{
if (f == NULL)
{
- cerr << "invalid file pointer\n";
+ cerr << "invalid file pointer\n";
}
else
{
@@ -118,7 +118,7 @@ public:
_parser->init();
}
}
-
+
~ParserBlackBox()
{
delete in; delete scan; delete pipe; delete _parser; delete tok;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp
index a8249cdac0a2..9d708e945ff9 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp
@@ -270,11 +270,11 @@ scanmatch(ScanAST *t, PCCTS_AST **labels[], int *n)
/* match what's below if something there and current node is not wildcard */
if ( sib->down()!=NULL && sib->type()!=0 )
{
- if ( sib->down()==NULL )
+ if ( sib->down()==NULL )
{
- if ( u->down()!=NULL )
- return 0;
- else
+ if ( u->down()!=NULL )
+ return 0;
+ else
return 1;
}
if ( !u->down()->scanmatch(sib->down(), labels, n) ) return 0;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h b/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h
index 27a324274257..ea3d2a42cd6c 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h
@@ -1,4 +1,4 @@
-/* antlr.h
+/* antlr.h
*
* SOFTWARE RIGHTS
*
@@ -353,7 +353,7 @@ extern void _inf_zzgettok();
InfLookData \
zzGuessData
#endif
-
+
#endif /* LL_k */


@@ -461,7 +461,7 @@ extern void _inf_zzgettok();
zzEXIT_ANTLR(zztasp1 + 1); \
} \
zzleaveANTLR(f);
-
+
#define ANTLRm(st, f, _m) zzbufsize = ZZLEXBUFSIZE; \
zzmode(_m); \
zzenterANTLR(f); \
@@ -473,7 +473,7 @@ extern void _inf_zzgettok();
zzEXIT_ANTLR(zztasp1 + 1); \
} \
zzleaveANTLR(f);
-
+
#define ANTLRf(st, f) zzbufsize = ZZLEXBUFSIZE; \
zzenterANTLRf(f); \
{ \
@@ -535,7 +535,7 @@ extern void _inf_zzgettok();
#endif

#ifdef __USE_PROTOS
-extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **, SetWordType * /* MR23 */);
+extern int _zzsetmatch(SetWordType *, char **, char **, int *, int *, SetWordType **, SetWordType * /* MR23 */);
extern int _zzsetmatch_wsig(SetWordType *);
#else
extern int _zzsetmatch();
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c
index 9326ae16ae75..f22c0523f28e 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/ast.c
@@ -18,7 +18,7 @@
* addition, we ask that this header remain intact in our source code.
* As long as these guidelines are kept, we expect to continue enhancing
* this system and expect to make other tools available as they are
- * completed.
+ * completed.
*
* ANTLR 1.33
* Terence Parr
@@ -292,7 +292,7 @@ AST *t;
#endif
{
AST *u;
-
+
if ( t == NULL ) return NULL;
u = zzastnew();
*u = *t;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/h/err.h b/BaseTools/Source/C/VfrCompile/Pccts/h/err.h
index 435d48356d5a..cd24f46db67c 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/h/err.h
+++ b/BaseTools/Source/C/VfrCompile/Pccts/h/err.h
@@ -106,7 +106,7 @@ SetWordType *wd, mask;

/* if current token is in resynch set, we've got what we wanted */
if ( wd[LA(1)]&mask || LA(1) == zzEOF_TOKEN ) {consumed=0; return;}
-
+
/* scan until we find something in the resynch set */
while ( !(wd[LA(1)]&mask) && LA(1) != zzEOF_TOKEN ) {zzCONSUME;}
consumed=1;
@@ -427,7 +427,7 @@ int k;
SetWordType *eset;
#endif
{
-
+
zzSyntaxErrCount++; /* MR11 */
fprintf(stderr, "line %d: syntax error at \"%s\"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
@@ -508,14 +508,14 @@ SetWordType **zzMissSet;
zzCONSUME;
}
if ( LA(1)!=_t ) {
- *zzBadText = *zzMissText=LATEXT(1);
+ *zzBadText = *zzMissText=LATEXT(1);
*zzMissTok= _t; *zzBadTok=LA(1);
- *zzMissSet=NULL;
+ *zzMissSet=NULL;
return 0;
}
- zzMakeAttr
- zzdirty++;
- zzlabase++;
+ zzMakeAttr
+ zzdirty++;
+ zzlabase++;
return 1;
}

@@ -533,9 +533,9 @@ int _t;
if ( LA(1)!=_t ) {
return 0;
}
- zzMakeAttr
- zzdirty++;
- zzlabase++;
+ zzMakeAttr
+ zzdirty++;
+ zzlabase++;
return 1;
}

@@ -553,16 +553,16 @@ char **zzMissText;
int *zzMissTok, *zzBadTok;
SetWordType **zzMissSet;
#endif
-{
- if ( zzdirty ) {zzCONSUME;}
+{
+ if ( zzdirty ) {zzCONSUME;}
if ( LA(1)!=_t ) {
- *zzBadText = *zzMissText=LATEXT(1);
+ *zzBadText = *zzMissText=LATEXT(1);
*zzMissTok= _t; *zzBadTok=LA(1);
- *zzMissSet=NULL;
+ *zzMissSet=NULL;
return 0;
- }
- zzdirty = 1;
- zzMakeAttr
+ }
+ zzdirty = 1;
+ zzMakeAttr
return 1;
}

@@ -574,12 +574,12 @@ _zzmatch_wsig(_t)
int _t;
#endif
{
- if ( zzdirty ) {zzCONSUME;}
+ if ( zzdirty ) {zzCONSUME;}
if ( LA(1)!=_t ) {
return 0;
}
- zzdirty = 1;
- zzMakeAttr
+ zzdirty = 1;
+ zzMakeAttr
return 1;
}

@@ -601,10 +601,10 @@ int *zzMissTok, *zzBadTok;
SetWordType **zzMissSet;
#endif
{
- if ( LA(1)!=_t ) {
- *zzBadText = *zzMissText=LATEXT(1);
+ if ( LA(1)!=_t ) {
+ *zzBadText = *zzMissText=LATEXT(1);
*zzMissTok= _t; *zzBadTok=LA(1);
- *zzMissSet=NULL;
+ *zzMissSet=NULL;
return 0;
}
zzMakeAttr
@@ -620,7 +620,7 @@ int _t;
#endif
{
if ( LA(1)!=_t ) return 0;
- zzMakeAttr
+ zzMakeAttr
return 1;
}

@@ -634,14 +634,14 @@ _inf_zzgettok(void)
_inf_zzgettok()
#endif
{
- if ( zzinf_labase >= zzinf_last )
- {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
- else {
+ if ( zzinf_labase >= zzinf_last )
+ {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
+ else {
NLA = zzinf_tokens[zzinf_labase];
zzline = zzinf_line[zzinf_labase]; /* wrong in 1.21 */
- strcpy(NLATEXT, zzinf_text[zzinf_labase]);
- zzinf_labase++;
- }
+ strcpy(NLATEXT, zzinf_text[zzinf_labase]);
+ zzinf_labase++;
+ }
}
#endif

@@ -670,14 +670,14 @@ zzfill_inf_look()
{
fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
zzinf_text_buffer_size);
- exit(PCCTS_EXIT_FAILURE);
+ exit(PCCTS_EXIT_FAILURE);
}
zzinf_tokens = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
if ( zzinf_tokens == NULL )
{
fprintf(stderr, "cannot allocate token buffer (%d tokens)\n",
zzinf_token_buffer_size);
- exit(PCCTS_EXIT_FAILURE);
+ exit(PCCTS_EXIT_FAILURE);
}
zzinf_line = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
if ( zzinf_line == NULL )
@@ -741,8 +741,8 @@ zzfill_inf_look()
{
fprintf(stderr, "cannot allocate lookahead text buffer (%d)\n",
zzinf_text_buffer_size);
- exit(PCCTS_EXIT_FAILURE);
- }
+ exit(PCCTS_EXIT_FAILURE);
+ }
zzinf_text_buffer_index = 0;
zzinf_lap = 0;
/* set ptrs so that zzinf_text[i] is the text of the ith token found on input */
@@ -826,7 +826,7 @@ SetWordType *whatFollows;
return 0;
}
else {
- zzMakeAttr
+ zzMakeAttr
#ifdef DEMAND_LOOK
#ifdef LL_K
zzdirty++;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/history.txt b/BaseTools/Source/C/VfrCompile/Pccts/history.txt
index 89ad8408c93d..84bfeb06ee7a 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/history.txt
+++ b/BaseTools/Source/C/VfrCompile/Pccts/history.txt
@@ -59,7 +59,7 @@ kahead fetches were to occur only when necessary for the parse


Page 1
-
+
PCCTS


@@ -121,7 +121,7 @@ called "parser exception handling" in a near future release.


Page 2
-
+
PCCTS


@@ -183,4 +183,4 @@ _____________________________________________________________________________


Page 3
-
+
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
index 4952a30b3883..a37ba7450405 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c
@@ -193,7 +193,7 @@ char *t;
pSor(NULL);
warn("sorcerer input file before any '-sor' option");
}
-
+
require(num_sfiles[num_sors-1]<MAX_SFILES,
"exceeded max # of sorcerer input files");
sfiles[num_sors-1][num_sfiles[num_sors-1]++] = t;
@@ -378,10 +378,10 @@ char **argv;
#endif
{
int i;
-
+
if ( argc == 1 ) { help(); DIE; }
for(i=0;i<MAX_SORS;i++) num_sfiles[i]=0;
-
+
ProcessArgs(argc-1, &(argv[1]), options);

strcpy(ATOKENBUFFER_O, ATOKENBUFFER_C);
@@ -476,7 +476,7 @@ char **argv;
else printf("# ANTLR-defined token types\n");
printf("#\n");
/***********
- printf(".SUFFIXES:\n.SUFFIXES:\t.o .cpp .c .h .g .i .dlg .sor\n");
+ printf(".SUFFIXES:\n.SUFFIXES:\t.o .cpp .c .h .g .i .dlg .sor\n");
***********/
if ( user_token_types!=NULL ) {
printf("# Make sure #tokdefs directive in ANTLR grammar lists this file:\n");
@@ -821,7 +821,7 @@ char **argv;
pclasses(&sclasses[i], 1, CPP_FILE_SUFFIX_NO_DOT);
printf(" ");
pclasses(&sclasses[i], 1, "h");
- if ( strcmp(hdr,"stdpccts.h")!=0 )
+ if ( strcmp(hdr,"stdpccts.h")!=0 )
{
printf(" ");
printf("$(HDR_FILE) stdpccts.h");
@@ -842,7 +842,7 @@ char **argv;
printf("STreeParser%s ",OBJ_FILE_SUFFIX);
printf("$(SOR_LIB)%sSTreeParser.cpp\n\n",DirectorySymbol);
}
-
+
printf("$(ANTLR_SPAWN) : $(GRM)\n");
printf("\t$(ANTLR) $(AFLAGS) $(GRM)\n");

@@ -1056,7 +1056,7 @@ char *DIR()
#endif
{
static char buf[200+1];
-
+
if ( strcmp(outdir,TopDirectory)==0 ) return "";
sprintf(buf, "%s%s", outdir, DirectorySymbol);
return buf;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
index 2cf9fad72701..ef36f0888a6a 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c
@@ -341,7 +341,7 @@ char **argv;
if ( user_token_types!=NULL ) printf("# User-defined token types in '%s'\n", user_token_types);
else printf("# ANTLR-defined token types\n");
printf("#\n");
- printf(".SUFFIXES:\n.SUFFIXES: .o .cpp .c .h .g .i .dlg\n");
+ printf(".SUFFIXES:\n.SUFFIXES: .o .cpp .c .h .g .i .dlg\n");
if ( user_token_types!=NULL ) {
printf("# Make sure #tokdefs directive in ANTLR grammar lists this file:\n");
printf("TOKENS = %s", user_token_types);
@@ -755,7 +755,7 @@ char *err_;
char *DIR()
{
static char buf[200+1];
-
+
if ( strcmp(outdir,TopDirectory)==0 ) return "";
sprintf(buf, "%s%s", outdir, DirectorySymbol);
return buf;
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c
index 805bf655331b..0fdb75a5e54f 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c
@@ -154,7 +154,7 @@ char *s;
#endif
{
ArcPtr p;
-
+
if ( automaton == accept && *s == '\0' ) return 1; /* match */

for (p=automaton->arcs; p!=NULL; p=p->next) /* try all arcs */
@@ -185,12 +185,12 @@ GraphPtr g;
#endif
{
Graph g1, g2;
-
+
if ( andExpr(&g1) == -1 )
{
return -1;
}
-
+
while ( token == '|' )
{
int a;
@@ -200,7 +200,7 @@ GraphPtr g;
else if ( !a ) return 1; /* empty alternative */
g1 = BuildNFA_AorB(g1, g2);
}
-
+
if ( token!='\0' ) return -1;

*g = g1;
@@ -219,18 +219,18 @@ GraphPtr g;
#endif
{
Graph g1, g2;
-
+
if ( expr(&g1) == -1 )
{
return -1;
}
-
+
while ( token==Atom || token=='{' || token=='(' || token=='~' || token=='[' )
{
if (expr(&g2) == -1) return -1;
g1 = BuildNFA_AB(g1, g2);
}
-
+
*g = g1;
return 1;
}
@@ -251,7 +251,7 @@ GraphPtr g;
{
int complement = 0;
char s[257]; /* alloc space for string of char in [] */
-
+
if ( token == '~' || token == '[' )
{
if ( token == '~' ) {complement = 1; next();}
@@ -294,7 +294,7 @@ GraphPtr g;
repeatSymbol( g );
return 1;
}
-
+
return -1;
}

@@ -335,9 +335,9 @@ int complement;
static unsigned char set[256]; /* no duplicates */
int first, last, i;
char *s = p;
-
+
if ( token != Atom ) return -1;
-
+
for (i=0; i<256; i++) set[i] = 0;
while ( token == Atom )
{
@@ -458,7 +458,7 @@ int label;
#endif
{
ArcPtr a;
-
+
a = newGraphArc();
if ( i->arcs == NULL ) i->arctail = i->arcs = a;
else {(i->arctail)->next = a; i->arctail = a;}
@@ -474,7 +474,7 @@ int label;
#endif
{
Graph g;
-
+
g.left = newNode();
g.right = newNode();
ArcBetweenGraphNodes(g.left, g.right, label);
@@ -489,7 +489,7 @@ Graph A, B;
#endif
{
Graph g;
-
+
ArcBetweenGraphNodes(A.right, B.left, Epsilon);
g.left = A.left;
g.right = B.right;
@@ -504,7 +504,7 @@ Graph A, B;
#endif
{
Graph g;
-
+
g.left = newNode();
ArcBetweenGraphNodes(g.left, A.left, Epsilon);
ArcBetweenGraphNodes(g.left, B.left, Epsilon);
@@ -522,9 +522,9 @@ char *s;
#endif
{
Graph g;
-
+
if ( s == NULL ) return g;
-
+
g.left = newNode();
g.right = newNode();
while ( *s != '\0' )
@@ -545,12 +545,12 @@ Graph A;

g.left = newNode();
g.right = newNode();
-
+
ArcBetweenGraphNodes(g.left, A.left, Epsilon);
ArcBetweenGraphNodes(g.left, g.right, Epsilon);
ArcBetweenGraphNodes(A.right, g.right, Epsilon);
ArcBetweenGraphNodes(A.right, A.left, Epsilon);
-
+
return( g );
}

@@ -562,7 +562,7 @@ Graph A;
#endif
{
ArcBetweenGraphNodes(A.right, A.left, Epsilon);
-
+
return( A );
}

@@ -574,13 +574,13 @@ Graph A;
#endif
{
Graph g;
-
+
g.left = newNode();
g.right = newNode();
-
+
ArcBetweenGraphNodes(g.left, A.left, Epsilon);
ArcBetweenGraphNodes(g.left, g.right, Epsilon);
ArcBetweenGraphNodes(A.right, g.right, Epsilon);
-
+
return( g );
}
diff --git a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c
index 6b9b510b8aed..44d6ee44c3ce 100644
--- a/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c
+++ b/BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c
@@ -2,37 +2,37 @@

The following is a general-purpose set library originally developed
by Hank Dietz and enhanced by Terence Parr to allow dynamic sets.
-
+
Sets are now structs containing the #words in the set and
a pointer to the actual set words.
-
+
Generally, sets need not be explicitly allocated. They are
created/extended/shrunk when appropriate (e.g. in set_of()).
HOWEVER, sets need to be destroyed (free()ed) when they go out of scope
or are otherwise no longer needed. A routine is provided to
free a set.
-
+
Sets can be explicitly created with set_new(s, max_elem).
-
+
Sets can be declared to have minimum size to reduce realloc traffic.
Default minimum size = 1.
-
+
Sets can be explicitly initialized to have no elements (set.n == 0)
by using the 'empty' initializer:
-
+
Examples:
set a = empty; -- set_deg(a) == 0
-
+
return( empty );
-
+
Example set creation and destruction:
-
+
This message has been truncated.


[PATCH 5/7] MdeModulePkg: strip trailing whitespace

Leif Lindholm
 

Cc: Jian J Wang <jian.j.wang@intel.com>
Cc: Hao A Wu <hao.a.wu@intel.com>
Cc: Dandan Bi <dandan.bi@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Zhichao Gao <zhichao.gao@intel.com>
Cc: Ray Ni <ray.ni@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr | 8 ++++----
MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr | 2 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h | 4 ++--
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h | 8 ++++----
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c | 70 +++++++++++++++++++++++++++++++++++-----------------------------------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h | 4 ++--
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c | 30 +++++++++++++++---------------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h | 4 ++--
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt | 92 ++++++++++++++++++++++++++++++++++++++++++++++----------------------------------------------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------------------------------
MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr | 6 +++---
MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr | 4 ++--
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c | 2 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h | 2 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c | 2 +-
15 files changed, 170 insertions(+), 170 deletions(-)

diff --git a/MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr b/MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr
index 26c71a644a9f..aabf47fdf685 100644
--- a/MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr
+++ b/MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr
@@ -1,10 +1,10 @@
///** @file
-//
+//
// Front page formset.
-//
+//
// Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
// SPDX-License-Identifier: BSD-2-Clause-Patent
-//
+//
//**/

#define FORMSET_GUID { 0x9e0c30bc, 0x3f06, 0x4ba6, 0x82, 0x88, 0x9, 0x17, 0x9b, 0x85, 0x5d, 0xbe }
@@ -70,7 +70,7 @@ formset

label LABEL_FRANTPAGE_INFORMATION;
//
- // This is where we will dynamically add a Action type op-code to show
+ // This is where we will dynamically add a Action type op-code to show
// the platform information.
//
label LABEL_END;
diff --git a/MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr b/MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr
index a8ed21740080..d81c580fe71e 100644
--- a/MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr
+++ b/MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr
@@ -4,7 +4,7 @@
//
// Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR>
// SPDX-License-Identifier: BSD-2-Clause-Patent
-//
+//
//**/

#define FORMSET_GUID { 0x3ebfa8e6, 0x511d, 0x4b5b, 0xa9, 0x5f, 0xfb, 0x38, 0x26, 0xf, 0x1c, 0x27 }
diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h
index a5fcb50baea3..ac06278002e3 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h
@@ -245,10 +245,10 @@ typedef struct
{
ILookInStream vt;
const ISeekInStream *realStream;
-
+
size_t pos;
size_t size; /* it's data size */
-
+
/* the following variables must be set outside */
Byte *buf;
size_t bufSize;
diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h
index aba8dce14f19..ecf7b0c44759 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h
@@ -11,23 +11,23 @@ EXTERN_C_BEGIN
/*
These functions convert relative addresses to absolute addresses
in CALL instructions to increase the compression ratio.
-
+
In:
data - data buffer
size - size of data
ip - current virtual Instruction Pinter (IP) value
state - state variable for x86 converter
encoding - 0 (for decoding), 1 (for encoding)
-
+
Out:
state - state variable for x86 converter

Returns:
The number of processed bytes. If you call these functions with multiple calls,
you must start next call with first byte after block of processed bytes.
-
+
Type Endian Alignment LookAhead
-
+
x86 little 1 4
ARMT little 2 2
ARM little 4 0
diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c
index 5128fc9518b8..8765cbebfc9b 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c
@@ -75,7 +75,7 @@ static void MatchFinder_ReadBlock(CMatchFinder *p)
p->streamEndWasReached = 1;
return;
}
-
+
for (;;)
{
Byte *dest = p->buffer + (p->streamPos - p->pos);
@@ -182,24 +182,24 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
ISzAllocPtr alloc)
{
UInt32 sizeReserv;
-
+
if (historySize > kMaxHistorySize)
{
MatchFinder_Free(p, alloc);
return 0;
}
-
+
sizeReserv = historySize >> 1;
if (historySize >= ((UInt32)3 << 30)) sizeReserv = historySize >> 3;
else if (historySize >= ((UInt32)2 << 30)) sizeReserv = historySize >> 2;
-
+
sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);

p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
p->keepSizeAfter = matchMaxLen + keepAddBufferAfter;
-
+
/* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
-
+
if (LzInWindow_Create(p, sizeReserv, alloc))
{
UInt32 newCyclicBufferSize = historySize + 1;
@@ -245,7 +245,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
p->historySize = historySize;
p->hashSizeSum = hs;
p->cyclicBufferSize = newCyclicBufferSize;
-
+
numSons = newCyclicBufferSize;
if (p->btMode)
numSons <<= 1;
@@ -253,11 +253,11 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,

if (p->hash && p->numRefs == newSize)
return 1;
-
+
MatchFinder_FreeThisClassMemory(p, alloc);
p->numRefs = newSize;
p->hash = AllocRefs(newSize, alloc);
-
+
if (p->hash)
{
p->son = p->hash + p->hashSizeSum;
@@ -274,11 +274,11 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
{
UInt32 limit = kMaxValForNormalize - p->pos;
UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
-
+
if (limit2 < limit)
limit = limit2;
limit2 = p->streamPos - p->pos;
-
+
if (limit2 <= p->keepSizeAfter)
{
if (limit2 > 0)
@@ -286,10 +286,10 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
}
else
limit2 -= p->keepSizeAfter;
-
+
if (limit2 < limit)
limit = limit2;
-
+
{
UInt32 lenLimit = p->streamPos - p->pos;
if (lenLimit > p->matchMaxLen)
@@ -328,10 +328,10 @@ void MatchFinder_Init_3(CMatchFinder *p, int readData)
p->streamPos = p->cyclicBufferSize;
p->result = SZ_OK;
p->streamEndWasReached = 0;
-
+
if (readData)
MatchFinder_ReadBlock(p);
-
+
MatchFinder_SetLimits(p);
}

@@ -343,7 +343,7 @@ void MatchFinder_Init(CMatchFinder *p)
MatchFinder_Init_3(p, True);
}

-
+
static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
{
return (p->pos - p->historySize - 1) & kNormalizeMask;
@@ -586,7 +586,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
d2 = pos - hash[h2];

curMatch = (hash + kFix3HashSize)[hv];
-
+
hash[h2] = pos;
(hash + kFix3HashSize)[hv] = pos;

@@ -605,7 +605,7 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
GET_MATCHES_FOOTER(offset, maxLen)
}

@@ -631,14 +631,14 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

maxLen = 0;
offset = 0;
-
+
if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
{
distances[0] = maxLen = 2;
distances[1] = d2 - 1;
offset = 2;
}
-
+
if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
{
maxLen = 3;
@@ -646,7 +646,7 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d3;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -657,10 +657,10 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
if (maxLen < 3)
maxLen = 3;
-
+
GET_MATCHES_FOOTER(offset, maxLen)
}

@@ -712,7 +712,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset = 2;
d2 = d3;
}
-
+
if (d2 != d4 && d4 < p->cyclicBufferSize
&& *(cur - d4) == *cur
&& *(cur - d4 + 3) == *(cur + 3))
@@ -722,7 +722,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d4;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -736,7 +736,7 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

if (maxLen < 4)
maxLen = 4;
-
+
GET_MATCHES_FOOTER(offset, maxLen)
}
*/
@@ -751,10 +751,10 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

hash = p->hash;
pos = p->pos;
-
+
d2 = pos - hash[ h2];
d3 = pos - (hash + kFix3HashSize)[h3];
-
+
curMatch = (hash + kFix4HashSize)[hv];

hash[ h2] = pos;
@@ -770,7 +770,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
distances[1] = d2 - 1;
offset = 2;
}
-
+
if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
{
maxLen = 3;
@@ -778,7 +778,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d3;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -789,7 +789,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
if (maxLen < 3)
maxLen = 3;

@@ -809,7 +809,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)

hash = p->hash;
pos = p->pos;
-
+
d2 = pos - hash[ h2];
d3 = pos - (hash + kFix3HashSize)[h3];
d4 = pos - (hash + kFix4HashSize)[h4];
@@ -846,7 +846,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset = 2;
d2 = d3;
}
-
+
if (d2 != d4 && d4 < p->cyclicBufferSize
&& *(cur - d4) == *cur
&& *(cur - d4 + 3) == *(cur + 3))
@@ -856,7 +856,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
offset += 2;
d2 = d4;
}
-
+
if (offset != 0)
{
UPDATE_maxLen
@@ -867,7 +867,7 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET;
}
}
-
+
if (maxLen < 4)
maxLen = 4;

diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h
index c77added7bd3..61bb9dd302b5 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h
@@ -34,7 +34,7 @@ typedef struct _CMatchFinder

Byte *bufferBase;
ISeqInStream *stream;
-
+
UInt32 blockSize;
UInt32 keepSizeBefore;
UInt32 keepSizeAfter;
@@ -59,7 +59,7 @@ typedef struct _CMatchFinder
((p)->streamEndWasReached \
&& (p)->streamPos == (p)->pos \
&& (!(p)->directInput || (p)->directInputRem == 0))
-
+
int MatchFinder_NeedMove(CMatchFinder *p);
Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
void MatchFinder_MoveBlock(CMatchFinder *p);
diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c
index 6d8c6eb6d95c..a262319928a9 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c
@@ -229,7 +229,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
Byte *dic = p->dic;
SizeT dicBufSize = p->dicBufSize;
SizeT dicPos = p->dicPos;
-
+
UInt32 processedPos = p->processedPos;
UInt32 checkDicSize = p->checkDicSize;
unsigned len = 0;
@@ -305,7 +305,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
dic[dicPos++] = (Byte)symbol;
continue;
}
-
+
{
UPDATE_1(prob);
prob = probs + IsRep + state;
@@ -372,7 +372,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
state = state < kNumLitStates ? 8 : 11;
prob = probs + RepLenCoder;
}
-
+
#ifdef _LZMA_SIZE_OPT
{
unsigned lim, offset;
@@ -476,7 +476,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
{
NORMALIZE
range >>= 1;
-
+
{
UInt32 t;
code -= range;
@@ -512,7 +512,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
}
}
}
-
+
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
@@ -531,13 +531,13 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
SizeT rem;
unsigned curLen;
SizeT pos;
-
+
if ((rem = limit - dicPos) == 0)
{
p->dicPos = dicPos;
return SZ_ERROR_DATA;
}
-
+
curLen = ((rem < len) ? (unsigned)rem : len);
pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);

@@ -570,7 +570,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
while (dicPos < limit && buf < bufLimit);

NORMALIZE;
-
+
p->buf = buf;
p->range = range;
p->code = code;
@@ -640,10 +640,10 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte
}

RINOK(LZMA_DECODE_REAL(p, limit2, bufLimit));
-
+
if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)
p->checkDicSize = p->prop.dicSize;
-
+
LzmaDec_WriteRem(p, limit);
}
while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
@@ -879,7 +879,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
{
SizeT inSize = *srcLen;
(*srcLen) = 0;
-
+
*status = LZMA_STATUS_NOT_SPECIFIED;

if (p->remainLen > kMatchSpecLenStart)
@@ -997,7 +997,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
p->buf = p->tempBuf;
if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
return SZ_ERROR_DATA;
-
+
{
unsigned kkk = (unsigned)(p->buf - p->tempBuf);
if (rem < kkk)
@@ -1013,7 +1013,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
p->tempBufSize = 0;
}
}
-
+
if (p->code != 0)
return SZ_ERROR_DATA;
*status = LZMA_STATUS_FINISHED_WITH_MARK;
@@ -1083,12 +1083,12 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
{
UInt32 dicSize;
Byte d;
-
+
if (size < LZMA_PROPS_SIZE)
return SZ_ERROR_UNSUPPORTED;
else
dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
-
+
if (dicSize < LZMA_DIC_MIN)
dicSize = LZMA_DIC_MIN;
p->dicSize = dicSize;
diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h
index 28ce60c3ea94..ebc568cb4ff4 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h
@@ -135,7 +135,7 @@ LzmaDec_Allocate* can return:
SZ_ERROR_MEM - Memory allocation error
SZ_ERROR_UNSUPPORTED - Unsupported properties
*/
-
+
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc);
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAllocPtr alloc);

@@ -164,7 +164,7 @@ void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc);
*/

/* LzmaDec_DecodeToDic
-
+
The decoding to internal dictionary buffer (CLzmaDec::dic).
You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!

diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt
index f4793264a51d..5ad9a5b1b94d 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt
@@ -3,11 +3,11 @@ HISTORY of the LZMA SDK

18.05 2018-04-30
-------------------------
-- The speed for LZMA/LZMA2 compressing was increased
- by 8% for fastest/fast compression levels and
+- The speed for LZMA/LZMA2 compressing was increased
+ by 8% for fastest/fast compression levels and
by 3% for normal/maximum compression levels.
- Previous versions of 7-Zip could work incorrectly in "Large memory pages" mode in
- Windows 10 because of some BUG with "Large Pages" in Windows 10.
+ Windows 10 because of some BUG with "Large Pages" in Windows 10.
Now 7-Zip doesn't use "Large Pages" on Windows 10 up to revision 1709 (16299).
- The BUG was fixed in Lzma2Enc.c
Lzma2Enc_Encode2() function worked incorretly,
@@ -16,7 +16,7 @@ HISTORY of the LZMA SDK

18.03 beta 2018-03-04
-------------------------
-- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
+- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
for x64 with about 30% higher speed than main version of LZMA decoder written in C.
- The speed for single-thread LZMA/LZMA2 decoder written in C was increased by 3%.
- 7-Zip now can use multi-threading for 7z/LZMA2 decoding,
@@ -35,7 +35,7 @@ HISTORY of the LZMA SDK
18.00 beta 2019-01-10
-------------------------
- The BUG in xz encoder was fixed:
- There was memory leak of 16 KB for each file compressed with
+ There was memory leak of 16 KB for each file compressed with
xz compression method, if additional filter was used.


@@ -44,7 +44,7 @@ HISTORY of the LZMA SDK
- Minor speed optimization for LZMA2 (xz and 7z) multi-threading compression.
7-Zip now uses additional memory buffers for multi-block LZMA2 compression.
CPU utilization was slightly improved.
-- 7-zip now creates multi-block xz archives by default. Block size can be
+- 7-zip now creates multi-block xz archives by default. Block size can be
specified with -ms[Size]{m|g} switch.
- xz decoder now can unpack random block from multi-block xz archives.
- 7-Zip command line: @listfile now doesn't work after -- switch.
@@ -55,7 +55,7 @@ HISTORY of the LZMA SDK

17.00 beta 2017-04-29
-------------------------
-- NewHandler.h / NewHandler.cpp:
+- NewHandler.h / NewHandler.cpp:
now it redefines operator new() only for old MSVC compilers (_MSC_VER < 1900).
- C/7zTypes.h : the names of variables in interface structures were changed (vt).
- Some bugs were fixed. 7-Zip could crash in some cases.
@@ -76,51 +76,51 @@ HISTORY of the LZMA SDK
16.02 2016-05-21
-------------------------
- The BUG in 16.00 - 16.01 was fixed:
- Split Handler (SplitHandler.cpp) returned incorrect
+ Split Handler (SplitHandler.cpp) returned incorrect
total size value (kpidSize) for split archives.


16.01 2016-05-19
--------------------------
+-------------------------
- Some internal changes to reduce the number of compiler warnings.


16.00 2016-05-10
--------------------------
+-------------------------
- Some bugs were fixed.


15.12 2015-11-19
--------------------------
+-------------------------
- The BUG in C version of 7z decoder was fixed:
7zDec.c : SzDecodeLzma2()
7z decoder could mistakenly report about decoding error for some 7z archives
that use LZMA2 compression method.
- The probability to get that mistaken decoding error report was about
- one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
+ The probability to get that mistaken decoding error report was about
+ one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
- The BUG (in 9.26-15.11) in C version of 7z decoder was fixed:
7zArcIn.c : SzReadHeader2()
- 7z decoder worked incorrectly for 7z archives that contain
- empty solid blocks, that can be placed to 7z archive, if some file is
+ 7z decoder worked incorrectly for 7z archives that contain
+ empty solid blocks, that can be placed to 7z archive, if some file is
unavailable for reading during archive creation.


15.09 beta 2015-10-16
--------------------------
+-------------------------
- The BUG in LZMA / LZMA2 encoding code was fixed.
The BUG in LzFind.c::MatchFinder_ReadBlock() function.
If input data size is larger than (4 GiB - dictionary_size),
the following code worked incorrectly:
- - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
- for compressing from memory to memory.
+ - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
+ for compressing from memory to memory.
That BUG is not related to LZMA encoder version that works via streams.
- - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
- default value of chunk size (CLzma2EncProps::blockSize) is changed
+ - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
+ default value of chunk size (CLzma2EncProps::blockSize) is changed
to value larger than (4 GiB - dictionary_size).


9.38 beta 2015-01-03
--------------------------
+-------------------------
- The BUG in 9.31-9.37 was fixed:
IArchiveGetRawProps interface was disabled for 7z archives.
- The BUG in 9.26-9.36 was fixed:
@@ -128,10 +128,10 @@ HISTORY of the LZMA SDK


9.36 beta 2014-12-26
--------------------------
+-------------------------
- The BUG in command line version was fixed:
7-Zip created temporary archive in current folder during update archive
- operation, if -w{Path} switch was not specified.
+ operation, if -w{Path} switch was not specified.
The fixed 7-Zip creates temporary archive in folder that contains updated archive.
- The BUG in 9.33-9.35 was fixed:
7-Zip silently ignored file reading errors during 7z or gz archive creation,
@@ -140,14 +140,14 @@ HISTORY of the LZMA SDK


9.35 beta 2014-12-07
--------------------------
+-------------------------
- 7zr.exe now support AES encryption.
- SFX mudules were added to LZMA SDK
- Some bugs were fixed.


9.21 beta 2011-04-11
--------------------------
+-------------------------
- New class FString for file names at file systems.
- Speed optimization in CRC code for big-endian CPUs.
- The BUG in Lzma2Dec.c was fixed:
@@ -155,7 +155,7 @@ HISTORY of the LZMA SDK


9.18 beta 2010-11-02
--------------------------
+-------------------------
- New small SFX module for installers (SfxSetup).


@@ -168,7 +168,7 @@ HISTORY of the LZMA SDK
9.11 beta 2010-03-15
-------------------------
- PPMd compression method support
-
+

9.09 2009-12-12
-------------------------
@@ -202,7 +202,7 @@ HISTORY of the LZMA SDK
4.61 beta 2008-11-23
-------------------------
- The bug in ANSI-C LZMA Decoder was fixed:
- If encoded stream was corrupted, decoder could access memory
+ If encoded stream was corrupted, decoder could access memory
outside of allocated range.
- Some changes in ANSI-C 7z Decoder interfaces.
- LZMA SDK is placed in the public domain.
@@ -216,7 +216,7 @@ HISTORY of the LZMA SDK
4.59 beta 2008-08-13
-------------------------
- The bug was fixed:
- LZMA Encoder in fast compression mode could access memory outside of
+ LZMA Encoder in fast compression mode could access memory outside of
allocated range in some rare cases.


@@ -229,7 +229,7 @@ HISTORY of the LZMA SDK

4.57 2007-12-12
-------------------------
-- Speed optimizations in ?++ LZMA Decoder.
+- Speed optimizations in ?++ LZMA Decoder.
- Small changes for more compatibility with some C/C++ compilers.


@@ -239,36 +239,36 @@ HISTORY of the LZMA SDK
- now it supports BCJ and BCJ2 filters
- now it supports files larger than 4 GB.
- now it supports "Last Write Time" field for files.
-- C++ code for .7z archives compressing/decompressing from 7-zip
+- C++ code for .7z archives compressing/decompressing from 7-zip
was included to LZMA SDK.
-
+

4.43 2006-06-04
-------------------------
- Small changes for more compatibility with some C/C++ compilers.
-
+

4.42 2006-05-15
-------------------------
- Small changes in .h files in ANSI-C version.
-
+

4.39 beta 2006-04-14
-------------------------
- The bug in versions 4.33b:4.38b was fixed:
- C++ version of LZMA encoder could not correctly compress
+ C++ version of LZMA encoder could not correctly compress
files larger than 2 GB with HC4 match finder (-mfhc4).
-
+

4.37 beta 2005-04-06
-------------------------
-- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.
+- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.


4.35 beta 2005-03-02
-------------------------
- The bug was fixed in C++ version of LZMA Decoder:
- If encoded stream was corrupted, decoder could access memory
+ If encoded stream was corrupted, decoder could access memory
outside of allocated range.


@@ -339,7 +339,7 @@ HISTORY of the LZMA SDK

4.17 2005-04-18
-------------------------
-- New example for RAM->RAM compressing/decompressing:
+- New example for RAM->RAM compressing/decompressing:
LZMA + BCJ (filter for x86 code):
- LzmaRam.h
- LzmaRam.cpp
@@ -350,11 +350,11 @@ HISTORY of the LZMA SDK

4.16 2005-03-29
-------------------------
-- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
+- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
If _LZMA_OUT_READ was defined, and if encoded stream was corrupted,
decoder could access memory outside of allocated range.
- Speed optimization of ANSI-C LZMA Decoder (now it's about 20% faster).
- Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
+ Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
LzmaDecodeSize.c can provide slightly smaller code than LzmaDecode.c
- Small speed optimization in LZMA C++ code
- filter for SPARC's code was added
@@ -369,7 +369,7 @@ HISTORY of the LZMA SDK

4.05 2004-08-25
-------------------------
-- Source code of filters for x86, IA-64, ARM, ARM-Thumb
+- Source code of filters for x86, IA-64, ARM, ARM-Thumb
and PowerPC code was included to SDK
- Some internal minor changes

@@ -381,8 +381,8 @@ HISTORY of the LZMA SDK

4.03 2004-06-18
-------------------------
-- "Benchmark" command was added. It measures compressing
- and decompressing speed and shows rating values.
+- "Benchmark" command was added. It measures compressing
+ and decompressing speed and shows rating values.
Also it checks hardware errors.


@@ -411,7 +411,7 @@ HISTORY of the LZMA SDK

HISTORY of the LZMA
-------------------
- 2001-2008: Improvements to LZMA compressing/decompressing code,
+ 2001-2008: Improvements to LZMA compressing/decompressing code,
keeping compatibility with original LZMA format
1996-2001: Development of LZMA compression format

@@ -419,6 +419,6 @@ HISTORY of the LZMA

2001-08-30: LZMA compression was added to 7-Zip
1999-01-02: First version of 7-Zip was released
-
+

End of document
diff --git a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt
index 01521e939887..bf0b3a5ee62d 100644
--- a/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt
+++ b/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt
@@ -2,15 +2,15 @@ LZMA SDK 18.05
--------------

LZMA SDK provides the documentation, samples, header files,
-libraries, and tools you need to develop applications that
+libraries, and tools you need to develop applications that
use 7z / LZMA / LZMA2 / XZ compression.

-LZMA is an improved version of famous LZ77 compression algorithm.
+LZMA is an improved version of famous LZ77 compression algorithm.
It was improved in way of maximum increasing of compression ratio,
-keeping high decompression speed and low memory requirements for
+keeping high decompression speed and low memory requirements for
decompressing.

-LZMA2 is a LZMA based compression method. LZMA2 provides better
+LZMA2 is a LZMA based compression method. LZMA2 provides better
multithreading support for compression than LZMA and some other improvements.

7z is a file format for data compression and file archiving.
@@ -19,7 +19,7 @@ multithreading support for compression than LZMA and some other improvements.
7z also supports AES-256 based encryption.

XZ is a file format for data compression that uses LZMA2 compression.
-XZ format provides additional features: SHA/CRC check, filters for
+XZ format provides additional features: SHA/CRC check, filters for
improved compression ratio, splitting to blocks and streams,


@@ -33,11 +33,11 @@ Some code in LZMA SDK is based on public domain code from another developers:
1) PPMd var.H (2001): Dmitry Shkarin
2) SHA-256: Wei Dai (Crypto++ library)

-Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
-original LZMA SDK code, either in source code form or as a compiled binary, for
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
+original LZMA SDK code, either in source code form or as a compiled binary, for
any purpose, commercial or non-commercial, and by any means.

-LZMA SDK code is compatible with open source licenses, for example, you can
+LZMA SDK code is compatible with open source licenses, for example, you can
include it to GNU GPL or GNU LGPL code.


@@ -60,7 +60,7 @@ LZMA SDK Contents
- SFX modules for installers.


-UNIX/Linux version
+UNIX/Linux version
------------------
To compile C++ version of file->file LZMA encoding, go to directory
CPP/7zip/Bundles/LzmaCon
@@ -68,11 +68,11 @@ and call make to recompile it:
make -f makefile.gcc clean all

In some UNIX/Linux versions you must compile LZMA with static libraries.
-To compile with static libraries, you can use
+To compile with static libraries, you can use
LIB = -lm -static

Also you can use p7zip (port of 7-Zip for POSIX systems like Unix or Linux):
-
+
http://p7zip.sourceforge.net/


@@ -120,7 +120,7 @@ C/ - C files (compression / decompression and other)
7z - 7z decoder program (decoding 7z files)
Lzma - LZMA program (file->file LZMA encoder/decoder).
LzmaLib - LZMA library (.DLL for Windows)
- SfxSetup - small SFX module for installers
+ SfxSetup - small SFX module for installers

CPP/ -- CPP files

@@ -135,7 +135,7 @@ CPP/ -- CPP files
7z - 7z C++ Encoder/Decoder

Bundles - Modules that are bundles of other modules (files)
-
+
Alone7z - 7zr.exe: Standalone 7-Zip console program (reduced version)
Format7zExtractR - 7zxr.dll: Reduced version of 7z DLL: extracting from 7z/LZMA/BCJ/BCJ2.
Format7zR - 7zr.dll: Reduced version of 7z DLL: extracting/compressing to 7z/LZMA/BCJ/BCJ2
@@ -152,7 +152,7 @@ CPP/ -- CPP files
Crypto - files for encryption / decompression

UI - User Interface files
-
+
Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll
Common - Common UI files
Console - Code for console program (7z.exe)
@@ -178,7 +178,7 @@ Java/ - Java files
RangeCoder - Range Coder (special code of compression/decompression)


-Note:
+Note:
Asm / C / C++ source code of LZMA SDK is part of 7-Zip's source code.
7-Zip's source code can be downloaded from 7-Zip's SourceForge page:

@@ -190,13 +190,13 @@ LZMA features
-------------
- Variable dictionary size (up to 1 GB)
- Estimated compressing speed: about 2 MB/s on 2 GHz CPU
- - Estimated decompressing speed:
+ - Estimated decompressing speed:
- 20-30 MB/s on modern 2 GHz cpu
- 1-2 MB/s on 200 MHz simple RISC cpu: (ARM, MIPS, PowerPC)
- Small memory requirements for decompressing (16 KB + DictionarySize)
- Small code size for decompressing: 5-8 KB

-LZMA decoder uses only integer operations and can be
+LZMA decoder uses only integer operations and can be
implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).

Some critical operations that affect the speed of LZMA decompression:
@@ -205,7 +205,7 @@ Some critical operations that affect the speed of LZMA decompression:
3) 32-bit shift and arithmetic operations

The speed of LZMA decompressing mostly depends from CPU speed.
-Memory speed has no big meaning. But if your CPU has small data cache,
+Memory speed has no big meaning. But if your CPU has small data cache,
overall weight of memory speed will slightly increase.


@@ -221,53 +221,53 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]

d: decode file

- b: Benchmark. There are two tests: compressing and decompressing
- with LZMA method. Benchmark shows rating in MIPS (million
- instructions per second). Rating value is calculated from
+ b: Benchmark. There are two tests: compressing and decompressing
+ with LZMA method. Benchmark shows rating in MIPS (million
+ instructions per second). Rating value is calculated from
measured speed and it is normalized with Intel's Core 2 results.
- Also Benchmark checks possible hardware errors (RAM
+ Also Benchmark checks possible hardware errors (RAM
errors in most cases). Benchmark uses these settings:
- (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
+ (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
Also you can change the number of iterations. Example for 30 iterations:
LZMA b 30
Default number of iterations is 10.

<Switches>
-
+

-a{N}: set compression mode 0 = fast, 1 = normal
default: 1 (normal)

d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB)
The maximum value for dictionary size is 1 GB = 2^30 bytes.
- Dictionary size is calculated as DictionarySize = 2^N bytes.
- For decompressing file compressed by LZMA method with dictionary
+ Dictionary size is calculated as DictionarySize = 2^N bytes.
+ For decompressing file compressed by LZMA method with dictionary
size D = 2^N you need about D bytes of memory (RAM).

-fb{N}: set number of fast bytes - [5, 273], default: 128
- Usually big number gives a little bit better compression ratio
+ Usually big number gives a little bit better compression ratio
and slower compression process.

-lc{N}: set number of literal context bits - [0, 8], default: 3
Sometimes lc=4 gives gain for big files.

-lp{N}: set number of literal pos bits - [0, 4], default: 0
- lp switch is intended for periodical data when period is
- equal 2^N. For example, for 32-bit (4 bytes)
- periodical data you can use lp=2. Often it's better to set lc0,
+ lp switch is intended for periodical data when period is
+ equal 2^N. For example, for 32-bit (4 bytes)
+ periodical data you can use lp=2. Often it's better to set lc0,
if you change lp switch.

-pb{N}: set number of pos bits - [0, 4], default: 2
- pb switch is intended for periodical data
+ pb switch is intended for periodical data
when period is equal 2^N.

- -mf{MF_ID}: set Match Finder. Default: bt4.
- Algorithms from hc* group doesn't provide good compression
- ratio, but they often works pretty fast in combination with
+ -mf{MF_ID}: set Match Finder. Default: bt4.
+ Algorithms from hc* group doesn't provide good compression
+ ratio, but they often works pretty fast in combination with
fast mode (-a0).

- Memory requirements depend from dictionary size
- (parameter "d" in table below).
+ Memory requirements depend from dictionary size
+ (parameter "d" in table below).

MF_ID Memory Description

@@ -276,8 +276,8 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]
bt4 d * 11.5 + 4MB Binary Tree with 4 bytes hashing.
hc4 d * 7.5 + 4MB Hash Chain with 4 bytes hashing.

- -eos: write End Of Stream marker. By default LZMA doesn't write
- eos marker, since LZMA decoder knows uncompressed size
+ -eos: write End Of Stream marker. By default LZMA doesn't write
+ eos marker, since LZMA decoder knows uncompressed size
stored in .lzma file header.

-si: Read data from stdin (it will write End Of Stream marker).
@@ -286,16 +286,16 @@ Usage: LZMA <e|d> inputFile outputFile [<switches>...]

Examples:

-1) LZMA e file.bin file.lzma -d16 -lc0
+1) LZMA e file.bin file.lzma -d16 -lc0

-compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
-and 0 literal context bits. -lc0 allows to reduce memory requirements
+compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
+and 0 literal context bits. -lc0 allows to reduce memory requirements
for decompression.


2) LZMA e file.bin file.lzma -lc0 -lp2

-compresses file.bin to file.lzma with settings suitable
+compresses file.bin to file.lzma with settings suitable
for 32-bit periodical data (for example, ARM or MIPS code).

3) LZMA d file.lzma file.bin
@@ -309,9 +309,9 @@ Compression ratio hints
Recommendations
---------------

-To increase the compression ratio for LZMA compressing it's desirable
+To increase the compression ratio for LZMA compressing it's desirable
to have aligned data (if it's possible) and also it's desirable to locate
-data in such order, where code is grouped in one place and data is
+data in such order, where code is grouped in one place and data is
grouped in other place (it's better than such mixing: code, data, code,
data, ...).

@@ -319,19 +319,19 @@ data, ...).
Filters
-------
You can increase the compression ratio for some data types, using
-special filters before compressing. For example, it's possible to
-increase the compression ratio on 5-10% for code for those CPU ISAs:
+special filters before compressing. For example, it's possible to
+increase the compression ratio on 5-10% for code for those CPU ISAs:
x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.

You can find C source code of such filters in C/Bra*.* files

-You can check the compression ratio gain of these filters with such
+You can check the compression ratio gain of these filters with such
7-Zip commands (example for ARM code):
No filter:
7z a a1.7z a.bin -m0=lzma

With filter for little-endian ARM code:
- 7z a a2.7z a.bin -m0=arm -m1=lzma
+ 7z a a2.7z a.bin -m0=arm -m1=lzma

It works in such manner:
Compressing = Filter_encoding + LZMA_encoding
@@ -339,11 +339,11 @@ Decompressing = LZMA_decoding + Filter_decoding

Compressing and decompressing speed of such filters is very high,
so it will not increase decompressing time too much.
-Moreover, it reduces decompression time for LZMA_decoding,
+Moreover, it reduces decompression time for LZMA_decoding,
since compression ratio with filtering is higher.

-These filters convert CALL (calling procedure) instructions
-from relative offsets to absolute addresses, so such data becomes more
+These filters convert CALL (calling procedure) instructions
+from relative offsets to absolute addresses, so such data becomes more
compressible.

For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
diff --git a/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr b/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr
index 8025cb107540..9fc7ed34e97c 100644
--- a/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr
+++ b/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr
@@ -1,8 +1,8 @@
///** @file
-//
+//
// VFR to produce the formset used by BDS. This form only lists
// the Configure Required driver health instances.
-//
+//
// Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR>
// SPDX-License-Identifier: BSD-2-Clause-Patent

@@ -20,7 +20,7 @@ formset

label LABEL_BEGIN;
label LABEL_END;
-
+
suppressif TRUE;
text
help = STRING_TOKEN(STR_NULL),
diff --git a/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr b/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr
index b84d8d649869..4c19bfcba97e 100644
--- a/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr
+++ b/MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr
@@ -1,7 +1,7 @@
///** @file
-//
+//
// VFR to produce the formset used by UI.
-//
+//
// Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR>
// SPDX-License-Identifier: BSD-2-Clause-Patent
//**/
diff --git a/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c b/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c
index b6a58c6a5637..376fcabd760c 100644
--- a/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c
+++ b/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c
@@ -1,5 +1,5 @@
/** @file
-
+
Module to rewrite stdlib references within Oniguruma

(C) Copyright 2014-2015 Hewlett Packard Enterprise Development LP<BR>
diff --git a/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h b/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h
index fb53cbf98066..299f414fd624 100644
--- a/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h
+++ b/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h
@@ -1,5 +1,5 @@
/** @file
-
+
Module to rewrite stdlib references within Oniguruma

(C) Copyright 2014-2015 Hewlett Packard Enterprise Development LP<BR>
diff --git a/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c b/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c
index 5ce859b39b95..6a7890910781 100644
--- a/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c
+++ b/MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c
@@ -375,7 +375,7 @@ print_compiled_byte_code(FILE* f, regex_t* reg, int index,
case OP_CCLASS_MB_NOT:
{
OnigCodePoint ncode;
- OnigCodePoint* codes;
+ OnigCodePoint* codes;

codes = (OnigCodePoint* )p->cclass_mb.mb;
GET_CODE_POINT(ncode, codes);
--
2.20.1


[PATCH 4/7] EmulatorPkg: strip trailing whitespace

Leif Lindholm
 

Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Andrew Fish <afish@apple.com>
Cc: Ray Ni <ray.ni@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
EmulatorPkg/Readme.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/EmulatorPkg/Readme.md b/EmulatorPkg/Readme.md
index 5ea61ca7ab5a..0c2eea6a9a02 100644
--- a/EmulatorPkg/Readme.md
+++ b/EmulatorPkg/Readme.md
@@ -57,12 +57,12 @@ emulator.**

For example, to build + run:

-`$ EmulatorPkg/build.sh`
+`$ EmulatorPkg/build.sh`
`$ EmulatorPkg/build.sh run`

The build architecture will match your host machine's architecture.

On X64 host machines, you can build + run IA32 mode as well:

-`$ EmulatorPkg/build.sh -a IA32`
+`$ EmulatorPkg/build.sh -a IA32`
`$ EmulatorPkg/build.sh -a IA32 run`
--
2.20.1


[PATCH 2/7] ArmPlatformPkg: strip trailing whitespace

Leif Lindholm
 

Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
ArmPlatformPkg/Scripts/Ds5/profile.py | 2 +-
ArmPlatformPkg/Scripts/Makefile | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/ArmPlatformPkg/Scripts/Ds5/profile.py b/ArmPlatformPkg/Scripts/Ds5/profile.py
index 8f74cf2a8bdf..f87dee24695c 100644
--- a/ArmPlatformPkg/Scripts/Ds5/profile.py
+++ b/ArmPlatformPkg/Scripts/Ds5/profile.py
@@ -321,7 +321,7 @@ for (key,value) in sorted_functions_cycles[:20]:
else:
break;
print "----"
-for (key,value) in sorted_all_functions_cycles[:20]:
+for (key,value) in sorted_all_functions_cycles[:20]:
if value[0] != 0:
print "%s (cycles: %d - %d%%, count: %d)" % (key, value[0], (value[0] * 100) / total_cycles, value[1])
else:
diff --git a/ArmPlatformPkg/Scripts/Makefile b/ArmPlatformPkg/Scripts/Makefile
index 09f1c9092328..da949dc1ed56 100644
--- a/ArmPlatformPkg/Scripts/Makefile
+++ b/ArmPlatformPkg/Scripts/Makefile
@@ -1,6 +1,6 @@
#/* @file
# Copyright (c) 2011-2015, ARM Limited. All rights reserved.
-#
+#
# SPDX-License-Identifier: BSD-2-Clause-Patent
#
#*/
--
2.20.1


[PATCH 1/7] ArmPkg: strip trailing whitespace

Leif Lindholm
 

Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf b/ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf
index f4fecbb4098a..5028a955afac 100644
--- a/ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf
+++ b/ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf
@@ -22,8 +22,8 @@ [Sources.AARCH64]

[Sources.ARM]
Arm/ArmMmuLibCore.c
- Arm/ArmMmuLibV7Support.S |GCC
- Arm/ArmMmuLibV7Support.asm |RVCT
+ Arm/ArmMmuLibV7Support.S |GCC
+ Arm/ArmMmuLibV7Support.asm |RVCT

[Packages]
ArmPkg/ArmPkg.dec
--
2.20.1


[PATCH 0/7] Strip trailing whitespace

Leif Lindholm
 

*cough* 5-6/7 do take a bit of a shotgun approach with the Cc:s, but I
would prefer not breaking the set up any more than it already is.
The changes are however trivial, so hopefully not much of an issue.

Before we start looking into migrating the repository to native
line endings, let's start by killing off a bunch of trailing
whitespace.

This is basically the output of:
for filetype in '*.c' '*.h' '*.s' '*.S' '*.asm' '*.py' '*.inf' '*.inc' '*.d=
sc' '*.fdf' '*.dec' '*.uni' '*.txt' '*.md' '*.nasm' '*.vfr' '*.asl' '*.aslc=
' '*.asm16' '*makefile' '*.common' '*.cpp'; do find * -type f -iname "$file=
type" -exec sed --in-place 's/[[:blank:]]\+\(\r*\)$/\1/' {} \;; done
executed in the top-level directory.

This does mess about with some imported projects, but I figure if
we keep them in the tree, we might as well clean it up.

Since we have some weird and wonderful file types in the tree, I think we c=
an
only realy ever run automated fixups on a "whitelist" of file types. Please
let me know if I have left any important ones out from this operation.

(Why yes, that .S _is_ totally redundant given the use of -iname, but at le=
ast I'm being honest.)

These patches, as well as the preceding line ending and character
encoding cleanup can also be accessed at:
https://git.linaro.org/people/leif.lindholm/edk2.git/log/?h=3Dpre-CRLF2LF-c=
leanup

Leif Lindholm (7):
ArmPkg: strip trailing whitespace
ArmPlatformPkg: strip trailing whitespace
BaseTools: strip trailing whitespace
EmulatorPkg: strip trailing whitespace
MdeModulePkg: strip trailing whitespace
OvmfPkg: strip trailing whitespace
UefiCpuPkg: strip trailing whitespace

ArmPkg/Library/ArmMmuLib/ArmMmuBaseLib.inf =
| 4 +-
ArmPlatformPkg/Scripts/Ds5/profile.py =
| 2 +-
ArmPlatformPkg/Scripts/Makefile =
| 2 +-
BaseTools/Source/C/BrotliCompress/tools/brotli.c =
| 2 +-
BaseTools/Source/C/GNUmakefile =
| 2 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/7zFile.c =
| 20 ++---
BaseTools/Source/C/LzmaCompress/Sdk/C/7zTypes.h =
| 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/Alloc.c =
| 22 ++---
BaseTools/Source/C/LzmaCompress/Sdk/C/Bra.h =
| 8 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.c =
| 70 ++++++++--------
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFind.h =
| 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.c =
| 40 ++++-----
BaseTools/Source/C/LzmaCompress/Sdk/C/LzFindMt.h =
| 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.c =
| 30 +++----
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaDec.h =
| 4 +-
BaseTools/Source/C/LzmaCompress/Sdk/C/LzmaEnc.c =
| 194 ++++++++++++++++++++++----------------------
BaseTools/Source/C/LzmaCompress/Sdk/C/Threads.c =
| 6 +-
BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-history.txt =
| 92 ++++++++++-----------
BaseTools/Source/C/LzmaCompress/Sdk/DOC/lzma-sdk.txt =
| 102 +++++++++++------------
BaseTools/Source/C/Makefiles/app.makefile =
| 4 +-
BaseTools/Source/C/Makefiles/footer.makefile =
| 4 +-
BaseTools/Source/C/Makefiles/header.makefile =
| 8 +-
BaseTools/Source/C/Makefiles/lib.makefile =
| 2 +-
BaseTools/Source/C/Makefiles/ms.common =
| 4 +-
BaseTools/Source/C/VfrCompile/GNUmakefile =
| 6 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_131.txt =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133.txt =
| 286 ++++++++++++++++++++++++++++++++---------------------------------
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_FROM_133_BEFORE_MR13.txt =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/CHANGES_SUMMARY.txt =
| 6 +-
BaseTools/Source/C/VfrCompile/Pccts/KNOWN_PROBLEMS.txt =
| 20 ++---
BaseTools/Source/C/VfrCompile/Pccts/antlr/antlr.c =
| 194 ++++++++++++++++++++++----------------------
BaseTools/Source/C/VfrCompile/Pccts/antlr/bits.c =
| 10 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/build.c =
| 18 ++---
BaseTools/Source/C/VfrCompile/Pccts/antlr/dumpcycles.c =
| 8 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/egman.c =
| 12 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/fcache.c =
| 8 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/fset.c =
| 16 ++--
BaseTools/Source/C/VfrCompile/Pccts/antlr/fset2.c =
| 16 ++--
BaseTools/Source/C/VfrCompile/Pccts/antlr/gen.c =
| 78 +++++++++---------
BaseTools/Source/C/VfrCompile/Pccts/antlr/generic.h =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/hash.c =
| 10 +--
BaseTools/Source/C/VfrCompile/Pccts/antlr/lex.c =
| 6 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/main.c =
| 40 ++++-----
BaseTools/Source/C/VfrCompile/Pccts/antlr/makefile =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/misc.c =
| 42 +++++-----
BaseTools/Source/C/VfrCompile/Pccts/antlr/mrhoist.c =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/pred.c =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/antlr/scan.c =
| 4072 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
++++++++++++++++-----------------------------------------------------------=
---------------------------------------------------------------------------=
---------------------------------------------------------------------------=
---------------------------------------------------------------------------=
---------------------------------------------------------------------------=
---------------------------------------------------------------------------=
------------------------
BaseTools/Source/C/VfrCompile/Pccts/dlg/automata.c =
| 10 +--
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg.h =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_a.c =
| 950 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
++++++++++++++++++++++++++++++++++++++++-----------------------------------=
------------------------------------------------------------------------
BaseTools/Source/C/VfrCompile/Pccts/dlg/dlg_p.c =
| 30 +++----
BaseTools/Source/C/VfrCompile/Pccts/dlg/main.c =
| 10 +--
BaseTools/Source/C/VfrCompile/Pccts/dlg/makefile =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/output.c =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/relabel.c =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/dlg/support.c =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/h/AParser.cpp =
| 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/AParser.h =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/h/ASTBase.cpp =
| 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/ATokenBuffer.cpp =
| 6 +-
BaseTools/Source/C/VfrCompile/Pccts/h/DLG_stream_input.h =
| 22 ++---
BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp =
| 2 +-
BaseTools/Source/C/VfrCompile/Pccts/h/PBlackBox.h =
| 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/PCCTSAST.cpp =
| 8 +-
BaseTools/Source/C/VfrCompile/Pccts/h/antlr.h =
| 10 +--
BaseTools/Source/C/VfrCompile/Pccts/h/ast.c =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/h/err.h =
| 70 ++++++++--------
BaseTools/Source/C/VfrCompile/Pccts/history.txt =
| 6 +-
BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk.c =
| 14 ++--
BaseTools/Source/C/VfrCompile/Pccts/support/genmk/genmk_old.c =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/support/rexpr/rexpr.c =
| 46 +++++------
BaseTools/Source/C/VfrCompile/Pccts/support/set/set.c =
| 46 +++++------
BaseTools/Source/C/VfrCompile/Pccts/support/set/set.h =
| 4 +-
BaseTools/Source/C/VfrCompile/Pccts/support/sym/sym.c =
| 26 +++---
BaseTools/Source/Python/Ecc/Check.py =
| 2 +-
BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py =
| 2 +-
BaseTools/Source/Python/Makefile =
| 2 +-
EmulatorPkg/Readme.md =
| 4 +-
MdeModulePkg/Application/UiApp/FrontPageVfr.Vfr =
| 8 +-
MdeModulePkg/Library/DeviceManagerUiLib/DeviceManagerVfr.Vfr =
| 2 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/7zTypes.h =
| 4 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h =
| 8 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c =
| 70 ++++++++--------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.h =
| 4 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c =
| 30 +++----
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h =
| 4 +-
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-history.txt =
| 92 ++++++++++-----------
MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/DOC/lzma-sdk.txt =
| 102 +++++++++++------------
MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthConfigureVfr.Vfr=
| 6 +-
MdeModulePkg/Universal/DriverHealthManagerDxe/DriverHealthManagerVfr.Vfr =
| 4 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.c =
| 2 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/OnigurumaUefiPort.h =
| 2 +-
MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/regexec.c =
| 2 +-
OvmfPkg/AcpiPlatformDxe/AcpiPlatform.c =
| 4 +-
OvmfPkg/AcpiPlatformDxe/Xen.c =
| 8 +-
OvmfPkg/AcpiTables/Facs.aslc =
| 6 +-
OvmfPkg/Csm/LegacyBootMaintUiLib/LegacyBootMaintUiVfr.Vfr =
| 18 ++---
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_32.h =
| 4 +-
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen-x86_64.h =
| 4 +-
OvmfPkg/Include/IndustryStandard/Xen/arch-x86/xen.h =
| 4 +-
OvmfPkg/Include/IndustryStandard/Xen/hvm/params.h =
| 2 +-
OvmfPkg/Include/IndustryStandard/Xen/io/protocols.h =
| 2 +-
OvmfPkg/Include/IndustryStandard/Xen/io/ring.h =
| 34 ++++----
OvmfPkg/Include/IndustryStandard/Xen/memory.h =
| 4 +-
OvmfPkg/Include/IndustryStandard/Xen/xen-compat.h =
| 4 +-
OvmfPkg/Include/IndustryStandard/Xen/xen.h =
| 10 +--
OvmfPkg/Include/Register/QemuSmramSaveStateMap.h =
| 2 +-
OvmfPkg/Library/DxePciLibI440FxQ35/PciLib.c =
| 12 +--
OvmfPkg/Library/LockBoxLib/LockBoxDxe.c =
| 2 +-
OvmfPkg/Library/LockBoxLib/LockBoxLib.c =
| 2 +-
OvmfPkg/Library/LockBoxLib/LockBoxLib.h =
| 2 +-
OvmfPkg/Library/PlatformSecureLib/PlatformSecureLib.c =
| 4 +-
OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c =
| 2 +-
OvmfPkg/Library/XenIoMmioLib/XenIoMmioLib.c =
| 2 +-
OvmfPkg/PlatformPei/Xen.c =
| 2 +-
OvmfPkg/SataControllerDxe/ComponentName.c =
| 6 +-
OvmfPkg/SataControllerDxe/SataController.c =
| 214 ++++++++++++++++++++++++-------------------------
OvmfPkg/SataControllerDxe/SataController.h =
| 208 +++++++++++++++++++++++------------------------
OvmfPkg/SataControllerDxe/SataControllerDxe.inf =
| 6 +-
OvmfPkg/Sec/SecMain.c =
| 34 ++++----
UefiCpuPkg/Application/Cpuid/Cpuid.c =
| 2 +-
122 files changed, 3882 insertions(+), 3882 deletions(-)

Cc: Andrew Fish <afish@apple.com>
Cc: Anthony Perard <anthony.perard@citrix.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Bob Feng <bob.c.feng@intel.com>
Cc: Dandan Bi <dandan.bi@intel.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Hao A Wu <hao.a.wu@intel.com>
Cc: Jian J Wang <jian.j.wang@intel.com>
Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Julien Grall <julien.grall@arm.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Liming Gao <liming.gao@intel.com>
Cc: Ray Ni <ray.ni@intel.com>
Cc: Zhichao Gao <zhichao.gao@intel.com>
--=20
2.20.1


[edk2-platforms][PATCH V1 1/1] AdvancedFeaturePkg/Ipmi: Fix X64 GCC Build Failures

Kubacki, Michael A
 

REF:https://bugzilla.tianocore.org/show_bug.cgi?id=2204

These build failures can be reproduced simply by building the
AdvancedFeaturePkg.dsc file in GCC5 for X64 architecture. To
build the whole package DSC (not pull individual features into
other packages), set the WORKSPACE variable to the edk2 directory
in the workspace as is done by executing edksetup.sh then create
the PACKAGES_PATH variable and add the Platform/Intel and
Silicon/Intel directories to the variable value. Then start the
build of AdvancedFeaturePkg.dsc:
'build -p AdvancedFeaturePkg/AdvancedFeaturePkg.dsc -a X64'

This change adds EFIAPI to the following function declarations so
they are consistent with the declaration for module entry points.
* BmcElog.c - InitializeBmcElogLayer ()
* FrbPei.c - InitializeFrbPei ()
* IpmiFru.c - InitializeFru ()

All future contributions to AdvancedFeaturePkg must successfully build
in GCC after this change.

Cc: Dandan Bi <dandan.bi@intel.com>
Cc: Sai Chaganty <rangasai.v.chaganty@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Signed-off-by: Michael Kubacki <michael.a.kubacki@intel.com>
---
Platform/Intel/AdvancedFeaturePkg/Ipmi/BmcElog/BmcElog.c | 3 ++-
Platform/Intel/AdvancedFeaturePkg/Ipmi/Frb/FrbPei.c | 3 ++-
Platform/Intel/AdvancedFeaturePkg/Ipmi/IpmiFru/IpmiFru.c | 3 ++-
3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/Platform/Intel/AdvancedFeaturePkg/Ipmi/BmcElog/BmcElog.c b/Platform/Intel/AdvancedFeaturePkg/Ipmi/BmcElog/BmcElog.c
index e214f1a18b..a6d075b19c 100644
--- a/Platform/Intel/AdvancedFeaturePkg/Ipmi/BmcElog/BmcElog.c
+++ b/Platform/Intel/AdvancedFeaturePkg/Ipmi/BmcElog/BmcElog.c
@@ -1,7 +1,7 @@
/** @file
BMC Event Log functions.

-Copyright (c) 2018, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2018 - 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/
@@ -171,6 +171,7 @@ Returns:
}

EFI_STATUS
+EFIAPI
InitializeBmcElogLayer (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
diff --git a/Platform/Intel/AdvancedFeaturePkg/Ipmi/Frb/FrbPei.c b/Platform/Intel/AdvancedFeaturePkg/Ipmi/Frb/FrbPei.c
index 962cd7cc9b..5d33df0103 100644
--- a/Platform/Intel/AdvancedFeaturePkg/Ipmi/Frb/FrbPei.c
+++ b/Platform/Intel/AdvancedFeaturePkg/Ipmi/Frb/FrbPei.c
@@ -1,7 +1,7 @@
/** @file
IPMI FRB PEIM.

-Copyright (c) 2018, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2018 - 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/
@@ -51,6 +51,7 @@ SetWatchDogTimer (
}

EFI_STATUS
+EFIAPI
InitializeFrbPei (
IN EFI_PEI_FILE_HANDLE FileHandle,
IN CONST EFI_PEI_SERVICES **PeiServices
diff --git a/Platform/Intel/AdvancedFeaturePkg/Ipmi/IpmiFru/IpmiFru.c b/Platform/Intel/AdvancedFeaturePkg/Ipmi/IpmiFru/IpmiFru.c
index 663983fd68..58e1fb4d7e 100644
--- a/Platform/Intel/AdvancedFeaturePkg/Ipmi/IpmiFru/IpmiFru.c
+++ b/Platform/Intel/AdvancedFeaturePkg/Ipmi/IpmiFru/IpmiFru.c
@@ -1,7 +1,7 @@
/** @file
IPMI FRU Driver.

-Copyright (c) 2018, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2018 - 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/
@@ -15,6 +15,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
#include <IndustryStandard/Ipmi.h>

EFI_STATUS
+EFIAPI
InitializeFru (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
--
2.16.2.windows.1


Re: [RFC] EDK II Continuous Integration Phase 1

Michael D Kinney
 

Responses below.

Mike

-----Original Message-----
From: Gao, Liming <liming.gao@intel.com>
Sent: Friday, August 30, 2019 1:44 AM
To: rfc@edk2.groups.io; Kinney, Michael D
<michael.d.kinney@intel.com>; devel@edk2.groups.io
Subject: RE: [RFC] EDK II Continuous Integration Phase
1

Mike:
I add my comments.

-----Original Message-----
From: rfc@edk2.groups.io [mailto:rfc@edk2.groups.io]
On Behalf Of
Michael D Kinney
Sent: Friday, August 30, 2019 4:23 AM
To: devel@edk2.groups.io; rfc@edk2.groups.io
Subject: [edk2-rfc] [RFC] EDK II Continuous
Integration Phase 1

Hello,

This is a proposal for a first step towards continuous
integration for
all TianoCore repositories to help improve to quality
of commits and
automate testing and release processes for all EDK II
packages and
platforms.

This is based on work from a number of EDK II
community members that
have provide valuable input and evaluations.

* Rebecca Cran <rebecca@bsdio.com> Jenkins evaluation
* Laszlo Ersek <lersek@redhat.com> GitLab evaluation
* Philippe Mathieu-Daudé <philmd@redhat.com> GitLab
evaluation
* Sean Brogan <sean.brogan@microsoft.com> Azure
Pipelines and HBFA
* Bret Barkelew <Bret.Barkelew@microsoft.com> Azure
Pipelines and HBFA
* Jiewen Yao <jiewen.yao@intel.com> HBFA

The following link is a link to an EDK II WIKI page
that contains a
summary of the work to date. Please provide feedback
in the EDK II
mailing lists. The WIKI pages will be updated with
input from the
entire EDK II community.


https://github.com/tianocore/tianocore.github.io/wiki/
EDK-II-Continuous
-
Integration

Proposal
========
Phase 1 of adding continuous integration is limited to
the
edk2 repository. Additional repositories will be
added later.

The following changes are proposed:
* Remove EDK II Maintainers write access to edk2
repository.
Only EDK II Administrators will continue to have
write
access, and that should only be used to handle
extraordinary
events.
* EDK II Maintainers use a GitHub Pull Request instead
of push
to commit a patch series to the edk2 repository.
There are
no other changes to the development and review
process. The
patch series is prepared in an EDK II maintainer
branch with
all commit message requirements met on each patch in
the series.

Will the maintainer manually provide pull request after
the patch passes the review?
Can the script scan the mail list and auto trig pull
request once the patch gets Reviewed-by or Acked-by
from Package maintainers?
The maintainer will do this step manually. After the
required Reviewed-by and Acked-by responses have been
received, the commit messages in the patch series must
be updated to include the Reviewed-by and Acked-by tags.
I do not see an easy way to automate the editing of the
commit messages and guarantee it is always correct.


* The edk2 repository only accepts Pull Requests from
members
of the EDK II Maintainers team. Pull Requests from
anyone else
are rejected.
* Run pre-commit checks using Azure Pipelines
The maintainer manually trig pre-commit check or auto
trig pre-commit?
By default, pre-commit should be auto trigged based on
pull request.
Automatically triggered.

I would be good to provide an on-demand service for maintainers
to run the exact same pre-commit checks on a branch to see
if there are issues that need to be resolved.


* If all pre-commit checks pass, then the patch series
is auto
committed. The result of this commit must match the
contents
and commit history that would have occurred using
the previous
push operation.
* If any pre-commit checks fail, then notify the
submitter.

Will Pre-commit check fail send the mail to the patch
submitter?
Yes.

The patch submitter need update the patch and go
through review process again.
Potentially. If it is a very simple merge conflict with
no functional impacts, then the maintainer should be able
to resolve and resubmit without additional code review.

If there are functional changes to resolve merge conflict,
then another review cycle would be required.


A typical reason for a failure would be a merge
conflict with
another pull request that was just processed.
* Limit pre-commit checks execution time to 10
minutes.
* Provide on-demand builds to EDK II Maintainers that
to allow
EDK II Maintainers to submit a branch through for
the same
set of pre-commit checks without submitting a pull
request.

## Pre-Commit Checks in Phase 1
* Run and pass PatchCheck.py with no errors

=====================================================

The following are some additional pre-commit check
ideas that could be
quickly added once the initial version using
PatchCheck.py is fully
functional. Please provide feedback on the ones you
like and
additional ones you think may improve the quality of
the commits to the
edk2 repository.

## Proposed Pre-Commit Checks in Phase 2
* Verify Reviewed-by and Acked-by tags are present
with
correct maintainer email addresses
* Verify no non-ASCII characters in modified files
* Verify no binary files in set of modified files
Now, Edk2 has few binary files, like logo.bmp.
I see one BZ to request logo bmp update.
(BZ
https://bugzilla.tianocore.org/show_bug.cgi?id=2050)
So, we need the exception way for it.

* Verify package dependency rules in modified files

## Proposed Pre-Commit Checks in Phase 3
* Run ECC on modified files
* Verify modified modules/libs build
* Run available host based tests (HBFA) against
modified
modules/libs
I request boot test on Emulator and Ovmf in the daily
and weekly scope.
Daily can cover boot to Shell.
Weekly can cover more boot functionality.

Thanks
Liming
Best regards,

Mike







Re: [Qemu-devel] [PATCH 1/2] q35: implement 128K SMRAM at default SMBASE address

Laszlo Ersek
 

Hi Igor,

(+Brijesh)

long-ish pondering ahead, with a question at the end.

On 09/17/19 15:07, Igor Mammedov wrote:
Use commit (2f295167e0 q35/mch: implement extended TSEG sizes) for
inspiration and (ab)use reserved register in config space at 0x9c
offset [*] to extend q35 pci-host with ability to use 128K at
0x30000 as SMRAM and hide it (like TSEG) from non-SMM context.

Usage:
1: write 0xff in the register
2: if the feature is supported, follow up read from the register
should return 0x01. At this point RAM at 0x30000 is still
available for SMI handler configuration from non-SMM context
3: writing 0x02 in the register, locks SMBASE area, making its contents
available only from SMM context. In non-SMM context, reads return
0xff and writes are ignored. Further writes into the register are
ignored until the system reset.
I haven't written any OVMF code for this yet, but I've spent a few hours
thinking about it. Progress! :)

So, this looks really promising.

I'm commenting now for summarizing my thoughts before I write the --
initially minimal -- counterpart patches in OVMF.

There is one complication that deserves this separate email, and that's
SEV's effect on the SMM save state map. It is the topic of the following
edk2 commit range:

1 61a044c6c15f OvmfPkg/MemEncryptSevLib: find pages of initial SMRAM
save state map
2 86defc2c2575 OvmfPkg/PlatformPei: SEV: allocate pages of initial
SMRAM save state map
3 5ef3b66fec13 OvmfPkg/SmmCpuFeaturesLib: SEV: encrypt+free pages of
init. save state map
4 5e2e5647b9fb OvmfPkg/AmdSevDxe: decrypt the pages of the initial
SMRAM save state map

For performing the initial SMBASE relocation, QEMU+KVM have to read the
save state map from guest RAM. For that, under SEV, the guest RAM has to
be decrypted before, and re-encrypted after. Meanwhile, the guest RAM
(while decrypted) should not leak other (unrelated) information to the
hypervisor.

Therefore the above edk2 commits implement the following procedure:

(a.1) in OvmfPkg/PlatformPei, the page in which the save state map
exists, is allocated away from other firmware components

(a.2) in AmdSevDxe, which runs early in the DXE phase (via APRIORI DXE
file), we decrypt the page in question

(a.3) PiSmmCpuDxeSmm, after it performs the initial SMBASE relocation,
calls a hook in SmmCpuFeaturesLib -- and in that hook, we
re-encrypt the page, and also release (free) it for other uses
(firmware and OS both)

Clearly, the above conflicts (or at least intersects) with reserving
128KB (32 pages) at 0x3_0000, i.e. at [0x3_0000..0x4_FFFF], forever,
from the OS. (That area is going to be locked to SMM, and so the OS
should see from the UEFI memmap that it should not touch it.) The
conflict exists because the save state map is in the last kilobyte of
page#15 (from said pages #0..#31) -- the save state map is at
[0x3_FC00..0x3_FFFF].

So here's my plan:

(b.1) In PlatformPei, probe the QEMU feature by writing 0xFF to register
0x9C, and reading back 0x01. If the feature is available, then:

(b.1.1) set a new dynamic PCD to TRUE

(b.1.2) allocate away (as reserved memory) the range
[0x3_0000..0x4_FFFF]

(b.2) In PlatformPei, conditionalize the current, SEV-specific,
allocation of the save state map, on the PCD being FALSE.
(Modifying (a.1).) This will prevent a conflicting
double-allocation (double coverage by memory allocation HOBs)

(b.3) In AmdSevDxe, don't touch the decryption of the save state map
(a.2)

(b.4) in the SmmCpuFeaturesLib hook, preserve the re-encryption of the
save state map (part of (a.3))

(b.5) in the SmmCpuFeaturesLib hook, conditionalize the freeing of the
save state map, on the PCD being FALSE. (Modifying (a.3).) This
will prevent a hole from being punched in the allocation that
covers [0x3_0000..0x4_FFFF], and the entire allocation will
survive into OS runtime.

The above steps ensure that, while the decrypt/encrypt steps prevail,
the save state map allocations will be ingested by the larger, and
longer-term, [0x3_0000..0x4_FFFF] allocation.

Furthermore:

(b.6) Extend SmmAccessDxe to write 0x02 to register 0x9C, in an
EFI_DXE_MM_READY_TO_LOCK_PROTOCOL notification callback, if the
PCD is true. This will cause the [0x3_0000..0x4_FFFF] area to be
locked down at the same time with the rest of SMRAM (i.e., TSEG).

(b.7) Extend SmmAccessDxe to save S3 boot script opcodes for writing
0x02 to register 0x9C, if the PCD is true. This makes sure that
the above lockdown will occur also during S3 resume, before the OS
is reached. (The S3 boot script is executed *after* SMBASE
relocation and TSEG locking, during S3 resume.)

Considering (b.6) and (b.7), the "lockdown on normal boot" (from (b.6))
could actually be merged into (b.5) -- we don't necessarily have to
delay the normal boot lockdown of [0x3_0000..0x4_FFFF] until platform
BDS signals EFI_DXE_MM_READY_TO_LOCK_PROTOCOL; we could do it right
after initial SMBASE relocation.

However: I'd really like to keep (b.6) and (b.7) together, in the same
driver, and (b.7) is really inappropriate for PiSmmCpuDxeSmm (into which
SmmCpuFeaturesLib is linked). For writing S3 boot script opcodes in
(b.7), we need another protocol notify (on EFI_S3_SAVE_STATE_PROTOCOL),
and sneaking that kind of callback into PiSmmCpuDxeSmm sounds really
bad. Hence I plan to add both (b.6) and (b.7) to SmmAccessDxe.

I'll report back with my findings; just wanted to give a heads-up (to
myself as well :))

Finally: can you please remind me why we lock down 128KB (32 pages) at
0x3_0000, and not just half of that? What do we need the range at
[0x4_0000..0x4_FFFF] for?

Thanks!
Laszlo



*) https://www.mail-archive.com/qemu-devel@nongnu.org/msg455991.html

Signed-off-by: Igor Mammedov <imammedo@redhat.com>
---
include/hw/pci-host/q35.h | 10 +++++
hw/i386/pc.c | 4 +-
hw/pci-host/q35.c | 80 +++++++++++++++++++++++++++++++++++----
3 files changed, 86 insertions(+), 8 deletions(-)

diff --git a/include/hw/pci-host/q35.h b/include/hw/pci-host/q35.h
index b3bcf2e632..976fbae599 100644
--- a/include/hw/pci-host/q35.h
+++ b/include/hw/pci-host/q35.h
@@ -32,6 +32,7 @@
#include "hw/acpi/ich9.h"
#include "hw/pci-host/pam.h"
#include "hw/i386/intel_iommu.h"
+#include "qemu/units.h"

#define TYPE_Q35_HOST_DEVICE "q35-pcihost"
#define Q35_HOST_DEVICE(obj) \
@@ -54,6 +55,8 @@ typedef struct MCHPCIState {
MemoryRegion smram_region, open_high_smram;
MemoryRegion smram, low_smram, high_smram;
MemoryRegion tseg_blackhole, tseg_window;
+ MemoryRegion smbase_blackhole, smbase_window;
+ bool has_smram_at_smbase;
Range pci_hole;
uint64_t below_4g_mem_size;
uint64_t above_4g_mem_size;
@@ -97,6 +100,13 @@ typedef struct Q35PCIHost {
#define MCH_HOST_BRIDGE_EXT_TSEG_MBYTES_QUERY 0xffff
#define MCH_HOST_BRIDGE_EXT_TSEG_MBYTES_MAX 0xfff

+#define MCH_HOST_BRIDGE_SMBASE_SIZE (128 * KiB)
+#define MCH_HOST_BRIDGE_SMBASE_ADDR 0x30000
+#define MCH_HOST_BRIDGE_F_SMBASE 0x9c
+#define MCH_HOST_BRIDGE_F_SMBASE_QUERY 0xff
+#define MCH_HOST_BRIDGE_F_SMBASE_IN_RAM 0x01
+#define MCH_HOST_BRIDGE_F_SMBASE_LCK 0x02
+
#define MCH_HOST_BRIDGE_PCIEXBAR 0x60 /* 64bit register */
#define MCH_HOST_BRIDGE_PCIEXBAR_SIZE 8 /* 64bit register */
#define MCH_HOST_BRIDGE_PCIEXBAR_DEFAULT 0xb0000000
diff --git a/hw/i386/pc.c b/hw/i386/pc.c
index bad866fe44..288d28358a 100644
--- a/hw/i386/pc.c
+++ b/hw/i386/pc.c
@@ -119,7 +119,9 @@ struct hpet_fw_config hpet_cfg = {.count = UINT8_MAX};
/* Physical Address of PVH entry point read from kernel ELF NOTE */
static size_t pvh_start_addr;

-GlobalProperty pc_compat_4_1[] = {};
+GlobalProperty pc_compat_4_1[] = {
+ { "mch", "smbase-smram", "off" },
+};
const size_t pc_compat_4_1_len = G_N_ELEMENTS(pc_compat_4_1);

GlobalProperty pc_compat_4_0[] = {};
diff --git a/hw/pci-host/q35.c b/hw/pci-host/q35.c
index 158d270b9f..c1bd9f78ae 100644
--- a/hw/pci-host/q35.c
+++ b/hw/pci-host/q35.c
@@ -275,20 +275,20 @@ static const TypeInfo q35_host_info = {
* MCH D0:F0
*/

-static uint64_t tseg_blackhole_read(void *ptr, hwaddr reg, unsigned size)
+static uint64_t blackhole_read(void *ptr, hwaddr reg, unsigned size)
{
return 0xffffffff;
}

-static void tseg_blackhole_write(void *opaque, hwaddr addr, uint64_t val,
- unsigned width)
+static void blackhole_write(void *opaque, hwaddr addr, uint64_t val,
+ unsigned width)
{
/* nothing */
}

-static const MemoryRegionOps tseg_blackhole_ops = {
- .read = tseg_blackhole_read,
- .write = tseg_blackhole_write,
+static const MemoryRegionOps blackhole_ops = {
+ .read = blackhole_read,
+ .write = blackhole_write,
.endianness = DEVICE_NATIVE_ENDIAN,
.valid.min_access_size = 1,
.valid.max_access_size = 4,
@@ -430,6 +430,46 @@ static void mch_update_ext_tseg_mbytes(MCHPCIState *mch)
}
}

+static void mch_update_smbase_smram(MCHPCIState *mch)
+{
+ PCIDevice *pd = PCI_DEVICE(mch);
+ uint8_t *reg = pd->config + MCH_HOST_BRIDGE_F_SMBASE;
+ bool lck;
+
+ if (!mch->has_smram_at_smbase) {
+ return;
+ }
+
+ if (*reg == MCH_HOST_BRIDGE_F_SMBASE_QUERY) {
+ pd->wmask[MCH_HOST_BRIDGE_F_SMBASE] =
+ MCH_HOST_BRIDGE_F_SMBASE_LCK;
+ *reg = MCH_HOST_BRIDGE_F_SMBASE_IN_RAM;
+ return;
+ }
+
+ /*
+ * default/reset state, discard written value
+ * which will disable SMRAM balackhole at SMBASE
+ */
+ if (pd->wmask[MCH_HOST_BRIDGE_F_SMBASE] == 0xff) {
+ *reg = 0x00;
+ }
+
+ memory_region_transaction_begin();
+ if (*reg & MCH_HOST_BRIDGE_F_SMBASE_LCK) {
+ /* disable all writes */
+ pd->wmask[MCH_HOST_BRIDGE_F_SMBASE] &=
+ ~MCH_HOST_BRIDGE_F_SMBASE_LCK;
+ *reg = MCH_HOST_BRIDGE_F_SMBASE_LCK;
+ lck = true;
+ } else {
+ lck = false;
+ }
+ memory_region_set_enabled(&mch->smbase_blackhole, lck);
+ memory_region_set_enabled(&mch->smbase_window, lck);
+ memory_region_transaction_commit();
+}
+
static void mch_write_config(PCIDevice *d,
uint32_t address, uint32_t val, int len)
{
@@ -456,6 +496,10 @@ static void mch_write_config(PCIDevice *d,
MCH_HOST_BRIDGE_EXT_TSEG_MBYTES_SIZE)) {
mch_update_ext_tseg_mbytes(mch);
}
+
+ if (ranges_overlap(address, len, MCH_HOST_BRIDGE_F_SMBASE, 1)) {
+ mch_update_smbase_smram(mch);
+ }
}

static void mch_update(MCHPCIState *mch)
@@ -464,6 +508,7 @@ static void mch_update(MCHPCIState *mch)
mch_update_pam(mch);
mch_update_smram(mch);
mch_update_ext_tseg_mbytes(mch);
+ mch_update_smbase_smram(mch);

/*
* pci hole goes from end-of-low-ram to io-apic.
@@ -514,6 +559,9 @@ static void mch_reset(DeviceState *qdev)
MCH_HOST_BRIDGE_EXT_TSEG_MBYTES_QUERY);
}

+ d->config[MCH_HOST_BRIDGE_F_SMBASE] = 0;
+ d->wmask[MCH_HOST_BRIDGE_F_SMBASE] = 0xff;
+
mch_update(mch);
}

@@ -563,7 +611,7 @@ static void mch_realize(PCIDevice *d, Error **errp)
memory_region_add_subregion(&mch->smram, 0xfeda0000, &mch->high_smram);

memory_region_init_io(&mch->tseg_blackhole, OBJECT(mch),
- &tseg_blackhole_ops, NULL,
+ &blackhole_ops, NULL,
"tseg-blackhole", 0);
memory_region_set_enabled(&mch->tseg_blackhole, false);
memory_region_add_subregion_overlap(mch->system_memory,
@@ -575,6 +623,23 @@ static void mch_realize(PCIDevice *d, Error **errp)
memory_region_set_enabled(&mch->tseg_window, false);
memory_region_add_subregion(&mch->smram, mch->below_4g_mem_size,
&mch->tseg_window);
+
+ memory_region_init_io(&mch->smbase_blackhole, OBJECT(mch), &blackhole_ops,
+ NULL, "smbase-blackhole",
+ MCH_HOST_BRIDGE_SMBASE_SIZE);
+ memory_region_set_enabled(&mch->smbase_blackhole, false);
+ memory_region_add_subregion_overlap(mch->system_memory,
+ MCH_HOST_BRIDGE_SMBASE_ADDR,
+ &mch->smbase_blackhole, 1);
+
+ memory_region_init_alias(&mch->smbase_window, OBJECT(mch),
+ "smbase-window", mch->ram_memory,
+ MCH_HOST_BRIDGE_SMBASE_ADDR,
+ MCH_HOST_BRIDGE_SMBASE_SIZE);
+ memory_region_set_enabled(&mch->smbase_window, false);
+ memory_region_add_subregion(&mch->smram, MCH_HOST_BRIDGE_SMBASE_ADDR,
+ &mch->smbase_window);
+
object_property_add_const_link(qdev_get_machine(), "smram",
OBJECT(&mch->smram), &error_abort);

@@ -601,6 +666,7 @@ uint64_t mch_mcfg_base(void)
static Property mch_props[] = {
DEFINE_PROP_UINT16("extended-tseg-mbytes", MCHPCIState, ext_tseg_mbytes,
16),
+ DEFINE_PROP_BOOL("smbase-smram", MCHPCIState, has_smram_at_smbase, true),
DEFINE_PROP_END_OF_LIST(),
};


Re: [edk2-platforms: PATCH 1/1] DisplayLinkPkg: DisplayLinkGop: Added GOP driver for USB docking stations based on DisplayLink chips

Leif Lindholm
 

Hi Ray,

On Fri, Sep 13, 2019 at 07:57:08AM +0000, Ni, Ray wrote:
Leif, Mike,
I have two general comments regarding the edk2-platforms/Drivers directory:
1. should we change it to "Driver" because the other two don't carry a "s"?
2. Where should OptionRomPkg go? "Platform" and "Silicon" both
contains vendor sub-directories. Now "Driver" contains vendor
sub-directory as well. But OptionRomPkg is in the root of
"Driver". Do we need to put it as a future task to separate the
OptionRomPkg according to vendors? or create "Driver/Intel" and put
OptionRomPkg there?
I agree we should look into reworking this. We've gone through the
initial effort of importing OpenPlatformPkg, bringing Intel platforms
across from -devel branches, and moving non-industry-standard items
across from edk2. It would make sense to revisit the directory layout
now we have some more content to relate to.

Best Regards,

Leif

(sorry I thought I sent the mail long time ago.)

Thanks,
Ray

-----Original Message-----
From: Leif Lindholm <leif.lindholm@linaro.org>
Sent: Friday, August 30, 2019 8:27 AM
To: Andy Hayes <andy.hayes@displaylink.com>
Cc: devel@edk2.groups.io; Kinney, Michael D <michael.d.kinney@intel.com>; Ni, Ray <ray.ni@intel.com>
Subject: Re: [edk2-platforms: PATCH 1/1] DisplayLinkPkg: DisplayLinkGop: Added GOP driver for USB docking stations based on
DisplayLink chips

Hi Andy,

This looks fine to me - all my feedback has been addressed.
Reviewed-by: Leif Lindholm <leif.lindholm@linaro.org>

Ray - did you have any comments on this, or can I go ahead and commit?

Best Regards,

Leif

On Mon, Aug 19, 2019 at 02:32:00PM +0100, Andy Hayes wrote:
Cc: Leif Lindholm <leif.lindholm@linaro.org>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Andy Hayes <andy.hayes@displaylink.com>
---
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/CapabilityDescriptor.c | 137 +++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/ComponentName.c | 235 +++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/DisplayLinkGopDxe.inf | 65 ++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.c | 598 +++++++++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.h | 129 +++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Gop.c | 578 +++++++++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.c | 145 +++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.h | 109 ++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.c | 1082 ++++++++++++++++++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.h | 278 +++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbTransfer.c | 180 ++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/VideoModes.c | 254 +++++
Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkPkg.dsc | 61 ++
Drivers/DisplayLink/DisplayLinkPkg/ReadMe.md | 77 ++
Maintainers.txt | 5 +
15 files changed, 3933 insertions(+)

diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/CapabilityDescriptor.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/CapabilityDescriptor.c
new file mode 100644
index 000000000000..4bfadd770b81
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/CapabilityDescriptor.c
@@ -0,0 +1,137 @@
+/** @file CapabilityDescriptor.c
+ * @brief Definitions for reading USB capability descriptor DisplayLink dock
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+#include "UsbDescriptors.h"
+
+/**
+ * Check that the Capability Descriptor is valid and hasn't been tampered with.
+ * @param Data Binary data of the Capability Descriptor received from the DisplayLink device
+ * @param Length
+ * @param out
+ * @return
+ */
+STATIC EFI_STATUS
+ValidateHeader (
+ CONST IN VOID* Data,
+ IN UINTN Length,
+ OUT CONST VendorDescriptorGeneric** Out
+ )
+{
+ if (Length < sizeof (VendorDescriptorGeneric)) {
+ DEBUG ((DEBUG_ERROR, "Data too short (%d bytes) for capability descriptor header section\n", Length));
+ return EFI_INVALID_PARAMETER;
+ }
+ CONST VendorDescriptorGeneric* Desc = (VendorDescriptorGeneric*)Data;
+ if (Desc->Length > Length) {
+ DEBUG ((DEBUG_ERROR, "Capability descriptor: Descriptor (%d bytes) exceeds buffer (%d bytes)\n",
+ Length, Desc->Length));
+ return EFI_BUFFER_TOO_SMALL;
+ }
+ if (Desc->Type != DESCRIPTOR_TYPE_DIRECTFB_CAPABILITY) {
+ DEBUG ((DEBUG_ERROR, "Capability descriptor: invalid type (0x%08x)\n", Desc->Type));
+ return EFI_UNSUPPORTED;
+ }
+ if (Desc->CapabilityVersion != 1) {
+ DEBUG ((DEBUG_ERROR, "Capability descriptor: invalid version (%d)\n", Desc->CapabilityVersion));
+ return EFI_INCOMPATIBLE_VERSION;
+ }
+ // Capability length must fit within remaining space
+ if (Desc->CapabilityLength > (Desc->Length - (sizeof (Desc->Length) + sizeof (Desc->Type)))) {
+ DEBUG ((DEBUG_ERROR, "Capability descriptor: invalid CapabilityLength (%d)\n", Desc->CapabilityLength));
+ return EFI_INVALID_PARAMETER;
+ }
+ *Out = Desc;
+ return EFI_SUCCESS;
+}
+
+
+/**
+ * Check that the connected DisplayLink device supports the functionality that this driver requires, e.g. video formats
+ * @param Data Binary data of the Capability Descriptor received from the DisplayLink device
+ * @param Length
+ * @param Output
+ * @return
+ */
+EFI_STATUS
+UsbDisplayLinkParseCapabilitiesDescriptor (
+ CONST IN VOID* Data,
+ IN UINTN Length,
+ OUT VendorDescriptor* Output
+ )
+{
+ CONST VendorDescriptorGeneric* Desc;
+ EFI_STATUS Status;
+
+ Desc = NULL;
+ Status = ValidateHeader (Data, Length, &Desc);
+
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ // Default capabilities
+ Output->Capabilities1 = 0;
+
+ CONST UINTN CapsHeaderLength = sizeof (Desc->CapabilityVersion) + sizeof (Desc->CapabilityLength);
+ ASSERT (CapsHeaderLength < MAX_UINT8);
+
+ UINTN DataRemaining;
+ UINTN Offset;
+
+ DataRemaining = Desc->CapabilityLength - CapsHeaderLength;
+ Offset = 0;
+
+ while (DataRemaining >= sizeof (DescriptorKLV)) {
+ CONST DescriptorKLV* KeyHeader = (CONST DescriptorKLV*)(Desc->Klv + Offset);
+ CONST UINTN KeyValueSize = sizeof (DescriptorKLV) + KeyHeader->Length;
+ if (KeyValueSize > DataRemaining) {
+ DEBUG ((DEBUG_ERROR, "Capability descriptor: invalid value Length (%d)\n", Desc->CapabilityLength));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ switch (KeyHeader->Key) {
+ case CAPABILITIES1_KEY: {
+ if (KeyHeader->Length != CAPABILITIES1_LENGTH) {
+ DEBUG ((DEBUG_ERROR, "Capability descriptor: invalid length (%d) for Capabilities 1\n", KeyHeader->Length));
+ return EFI_INVALID_PARAMETER;
+ }
+ Output->Capabilities1 = *(UINT32*)KeyHeader->Value;
+ break;
+ default:
+ // Ignore unknown types
+ break;
+ }
+ }
+ DataRemaining -= KeyValueSize;
+ Offset += KeyValueSize;
+ }
+ return EFI_SUCCESS;
+}
+
+
+/**
+ * Check that the DisplayLink device supports the basic level of functionality to display GOP pixels.
+ * @param Descriptor The USB descriptor received from the DisplayLink device
+ * @return True we can bind, False we can't
+ */
+BOOLEAN
+UsbDisplayLinkCapabilitiesSufficientToBind (
+ CONST IN VendorDescriptor* Descriptor
+ )
+{
+ BOOLEAN Sufficient;
+ Sufficient = (BOOLEAN)(Descriptor->Capabilities1 & CAPABILITIES1_BASE_PROTOCOL);
+
+ if (Sufficient == FALSE) {
+ DEBUG ((DEBUG_ERROR, "DisplayLink device does not report support for base capabilites - reports x%x, required x%x\n",
Descriptor->Capabilities1 & CAPABILITIES1_BASE_PROTOCOL));
+ }
+ return Sufficient;
+}
+
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/ComponentName.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/ComponentName.c
new file mode 100644
index 000000000000..74498f339eb7
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/ComponentName.c
@@ -0,0 +1,235 @@
+/**
+ * @file ComponentName.c
+ * @brief UEFI Component Name protocol implementation for USB DisplayLink driver.
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkComponentNameGetDriverName (
+ IN EFI_COMPONENT_NAME_PROTOCOL *This,
+ IN CHAR8 *Language,
+ OUT CHAR16 **DriverName
+);
+
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkComponentNameGetControllerName (
+ IN EFI_COMPONENT_NAME_PROTOCOL *This,
+ IN EFI_HANDLE ControllerHandle,
+ IN EFI_HANDLE ChildHandle OPTIONAL,
+ IN CHAR8 *Language,
+ OUT CHAR16 **ControllerName
+);
+
+
+//
+// EFI Component Name Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL mUsbDisplayLinkComponentName = {
+ UsbDisplayLinkComponentNameGetDriverName,
+ UsbDisplayLinkComponentNameGetControllerName,
+ "eng"
+};
+
+//
+// EFI Component Name 2 Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL mUsbDisplayLinkComponentName2 = {
+ (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) UsbDisplayLinkComponentNameGetDriverName,
+ (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) UsbDisplayLinkComponentNameGetControllerName,
+ "en"
+};
+
+
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mUsbDisplayLinkDriverNameTable[] = {
+ { (CHAR8*)"eng;en", (CHAR16*)L"DisplayLink USB GOP Driver" },
+ { (CHAR8*)NULL , (CHAR16*)NULL }
+};
+
+/**
+ Retrieves a Unicode string that is the user readable name of the driver.
+
+ This function retrieves the user readable name of a driver in the form of a
+ Unicode string. If the driver specified by This has a user readable name in
+ the language specified by Language, then a pointer to the driver name is
+ returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
+ by This does not support the language specified by Language,
+ then EFI_UNSUPPORTED is returned.
+
+ @param This A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+ EFI_COMPONENT_NAME_PROTOCOL instance.
+ @param Language A pointer to a Null-terminated ASCII string
+ array indicating the language. This is the
+ language of the driver name that the caller is
+ requesting, and it must match one of the
+ languages specified in SupportedLanguages. The
+ number of languages supported by a driver is up
+ to the driver writer. Language is specified
+ in RFC 4646 or ISO 639-2 language code format.
+ @param DriverName A pointer to the Unicode string to return.
+ This Unicode string is the name of the
+ driver specified by This in the language
+ specified by Language.
+
+ @retval EFI_SUCCESS The Unicode string for the Driver specified by
+ This and the language specified by Language was
+ returned in DriverName.
+ @retval EFI_INVALID_PARAMETER Language is NULL.
+ @retval EFI_INVALID_PARAMETER DriverName is NULL.
+ @retval EFI_UNSUPPORTED The driver specified by This does not support
+ the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkComponentNameGetDriverName (
+ IN EFI_COMPONENT_NAME_PROTOCOL *This,
+ IN CHAR8 *Language,
+ OUT CHAR16 **DriverName
+ )
+{
+ return LookupUnicodeString2 (
+ Language,
+ This->SupportedLanguages,
+ mUsbDisplayLinkDriverNameTable,
+ DriverName,
+ (BOOLEAN)(This == &mUsbDisplayLinkComponentName));
+}
+
+/**
+ Retrieves a Unicode string that is the user readable name of the controller
+ that is being managed by a driver.
+
+ This function retrieves the user readable name of the controller specified by
+ ControllerHandle and ChildHandle in the form of a Unicode string. If the
+ driver specified by This has a user readable name in the language specified by
+ Language, then a pointer to the controller name is returned in ControllerName,
+ and EFI_SUCCESS is returned. If the driver specified by This is not currently
+ managing the controller specified by ControllerHandle and ChildHandle,
+ then EFI_UNSUPPORTED is returned. If the driver specified by This does not
+ support the language specified by Language, then EFI_UNSUPPORTED is returned.
+
+ @param This A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+ EFI_COMPONENT_NAME_PROTOCOL instance.
+ @param ControllerHandle The handle of a controller that the driver
+ specified by This is managing. This handle
+ specifies the controller whose name is to be
+ returned.
+ @param ChildHandle The handle of the child controller to retrieve
+ the name of. This is an optional parameter that
+ may be NULL. It will be NULL for device
+ drivers. It will also be NULL for a bus drivers
+ that wish to retrieve the name of the bus
+ controller. It will not be NULL for a bus
+ driver that wishes to retrieve the name of a
+ child controller.
+ @param Language A pointer to a Null-terminated ASCII string
+ array indicating the language. This is the
+ language of the driver name that the caller is
+ requesting, and it must match one of the
+ languages specified in SupportedLanguages. The
+ number of languages supported by a driver is up
+ to the driver writer. Language is specified in
+ RFC 4646 or ISO 639-2 language code format.
+ @param ControllerName A pointer to the Unicode string to return.
+ This Unicode string is the name of the
+ controller specified by ControllerHandle and
+ ChildHandle in the language specified by
+ Language from the point of view of the driver
+ specified by This.
+
+ @retval EFI_SUCCESS The Unicode string for the user readable name in
+ the language specified by Language for the
+ driver specified by This was returned in
+ DriverName.
+ @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+ @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
+ EFI_HANDLE.
+ @retval EFI_INVALID_PARAMETER Language is NULL.
+ @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+ @retval EFI_UNSUPPORTED The driver specified by This is not currently
+ managing the controller specified by
+ ControllerHandle and ChildHandle.
+ @retval EFI_UNSUPPORTED The driver specified by This does not support
+ the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkComponentNameGetControllerName (
+ IN EFI_COMPONENT_NAME_PROTOCOL *This,
+ IN EFI_HANDLE ControllerHandle,
+ IN EFI_HANDLE ChildHandle OPTIONAL,
+ IN CHAR8 *Language,
+ OUT CHAR16 **ControllerName
+ )
+{
+ EFI_STATUS Status;
+ USB_DISPLAYLINK_DEV *UsbDisplayLinkDev;
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutputProtocol;
+ EFI_USB_IO_PROTOCOL *UsbIoProtocol;
+
+ //
+ // This is a device driver, so ChildHandle must be NULL.
+ //
+ if (ChildHandle != NULL) {
+ return EFI_UNSUPPORTED;
+ }
+
+ //
+ // Check Controller's handle
+ //
+ Status = gBS->OpenProtocol (
+ ControllerHandle,
+ &gEfiUsbIoProtocolGuid,
+ (VOID **) &UsbIoProtocol,
+ gUsbDisplayLinkDriverBinding.DriverBindingHandle,
+ ControllerHandle,
+ EFI_OPEN_PROTOCOL_BY_DRIVER);
+
+ if (!EFI_ERROR (Status)) {
+ gBS->CloseProtocol (
+ ControllerHandle,
+ &gEfiUsbIoProtocolGuid,
+ gUsbDisplayLinkDriverBinding.DriverBindingHandle,
+ ControllerHandle);
+
+ return EFI_UNSUPPORTED;
+ }
+
+ if (Status != EFI_ALREADY_STARTED) {
+ return EFI_UNSUPPORTED;
+ }
+ //
+ // Get the device context
+ //
+ Status = gBS->OpenProtocol (
+ ControllerHandle,
+ &gEfiGraphicsOutputProtocolGuid,
+ (VOID**)&GraphicsOutputProtocol,
+ gUsbDisplayLinkDriverBinding.DriverBindingHandle,
+ ControllerHandle,
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ UsbDisplayLinkDev = USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(GraphicsOutputProtocol);
+
+ return LookupUnicodeString2 (
+ Language,
+ This->SupportedLanguages,
+ UsbDisplayLinkDev->ControllerNameTable,
+ ControllerName,
+ (BOOLEAN)(This == &mUsbDisplayLinkComponentName));
+}
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/DisplayLinkGopDxe.inf
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/DisplayLinkGopDxe.inf
new file mode 100644
index 000000000000..0f458fedcc88
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/DisplayLinkGopDxe.inf
@@ -0,0 +1,65 @@
+#/** @file
+# USB DisplayLink driver that implements blt and EDID commands
+#
+# USB DisplayLink driver consumes I/O Protocol and Device Path Protocol, and produces
+# Graphics Output Protocol on DisplayLink devices.
+# 1. DisplayLink reference
+# 2. UEFI Specification, v2.1
+#
+# Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+#**/
+
+
+[Defines]
+ INF_VERSION = 0x0001001B
+ BASE_NAME = DisplayLinkGop
+ FILE_GUID = 2D2E62AA-9ECF-43b7-8219-94E7FC713DFF
+ MODULE_TYPE = UEFI_DRIVER
+ VERSION_STRING = 1.0
+ ENTRY_POINT = UsbDisplayLinkDriverBindingEntryPoint
+ UNLOAD_IMAGE = UsbDisplayLinkDriverCombinedGopUnload
+ INF_DRIVER_VERSION = 0x00000001
+
+[Sources]
+ CapabilityDescriptor.c
+ ComponentName.c
+ Edid.c
+ Edid.h
+ Gop.c
+ UsbDescriptors.c
+ UsbDescriptors.h
+ UsbDisplayLink.c
+ UsbDisplayLink.h
+ UsbTransfer.c
+ VideoModes.c
+
+[Packages]
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ BaseMemoryLib
+ DebugLib
+ MemoryAllocationLib
+ ReportStatusCodeLib
+ UefiBootServicesTableLib
+ UefiDriverEntryPoint
+ UefiLib
+ UefiUsbLib
+
+[Protocols]
+ gEfiUsbIoProtocolGuid ## TO_START
+ gEfiEdidActiveProtocolGuid # PROTOCOL BY_START
+ gEfiEdidDiscoveredProtocolGuid # PROTOCOL BY_START
+ gEfiEdidOverrideProtocolGuid # PROTOCOL TO_START
+ gEfiHiiDatabaseProtocolGuid
+ gEfiHiiFontProtocolGuid
+
+[Guids]
+ gEfiEventExitBootServicesGuid
+ gEfiGlobalVariableGuid
+
+[Pcd]
+ gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize ## CONSUMES
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.c
new file mode 100644
index 000000000000..21f4b7d9c736
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.c
@@ -0,0 +1,598 @@
+/** @file Edid.c
+ * @brief Reads and parses the EDID, checks if a requested video mode is in the supplied EDID
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+#include "Edid.h"
+
+CONST UINT8 ExpectedEdidHeader[EDID_HEADER_SIZE] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 };
+
+//
+// Standard timing defined by VESA EDID
+//
+CONST EDID_TIMING EstablishedTimings[EDID_NUMBER_OF_ESTABLISHED_TIMINGS_BYTES][8] = {
+ //
+ // Established Timing I
+ //
+ {
+ { 800, 600, 60 },
+ { 800, 600, 56 },
+ { 640, 480, 75 },
+ { 640, 480, 72 },
+ { 640, 480, 67 },
+ { 640, 480, 60 },
+ { 720, 400, 88 },
+ { 720, 400, 70 },
+ },
+ {
+ //
+ // Established Timing II
+ //
+ { 1280, 1024, 75 },
+ { 1024, 768, 75 },
+ { 1024, 768, 70 },
+ { 1024, 768, 60 },
+ { 1024, 768, 87 },
+ { 832, 624, 75 },
+ { 800, 600, 75 },
+ { 800, 600, 72 },
+ },
+ //
+ // Established Timing III
+ //
+ {
+ { 1152, 870, 75 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ { 0, 0, 0 },
+ }
+};
+
+/**
+ * Requests the monitor EDID data from the connected DisplayLink device
+ * @param UsbDisplayLinkDev
+ * @param EdidDataBlock
+ * @param EdidSize
+ * @retval EFI_DEVICE_ERROR - No EDID received, or EDID is corrupted
+ * @retval EFI_OUT_OF_RESOURCES - Cannot allocate memory
+ * @retval EFI_SUCCESS
+ *
+ */
+STATIC EFI_STATUS
+ReadEdidData (
+ IN USB_DISPLAYLINK_DEV *UsbDisplayLinkDev,
+ OUT UINT8 **EdidDataBlock,
+ OUT UINTN *EdidSize
+)
+{
+ EFI_STATUS Status;
+
+ UINT8 EdidDataRead[EDID_BLOCK_SIZE];
+ UINT8 *EdidData = EdidDataRead;
+ UINT8* ValidEdid;
+
+ Status = DlUsbSendControlReadMessage (UsbDisplayLinkDev, GET_OUTPUT_EDID, 0, EdidDataRead, sizeof (EdidDataRead));
+
+ if (EFI_ERROR (Status) || (EdidData[0] != 0)) {
+ DEBUG ((DEBUG_ERROR, "No monitor EDID received from DisplayLink device - System error %r, EDID error %d. Monitor
connected correctly?\n", Status, EdidData[0]));
+ return EFI_DEVICE_ERROR;
+ } else {
+ //
+ // Search for the EDID signature
+ //
+ ValidEdid = &EdidData[0];
+ CONST UINT64 Signature = 0x00ffffffffffff00ull;
+ if (CompareMem (ValidEdid, &Signature, 8) != 0) {
+ //
+ // No EDID signature found
+ //
+ DEBUG ((DEBUG_ERROR, "Monitor EDID received from DisplayLink device did not have a valid signature - corrupted?\n"));
+ Status = EFI_DEVICE_ERROR;
+ return Status;
+ }
+ }
+
+ *EdidDataBlock = (UINT8*)AllocateCopyPool (
+ EDID_BLOCK_SIZE,
+ ValidEdid);
+
+ if (*EdidDataBlock == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ //
+ // Currently only support EDID 1.x
+ //
+ *EdidSize = EDID_BLOCK_SIZE;
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+Calculates the mod256 checksum of the EDID and compares it with the one supplied at the end of the EDID
+@param EDID Pointer to the 128-byte EDID
+@retval TRUE The EDID checksum is correct
+**/
+BOOLEAN
+IsEdidChecksumCorrect (
+ CONST VOID *EDID
+ )
+{
+ CONST UINT8 EdidChecksum = ((UINT8 *)EDID)[EDID_BLOCK_SIZE - 1];
+ UINT8 CalculatedChecksum;
+
+ CalculatedChecksum = 0;
+
+ UINTN i;
+ for (i = 0; i < EDID_BLOCK_SIZE - 1; i++) {
+ CalculatedChecksum += ((UINT8 *)EDID)[i];
+ }
+ CalculatedChecksum = 0 - CalculatedChecksum;
+
+ return (CalculatedChecksum == EdidChecksum);
+}
+
+/**
+Check if a particular video mode is in the Established Timings section of the EDID.
+
+@param EDID Pointer to the 128-byte EDID
+@param hRes Horizontal resolution
+@param vRes Vertical resolution
+@param refresh Refresh rate
+@retval TRUE The requested mode is present in the Established Timings section
+
+**/
+STATIC BOOLEAN
+IsModeInEstablishedTimings (
+ IN CONST VOID *EDID,
+ IN UINT16 HRes,
+ IN UINT16 VRes,
+ IN UINT16 Refresh
+ )
+{
+ CONST struct Edid *pEDID = (CONST struct Edid *)EDID;
+ BOOLEAN ModeSupported;
+
+ ModeSupported = FALSE;
+
+ int EstByteNum;
+ int BitNum;
+ for (EstByteNum = 0; EstByteNum < EDID_NUMBER_OF_ESTABLISHED_TIMINGS_BYTES; EstByteNum++) {
+ for (BitNum = 0; BitNum < 8; BitNum++) {
+ if (pEDID->EstablishedTimings[EstByteNum] & (1 << BitNum)) { // The bit is set in the established timings of the EDID
+
+ if ((EstablishedTimings[EstByteNum][BitNum].HRes == HRes) && // The passed-in resolution matches the resolution
represented by the set bit
+ (EstablishedTimings[EstByteNum][BitNum].VRes == VRes) &&
+ (EstablishedTimings[EstByteNum][BitNum].Refresh == Refresh)) {
+
+ ModeSupported = TRUE;
+ break;
+ }
+ }
+ }
+ if (ModeSupported == TRUE) {
+ break;
+ }
+ }
+ return ModeSupported;
+}
+
+/**
+Extract the resolutions and refresh rate from one of the entries in the Standard Timings section of the EDID.
+
+@param EDID Pointer to the 128-byte EDID
+@param timingNumber The entry that we want to extract
+@param hRes Output - Horizontal resolution
+@param vRes Output - Vertical resolution
+@param refresh Output - Refresh rate
+@retval TRUE The requested Standard Timings entry contains valid data
+
+**/
+STATIC BOOLEAN ReadStandardTiming (
+ CONST VOID *EDID,
+ IN UINT8 TimingNumber,
+ OUT UINT16 *HRes,
+ OUT UINT16 *VRes,
+ OUT UINT8 *Refresh)
+{
+ CONST struct Edid *pEDID = (CONST struct Edid *)EDID;
+
+ // See section 3.9.1 of the VESA EDID spec
+
+ if (((pEDID->standardTimingIdentifications[TimingNumber].HorizontalActivePixels) == 0x01) &&
+ (pEDID->standardTimingIdentifications[TimingNumber].ImageAspectRatioAndrefresh) == 0x01) {
+ *HRes = 0;
+ *VRes = 0;
+ *Refresh = 0;
+ return FALSE;
+ }
+ *HRes = (pEDID->standardTimingIdentifications[TimingNumber].HorizontalActivePixels + 31) * 8;
+
+ UINT8 AspectRatio;
+ AspectRatio = (pEDID->standardTimingIdentifications[TimingNumber].ImageAspectRatioAndrefresh >> 6) & 0x3;
+
+ switch (AspectRatio) {
+ case 0: *VRes = (*HRes * 10) / 16;
+ break;
+ case 1: *VRes = (*HRes * 3) / 4;
+ break;
+ case 2: *VRes = (*HRes * 4) / 5;
+ break;
+ case 3: *VRes = (*HRes * 9) / 16;
+ break;
+ default: break;
+ }
+
+ // WORKAROUND - 1360x768 is not a perfect aspect ratio
+ if ((*HRes == 1360) && (*VRes == 765)) {
+ *VRes = 768;
+ }
+
+ *Refresh = (pEDID->standardTimingIdentifications[TimingNumber].ImageAspectRatioAndrefresh & 0x1F) + 60;
+
+ return TRUE;
+}
+
+/**
+Extract the resolutions and refresh rate from one of the entries in the Detailed Timings section of the EDID.
+
+@param EDID Pointer to the 128-byte EDID
+@param timingNumber The entry that we want to extract
+@param videoMode Output - Filled in with details from the detailed timing
+@retval TRUE The requested Detailed Timings entry contains valid data
+
+**/
+STATIC BOOLEAN
+ReadDetailedTiming (
+ IN CONST VOID *EDID,
+ IN UINT8 TimingNumber,
+ OUT struct VideoMode *VideoMode
+ )
+{
+ if (TimingNumber >= EDID_NUMBER_OF_DETAILED_TIMINGS) {
+ return FALSE;
+ }
+
+ UINT16 NumValidDetailedTimingsFound;
+ NumValidDetailedTimingsFound = 0;
+
+ // Spin through the detailed timings until we find a valid one - then check if this has the index that we want
+ int BlockNumber;
+ for (BlockNumber = 0; BlockNumber < EDID_NUMBER_OF_DETAILED_TIMINGS; BlockNumber++) {
+ CONST struct Edid *pEDID = (CONST struct Edid *)EDID;
+ CONST struct DetailedTimingIdentification *pTiming = &pEDID->detailedTimingDescriptions[BlockNumber];
+
+ if (((BlockNumber == 0) && (pTiming->PixelClock == EDID_DETAILED_TIMING_INVALID_PIXEL_CLOCK)) ||
+ (pTiming->PixelClock == 0)) {
+ // This is not a valid detailed timing descriptor
+ continue;
+ }
+
+ if ((pTiming->Features & EdidDetailedTimingsFeaturesSyncSchemeMask) != EdidDetailedTimingsFeaturesSyncSchemeMask)
{
+ DEBUG ((DEBUG_INFO, "EDID detailed timing with unsupported sync scheme found - not processing.\n"));
+ continue;
+ }
+
+ if ((pTiming->Features & EdidDetailedTimingsFeaturesStereoModeMask) != 0) {
+ DEBUG ((DEBUG_INFO, "EDID detailed timing with unsupported stereo mode found - not processing.\n"));
+ continue;
+ }
+
+ // We've found a supported detailed timing - now see if this is the requested one
+ if (TimingNumber != NumValidDetailedTimingsFound) {
+ NumValidDetailedTimingsFound++;
+ continue;
+ }
+
+ ZeroMem ((VOID *)VideoMode, sizeof (struct VideoMode));
+
+ // Bit manipulations copied from host software class EDIDTimingDescriptor
+
+ VideoMode->PixelClock = (UINT16)pTiming->PixelClock;
+ VideoMode->HActive = pTiming->HActiveLo + ((pTiming->HActiveHiBlankingHi & 0xF0) << 4);
+ VideoMode->VActive = pTiming->VActiveLo + ((pTiming->VActiveHiBlankingHi & 0xF0) << 4);
+
+ VideoMode->HBlanking = pTiming->HBlankingLo + ((pTiming->HActiveHiBlankingHi & 0x0F) << 8);
+ VideoMode->VBlanking = pTiming->VBlankingLo + ((pTiming->VActiveHiBlankingHi & 0x0F) << 8);
+
+ VideoMode->HSyncOffset = pTiming->HSyncOffsetLo + ((pTiming->HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi
& 0xC0) << 2); // Horizontal Front Porch
+ VideoMode->HSyncWidth = pTiming->HSyncWidthLo + ((pTiming->HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi
& 0x30) << 4);
+
+ VideoMode->VSyncOffset = ((pTiming->VSyncOffsetLoSyncWidthLo & 0xF0) >> 4) + ((pTiming-
HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi & 0x0C) << 2); // Vertical Front Porch
+ VideoMode->VSyncWidth = (pTiming->VSyncOffsetLoSyncWidthLo & 0x0F) + ((pTiming-
HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi & 0x03) << 4);
+
+ VideoMode->Reserved2 = 2;
+ VideoMode->Accumulate = 1;
+
+ // Horizontal and vertical sync inversions - positive if bit set in descriptor (EDID spec)
+ // In the VideoMode, they are negative if the bit is set (NR-110497-TC 4.3.3 0x22 Set Video Mode)
+
+ // Horizontal sync
+ if ((pTiming->Features & EdidDetailedTimingsFeaturesHorizontalSyncPositive) == 0) {
+ VideoMode->Flags |= VideoModeFlagsHorizontalSyncInverted;
+ }
+ // Vertical sync
+ if ((pTiming->Features & EdidDetailedTimingsFeaturesVerticalSyncPositive) == 0) {
+ VideoMode->Flags |= VideoModeFlagsVerticalSyncInverted;
+ }
+ // Interlace
+ if ((pTiming->Features & EdidDetailedTimingsFeaturesInterlaced) == EdidDetailedTimingsFeaturesInterlaced) {
+ VideoMode->Flags |= VideoModeFlagsInterlaced;
+ }
+
+ DEBUG ((DEBUG_INFO, "Read mode %dx%d from detailed timings\n", VideoMode->HActive, VideoMode->VActive));
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/**
+Check if a particular video mode is in either the Established or Standard Timings section of the EDID.
+
+@param EDID Pointer to the 128-byte EDID
+@param hRes Horizontal resolution
+@param vRes Vertical resolution
+@param refresh Refresh rate
+@retval TRUE The requested mode is present in the EDID
+
+**/
+STATIC BOOLEAN
+IsModeInEdid (
+ IN CONST VOID *EDID,
+ IN UINT16 HRes,
+ IN UINT16 VRes,
+ IN UINT16 Refresh
+ )
+{
+ UINT16 EdidHRes;
+ UINT16 EdidVRes;
+ UINT8 EdidRefresh;
+ BOOLEAN ModeSupported;
+
+ ModeSupported = IsModeInEstablishedTimings (EDID, HRes, VRes, Refresh);
+
+ if (ModeSupported == FALSE) {
+ // Check if the mode is in the Standard Timings section of the EDID
+ UINT8 i;
+ for (i = 0; i < EDID_NUMBER_OF_STANDARD_TIMINGS; i++) {
+ if (TRUE == ReadStandardTiming (EDID, i, &EdidHRes, &EdidVRes, &EdidRefresh)) {
+ if ((HRes == EdidHRes) && (VRes == EdidVRes) && (Refresh == EdidRefresh)) {
+ ModeSupported = TRUE;
+ break;
+ }
+ }
+ }
+ }
+ return ModeSupported;
+}
+
+/**
+Returns the (index)'th entry from the list of pre-calculated video timings that is also present in the EDID,
+or, video mode data corresponding to any detailed timings present in the EDID.
+
+Like QueryVideoMode, finds the number (and contents) of video modes available by repeatedly calling this function
+with an increasing index value, until it returns FALSE
+@param index The caller wants the _index_'th video mode
+@param EDID Pointer to the 128-byte EDID
+@param edidSize Size in bytes of the EDID
+@param videoMode Video timings extracted from the modeData structure
+@retval EFI_SUCCESS The requested mode is present in the EDID
+@retval EFI_INVALID_PARAMETER The requested mode is not present in the EDID
+**/
+EFI_STATUS
+DlEdidGetSupportedVideoMode (
+ IN UINT32 Index,
+ IN CONST VOID *EDID,
+ IN UINT32 EdidSize,
+ OUT CONST struct VideoMode **VideoMode
+ )
+{
+ UINTN SupportedVideoModesFoundInEdid;
+ EFI_STATUS Status;
+
+ SupportedVideoModesFoundInEdid = 0;
+ Status = EFI_INVALID_PARAMETER;
+
+ // If we didn't manage to find an EDID earlier, just use one of the hard-coded video modes
+ if ((EDID == NULL) || (EdidSize != EDID_BLOCK_SIZE)) {
+ if (Index >= DlVideoModeGetNumSupportedVideoModes ()) {
+ return EFI_INVALID_PARAMETER;
+ }
+ else {
+ *VideoMode = DlVideoModeGetSupportedVideoMode (Index);
+ DEBUG ((DEBUG_WARN, "No monitor EDID loaded - returning mode from default list (%dx%d)\n", (*VideoMode)-
HActive, (*VideoMode)->VActive));
+ return EFI_SUCCESS;
+ }
+ }
+
+ UINT16 ModeNumber;
+ for (ModeNumber = 0; ModeNumber < DlVideoModeGetNumSupportedVideoModes (); ModeNumber++) {
+
+ CONST struct VideoMode *SupportedVideoMode = DlVideoModeGetSupportedVideoMode (ModeNumber);
+ ASSERT (SupportedVideoMode);
+
+ if (IsModeInEdid (EDID, SupportedVideoMode->HActive, SupportedVideoMode->VActive,
DISPLAYLINK_FIXED_VERTICAL_REFRESH_RATE)) {
+ if (Index == SupportedVideoModesFoundInEdid) {
+ *VideoMode = SupportedVideoMode;
+ Status = EFI_SUCCESS;
+ break;
+ }
+ SupportedVideoModesFoundInEdid++;
+ }
+ }
+
+ if (EFI_ERROR (Status)) {
+ // Have a look in the detailed timings
+ UINTN DetailedTimingNumber;
+ STATIC struct VideoMode TmpVideoMode;
+ DetailedTimingNumber = Index - SupportedVideoModesFoundInEdid;
+
+ if (DetailedTimingNumber < EDID_NUMBER_OF_DETAILED_TIMINGS) {
+ if (ReadDetailedTiming (EDID, (UINT8)DetailedTimingNumber, &TmpVideoMode)) {
+ *VideoMode = &TmpVideoMode;
+ Status = EFI_SUCCESS;
+ }
+ }
+ }
+
+ return Status;
+}
+
+/**
+ * Like GetSupportedEdidVideoMode, but will return a fallback fixed mode of 640x480@60Hz
+ * for index 0 if no suitable modes found in EDID.
+ * @param index
+ * @param EDID
+ * @param edidSize
+ * @param videoMode
+ * @return EFI_SUCCESS
+ */
+EFI_STATUS
+DlEdidGetSupportedVideoModeWithFallback (
+ IN UINT32 Index,
+ IN CONST VOID *EDID,
+ IN UINT32 EdidSize,
+ OUT CONST struct VideoMode **VideoMode
+ )
+{
+ EFI_STATUS Status;
+ Status = DlEdidGetSupportedVideoMode (Index, EDID, EdidSize, VideoMode);
+
+ if (EFI_ERROR (Status)) {
+ // Special case - if we didn't find any matching video modes in the EDID, fall back to 640x480@60Hz
+ if (Index == 0) {
+ *VideoMode = DlVideoModeGetSupportedVideoMode (0);
+ DEBUG ((DEBUG_WARN, "No video modes supported by driver found in monitor EDID received from DL device - falling
back to %dx%d\n", (*VideoMode)->HActive, (*VideoMode)->VActive));
+ Status = EFI_SUCCESS;
+ }
+ }
+
+ return Status;
+}
+
+/**
+Count the number of video modes that we have timing information for that are present in the EDID
+@param EDID Pointer to the 128-byte EDID
+@param edidSize
+@retval The number of modes in the EDID
+
+**/
+UINT32
+DlEdidGetNumSupportedModesInEdid (
+ IN CONST VOID *EDID,
+ IN UINT32 EdidSize
+ )
+{
+ UINT32 MaxMode;
+
+ if ((EDID == NULL) || (EdidSize != EDID_BLOCK_SIZE)) {
+ return DlVideoModeGetNumSupportedVideoModes ();
+ }
+
+ for (MaxMode = 0; ; MaxMode++) {
+ CONST struct VideoMode *videoMode;
+ if (EFI_ERROR (DlEdidGetSupportedVideoMode (MaxMode, EDID, EdidSize, &videoMode))) {
+ break;
+ }
+ }
+ DEBUG ((DEBUG_INFO, "Found %d video modes supported by driver in monitor EDID.\n", MaxMode));
+ return MaxMode;
+}
+
+
+
+/**
+ * Read the EDID from the connected monitor, store it in the local data structure
+ * @param UsbDisplayLinkDev
+ * @retval EFI_OUT_OF_RESOURCES - Could not allocate memory
+ * @retval EFI_SUCCESS
+ */
+EFI_STATUS
+DlReadEdid (
+ IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev
+ )
+{
+ EFI_STATUS Status;
+ BOOLEAN EdidFound;
+ EFI_EDID_OVERRIDE_PROTOCOL* EdidOverride;
+
+ //
+ // setup EDID information
+ //
+ UsbDisplayLinkDev->EdidDiscovered.Edid = (UINT8 *)NULL;
+ UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid = 0;
+
+ EdidFound = FALSE;
+
+ //
+ // Find EDID Override protocol firstly, this protocol is installed by platform if needed.
+ //
+ Status = gBS->LocateProtocol (&gEfiEdidOverrideProtocolGuid, NULL, (VOID**)&EdidOverride);
+
+ if (!EFI_ERROR (Status)) {
+ UINT32 EdidAttributes = 0xff;
+ UINTN EdidDataSize = 0;
+ UINT8* EdidDataBlock = (UINT8*)NULL;
+
+ // Allocate double size of VESA_BIOS_EXTENSIONS_EDID_BLOCK_SIZE to avoid overflow
+ EdidDataBlock = (UINT8*)AllocatePool (EDID_BLOCK_SIZE * 2);
+
+ if (NULL == EdidDataBlock) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = EdidOverride->GetEdid (
+ EdidOverride,
+ &UsbDisplayLinkDev->Handle,
+ &EdidAttributes,
+ &EdidDataSize,
+ &EdidDataBlock);
+
+ if (!EFI_ERROR (Status) && EdidAttributes == 0 && EdidDataSize != 0) {
+ UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid = (UINT32)EdidDataSize;
+ UsbDisplayLinkDev->EdidDiscovered.Edid = EdidDataBlock;
+ EdidFound = TRUE;
+ }
+ else {
+ FreePool (EdidDataBlock);
+ EdidDataBlock = NULL;
+ }
+ }
+
+ if (EdidFound != TRUE) {
+ UINTN EdidDataSize = 0;
+ UINT8* EdidDataBlock = (UINT8*)NULL;
+
+ if (ReadEdidData (UsbDisplayLinkDev, &EdidDataBlock, &EdidDataSize) == EFI_SUCCESS) {
+
+ if (IsEdidChecksumCorrect (EdidDataBlock)) {
+ UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid = (UINT32)EdidDataSize;
+ UsbDisplayLinkDev->EdidDiscovered.Edid = EdidDataBlock;
+ EdidFound = TRUE;
+ } else {
+ DEBUG ((DEBUG_WARN, "Monitor EDID received from DisplayLink device had an invalid checksum. Corrupted?\n"));
+ }
+ }
+ }
+
+ if (EdidFound == FALSE) {
+ DEBUG ((DEBUG_WARN, "No valid monitor EDID received from DisplayLink device. Cannot detect resolutions supported by
monitor.\n"));
+ }
+
+ // Set the EDID active.
+ // In an error case this will be set 0/NULL, which flags to the parsing code that there is no EDID.
+ UsbDisplayLinkDev->EdidActive.SizeOfEdid = UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid;
+ UsbDisplayLinkDev->EdidActive.Edid = UsbDisplayLinkDev->EdidDiscovered.Edid;
+
+ return EFI_SUCCESS;
+}
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.h
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.h
new file mode 100644
index 000000000000..a1b8a0512d1a
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Edid.h
@@ -0,0 +1,129 @@
+/** @file Edid.h
+ * @brief Helper routine and corresponding data struct used by USB DisplayLink Driver.
+ * Reads and parses the EDID, checks if a requested video mode is in the supplied EDID
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#ifndef EDID_H
+#define EDID_H
+
+#include "UsbDisplayLink.h"
+
+#define EDID_HEADER_SIZE ((UINTN)8)
+#define EDID_NUMBER_OF_ESTABLISHED_TIMINGS_BYTES ((UINTN)3)
+#define EDID_NUMBER_OF_STANDARD_TIMINGS ((UINTN)8)
+#define EDID_NUMBER_OF_DETAILED_TIMINGS ((UINTN)4)
+
+
+typedef struct {
+ UINT16 HRes;
+ UINT16 VRes;
+ UINT16 Refresh;
+} EDID_TIMING;
+
+
+EFI_STATUS
+DlEdidGetSupportedVideoMode (
+ UINT32 ModeNumber,
+ CONST VOID *EDID,
+ UINT32 EdidSize,
+ CONST struct VideoMode **VideoMode
+ );
+
+EFI_STATUS
+DlEdidGetSupportedVideoModeWithFallback (
+ UINT32 ModeNumber,
+ CONST VOID *EDID,
+ UINT32 EdidSize,
+ CONST struct VideoMode **VideoMode
+ );
+
+UINT32
+DlEdidGetNumSupportedModesInEdid (
+ CONST VOID *EDID,
+ UINT32 EdidSize
+ );
+
+EFI_STATUS
+DlReadEdid (
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev
+);
+
+// EDID Detailed timings section - Features
+enum EdidDetailedTimingsFeatures {
+ EdidDetailedTimingsFeaturesInterlaced = 0x80,
+ EdidDetailedTimingsFeaturesStereoModeMask = 0x60,
+ EdidDetailedTimingsFeaturesSyncSchemeMask = 0x18,
+ EdidDetailedTimingsFeaturesHorizontalSyncPositive = 0x02,
+ EdidDetailedTimingsFeaturesVerticalSyncPositive = 0x04,
+};
+
+// NR-110497-TC-7ZM Section 4.3.3 0x22 Set Video Mode - Flags
+enum VideoModeFlags {
+ VideoModeFlagsInterlaced = 0x0001,
+ VideoModeFlagsHorizontalSyncInverted = 0x0100,
+ VideoModeFlagsVerticalSyncInverted = 0x0200,
+};
+
+struct StandardTimingIdentification {
+ UINT8 HorizontalActivePixels; // X resolution, from 256->2288 in increments of 8 pixels
+ UINT8 ImageAspectRatioAndrefresh; // Bits 7,6 Aspect ratio - 0=16:10 1=4:3 2=5:4 3=16:9
+ // Bits 5,0 Refresh rate Range 60->1213Hz
+};
+
+struct DetailedTimingIdentification {
+ UINT16 PixelClock; // wPixelClock in VideoMode struct
+ UINT8 HActiveLo; // wHActive
+ UINT8 HBlankingLo; // wHBlanking
+ UINT8 HActiveHiBlankingHi;
+ UINT8 VActiveLo; // wVActive
+ UINT8 VBlankingLo; // wVBlanking
+ UINT8 VActiveHiBlankingHi;
+ UINT8 HSyncOffsetLo; // wHSyncOffset, front porch
+ UINT8 HSyncWidthLo; // wHSyncWidth
+ UINT8 VSyncOffsetLoSyncWidthLo;
+ UINT8 HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi;
+ UINT8 HImageSizeHi;
+ UINT8 VImageSizeHi;
+ UINT8 HImageSizeLoVImageSizeLo;
+ UINT8 HBorder;
+ UINT8 VBorder;
+ UINT8 Features;
+};
+
+struct Edid {
+ UINT8 Header[EDID_HEADER_SIZE]; //EDID header "00 FF FF FF FF FF FF 00"
+ UINT16 ManufactureName; //EISA 3-character ID
+ UINT16 ProductCode; //Vendor assigned code
+ UINT32 SerialNumber; //32-bit serial number
+ UINT8 WeekOfManufacture; //Week number
+ UINT8 YearOfManufacture; //Year
+ UINT8 EdidVersion; //EDID Structure Version
+ UINT8 EdidRevision; //EDID Structure Revision
+ UINT8 VideoInputDefinition;
+ UINT8 MaxHorizontalImageSize; //cm
+ UINT8 MaxVerticalImageSize; //cm
+ UINT8 DisplayTransferCharacteristic;
+ UINT8 FeatureSupport;
+ UINT8 RedGreenLowBits; //Rx1 Rx0 Ry1 Ry0 Gx1 Gx0 Gy1Gy0
+ UINT8 BlueWhiteLowBits; //Bx1 Bx0 By1 By0 Wx1 Wx0 Wy1 Wy0
+ UINT8 RedX; //Red-x Bits 9 - 2
+ UINT8 RedY; //Red-y Bits 9 - 2
+ UINT8 GreenX; //Green-x Bits 9 - 2
+ UINT8 GreenY; //Green-y Bits 9 - 2
+ UINT8 BlueX; //Blue-x Bits 9 - 2
+ UINT8 BlueY; //Blue-y Bits 9 - 2
+ UINT8 WhiteX; //White-x Bits 9 - 2
+ UINT8 WhiteY; //White-x Bits 9 - 2
+ UINT8 EstablishedTimings[EDID_NUMBER_OF_ESTABLISHED_TIMINGS_BYTES];
+ struct StandardTimingIdentification standardTimingIdentifications[EDID_NUMBER_OF_STANDARD_TIMINGS];
+ struct DetailedTimingIdentification detailedTimingDescriptions[EDID_NUMBER_OF_DETAILED_TIMINGS];
+ UINT8 ExtensionFlag; //Number of (optional) 128-byte EDID extension blocks to follow
+ UINT8 Checksum;
+};
+
+#endif // EDID_H
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Gop.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Gop.c
new file mode 100644
index 000000000000..3e483afdba72
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/Gop.c
@@ -0,0 +1,578 @@
+/**
+ * @file Gop.c
+ * @brief UEFI GOP protocol API implementation for USB DisplayLink driver.
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+#include "Edid.h"
+
+
+/**
+ *
+ * @param This Pointer to the instance of the GOP protocol
+ * @param BltOperation
+ * @param SourceX
+ * @param SourceY
+ * @param Width
+ * @param Height
+ * @param DestinationX
+ * @param DestinationY
+ * @return
+ */
+STATIC EFI_STATUS
+CheckBounds (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL* This,
+ IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY
+ )
+{
+ USB_DISPLAYLINK_DEV *UsbDisplayLinkDev;
+ EFI_GRAPHICS_OUTPUT_PROTOCOL* Gop;
+
+ UsbDisplayLinkDev = USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(This);
+ Gop = &UsbDisplayLinkDev->GraphicsOutputProtocol;
+
+ CONST EFI_GRAPHICS_OUTPUT_MODE_INFORMATION* ScreenMode = Gop->Mode->Info;
+
+ if (BltOperation == EfiBltVideoToBltBuffer || BltOperation == EfiBltVideoToVideo) {
+ if (SourceY + Height > ScreenMode->VerticalResolution) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (SourceX + Width > ScreenMode->HorizontalResolution) {
+ return EFI_INVALID_PARAMETER;
+ }
+ }
+
+ if (BltOperation == EfiBltBufferToVideo
+ || BltOperation == EfiBltVideoToVideo
+ || BltOperation == EfiBltVideoFill) {
+ if (DestinationY + Height > ScreenMode->VerticalResolution) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (DestinationX + Width > ScreenMode->HorizontalResolution) {
+ return EFI_INVALID_PARAMETER;
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+/**
+ * Update the local copy of the Frame Buffer. This local copy is periodically transmitted to the
+ * DisplayLink device (via DlGopSendScreenUpdate)
+ * @param UsbDisplayLinkDev
+ * @param BltBuffer
+ * @param BltOperation
+ * @param SourceX
+ * @param SourceY
+ * @param DestinationX
+ * @param DestinationY
+ * @param Width
+ * @param Height
+ * @param BltBufferStride
+ * @param PixelsPerScanLine
+ */
+STATIC VOID
+BuildBackBuffer (
+ IN USB_DISPLAYLINK_DEV *UsbDisplayLinkDev,
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
+ IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN BltBufferStride,
+ IN UINTN PixelsPerScanLine
+)
+{
+ UINTN H;
+ UINTN W;
+ switch (BltOperation) {
+ case EfiBltVideoToBltBuffer:
+ {
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* Blt;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* SrcB;
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL*)((UINT8 *)BltBuffer + (DestinationY * BltBufferStride) + DestinationX * sizeof
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ SrcB = UsbDisplayLinkDev->Screen + SourceY * PixelsPerScanLine + SourceX;
+
+ for (H = 0; H < Height; H++) {
+ for (W = 0; W < Width; W++) {
+ Blt[W] = *SrcB++;
+ }
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL*)(((UINT8*)Blt) + BltBufferStride);
+ SrcB += PixelsPerScanLine - Width;
+ }
+ }
+ break;
+
+ case EfiBltBufferToVideo:
+ {
+ // Update the store of the area of the screen that is "dirty" - that we need to send in the next screen update.
+ if (DestinationY < UsbDisplayLinkDev->LastY1) {
+ UsbDisplayLinkDev->LastY1 = DestinationY;
+ }
+ if ((DestinationY + Height) > UsbDisplayLinkDev->LastY2) {
+ UsbDisplayLinkDev->LastY2 = DestinationY + Height;
+ }
+
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* Blt;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* DstB;
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)(((UINT8 *)BltBuffer) + (SourceY * BltBufferStride) + SourceX * sizeof *Blt);
+ DstB = UsbDisplayLinkDev->Screen + DestinationY * PixelsPerScanLine + DestinationX;
+
+ for (H = 0; H < Height; H++) {
+ for (W = 0; W < Width; W++) {
+ *DstB++ = Blt[W];
+ }
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL*)(((UINT8*)Blt) + BltBufferStride);
+ DstB += PixelsPerScanLine - Width;
+ }
+ }
+ break;
+
+ case EfiBltVideoToVideo:
+ {
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* SrcB;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* DstB;
+ SrcB = UsbDisplayLinkDev->Screen + SourceY * PixelsPerScanLine + SourceX;
+ DstB = UsbDisplayLinkDev->Screen + DestinationY * PixelsPerScanLine + DestinationX;
+
+ for (H = 0; H < Height; H++) {
+ for (W = 0; W < Width; W++) {
+ *DstB++ = *SrcB++;
+ }
+ SrcB += PixelsPerScanLine - Width;
+ DstB += PixelsPerScanLine - Width;
+ }
+ }
+ break;
+
+ case EfiBltVideoFill:
+ {
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* DstB;
+ DstB = UsbDisplayLinkDev->Screen + DestinationY * PixelsPerScanLine + DestinationX;
+ for (H = 0; H < Height; H++) {
+ for (W = 0; W < Width; W++) {
+ *DstB++ = *BltBuffer;
+ }
+ DstB += PixelsPerScanLine - Width;
+ }
+ }
+ break;
+ default: break;
+ }
+}
+
+/**
+ * Display a colour bar pattern on the DisplayLink device.
+ * @param UsbDisplayLinkDev
+ * @param PatternNumber
+ * @return
+ */
+EFI_STATUS
+DlGopSendTestPattern (
+ IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev,
+ IN UINTN PatternNumber)
+{
+ EFI_STATUS Status;
+ UINTN DataLen;
+ UINT8 *DstBuf;
+ UINT32 USBStatus;
+
+ Status = EFI_SUCCESS;
+ DataLen = UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution * 3; // Send 1 line @ 24 bits per
pixel
+ DstBuf = AllocateZeroPool (DataLen);
+
+ if (DstBuf == NULL) {
+ DEBUG ((DEBUG_ERROR, "SendTestPattern Failed to allocate memory\n"));
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ //DEBUG ((DEBUG_ERROR, "Called DlGopSendTestPattern %d\n", PatternNumber));
+
+ CONST UINT8 RedPixel[3] = { 0xFF, 0x00, 0x00 };
+ CONST UINT8 GreenPixel[3] = { 0x00, 0xFF, 0x00 };
+ CONST UINT8 BluePixel[3] = { 0x00, 0x00, 0xFF };
+ CONST UINT8 YellowPixel[3] = { 0xFF, 0xFF, 0x00 };
+ CONST UINT8 MagentaPixel[3] = { 0xFF, 0x00, 0xFF };
+ CONST UINT8 CyanPixel[3] = { 0x00, 0xFF, 0xFF };
+
+ UINTN Row;
+ UINTN Column;
+ for (Row = 0; Row < UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->VerticalResolution; Row++) {
+ for (Column = 0; Column < UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution; Column++) {
+
+ if (0 == PatternNumber) {
+ if (Row < UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->VerticalResolution / 3) {
+ CopyMem (&DstBuf[Column * 3], RedPixel, sizeof (RedPixel));
+ }
+ else if (Row < (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->VerticalResolution * 2) / 3)
+ {
+ CopyMem (&DstBuf[Column * 3], GreenPixel, sizeof (GreenPixel));
+ }
+ else {
+ CopyMem (&DstBuf[Column * 3], BluePixel, sizeof (BluePixel));
+ }
+ }
+ else {
+ if (Column < UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution / 3) {
+ CopyMem (&DstBuf[Column * 3], YellowPixel, sizeof (RedPixel));
+ }
+ else if (Column < (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution * 2) / 3)
+ {
+ CopyMem (&DstBuf[Column * 3], MagentaPixel, sizeof (GreenPixel));
+ }
+ else {
+ CopyMem (&DstBuf[Column * 3], CyanPixel, sizeof (BluePixel));
+ }
+ }
+ }
+ DlUsbBulkWrite (UsbDisplayLinkDev, DstBuf, DataLen, &USBStatus);
+ }
+ // Payload with length of 1 to terminate the frame
+ DlUsbBulkWrite (UsbDisplayLinkDev, DstBuf, 1, &USBStatus);
+ FreePool (DstBuf);
+
+ return Status;
+}
+
+
+/**
+ * Transfer the latest copy of the Blt buffer over USB to the DisplayLink device
+ * @param UsbDisplayLinkDev
+ * @return
+ */
+EFI_STATUS
+DlGopSendScreenUpdate (
+ IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev
+ )
+{
+ EFI_STATUS Status;
+ UINT32 USBStatus;
+ Status = EFI_SUCCESS;
+
+ // If it has been a while since we sent an update, send a full screen.
+ // This allows us to update a hot-plugged monitor quickly.
+ if (UsbDisplayLinkDev->TimeSinceLastScreenUpdate > DISPLAYLINK_FULL_SCREEN_UPDATE_PERIOD) {
+ UsbDisplayLinkDev->LastY1 = 0;
+ UsbDisplayLinkDev->LastY2 = UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution - 1;
+ }
+
+ // If there has been no BLT since the last update/poll, drop out quietly.
+ if (UsbDisplayLinkDev->LastY2 < UsbDisplayLinkDev->LastY1) {
+ UsbDisplayLinkDev->TimeSinceLastScreenUpdate += (DISPLAYLINK_SCREEN_UPDATE_TIMER_PERIOD / 1000); // Convert
us to ms
+ return EFI_SUCCESS;
+ }
+
+ UsbDisplayLinkDev->TimeSinceLastScreenUpdate = 0;
+
+ EFI_TPL OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
+
+ UINTN DataLen;
+ UINTN Width;
+ UINTN Height;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL* SrcPtr;
+ UINT8* DstPtr;
+ UINT8 DstBuffer[1920 * 3]; // Get rid of the magic numbers at some point
+ // Could also use a buffer allocated at runtime to store the line, stored in the USB_DISPLAYLINK_DEV
structure.
+ UINTN H;
+
+ DataLen = UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution * 3; // Send 1 line @ 24 bits per
pixel
+ Width = UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->HorizontalResolution;
+ Height = UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info->VerticalResolution;
+ SrcPtr = UsbDisplayLinkDev->Screen;
+ DstPtr = DstBuffer;
+
+ for (H = 0; H < Height; H++) {
+ DstPtr = DstBuffer;
+
+ UINTN W;
+ for (W = 0; W < Width; W++) {
+ // Need to swap round the RGB values
+ DstPtr[0] = ((UINT8 *)SrcPtr)[2];
+ DstPtr[1] = ((UINT8 *)SrcPtr)[1];
+ DstPtr[2] = ((UINT8 *)SrcPtr)[0];
+ SrcPtr++;
+ DstPtr += 3;
+ }
+
+ Status = DlUsbBulkWrite (UsbDisplayLinkDev, DstBuffer, DataLen, &USBStatus);
+
+ // USBStatus values defined in usbio.h, e.g. EFI_USB_ERR_TIMEOUT 0x40
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Screen update - USB bulk transfer of pixel data failed. Line %d len %d, failure code %r USB
status x%x\n", H, DataLen, Status, USBStatus));
+ break;
+ }
+ // Need an extra DlUsbBulkWrite if the data length is divisible by USB MaxPacketSize. This spare data will just get written
into the (invisible) stride area.
+ // Note that the API doesn't let us do a bulk write of 0.
+ if ((DataLen & (UsbDisplayLinkDev->BulkOutEndpointDescriptor.MaxPacketSize - 1)) == 0) {
+ Status = DlUsbBulkWrite (UsbDisplayLinkDev, DstBuffer, 2, &USBStatus);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Screen update - USB bulk transfer of pixel data failed. Line %d len %d, failure code %r USB
status x%x\n", H, DataLen, Status, USBStatus));
+ break;
+ }
+ }
+ }
+
+ if (!EFI_ERROR (Status)) {
+ // If we've successfully transmitted the frame, reset the values that store which area of the screen has been BLTted to.
+ // If we haven't succeeded, this will mean we'll try to resend it after the next poll period.
+ UsbDisplayLinkDev->LastY2 = 0;
+ UsbDisplayLinkDev->LastY1 = (UINTN)-1;
+ }
+
+ // Payload with length of 1 to terminate the frame
+ // We need to do this even if we had an error, to indicate to the DL device that it should now expect a new frame.
+ DlUsbBulkWrite (UsbDisplayLinkDev, DstBuffer, 1, &USBStatus);
+
+ gBS->RestoreTPL (OriginalTPL);
+
+ return Status;
+}
+
+/**
+ * Calculate the video refresh rate from the video timing parameters (pixel clock etc)
+ * @param videoMode
+ * @return
+ */
+#ifndef MDEPKG_NDEBUG
+STATIC inline UINT16
+CalculateRefreshRate (
+ IN CONST struct VideoMode *VideoMode)
+{
+ UINT16 RefreshRate;
+ UINT16 Rmod;
+ UINT16 Rate10Hz;
+
+ RefreshRate = (VideoMode->PixelClock * 10000) / ((VideoMode->HActive + VideoMode->HBlanking) * (VideoMode->VActive
+ VideoMode->VBlanking));
+ Rmod = RefreshRate % 10;
+ Rate10Hz = RefreshRate - Rmod;
+
+ if (Rmod >= 5) {
+ Rate10Hz += 10;
+ }
+ return Rate10Hz;
+}
+#endif // MDEPKG_NDEBUG
+/*
***************************************************************************************************** */
+/*
***************************************************************************************************** */
+/* ****************** START OF FUNCTIONS WHICH IMPLEMENT GOP INTERFACE ****************** */
+/*
***************************************************************************************************** */
+/*
***************************************************************************************************** */
+
+
+/**
+ *
+ * @param Gop Pointer to the instance of the GOP protocol
+ * @param ModeNumber
+ * @param SizeOfInfo
+ * @param Info
+ * @return
+ */
+EFI_STATUS
+EFIAPI
+DisplayLinkQueryMode (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop,
+ IN UINT32 ModeNumber,
+ OUT UINTN *SizeOfInfo,
+ OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info
+)
+{
+ USB_DISPLAYLINK_DEV *Dev;
+ CONST struct VideoMode *VideoMode;
+ EFI_STATUS Status;
+
+ Dev = USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(Gop);
+ Status = EFI_INVALID_PARAMETER;
+
+ if ((SizeOfInfo == NULL) || (Info == NULL)) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Get a video mode from the EDID
+ Status = DlEdidGetSupportedVideoModeWithFallback (ModeNumber, Dev->EdidActive.Edid, Dev->EdidActive.SizeOfEdid,
&VideoMode);
+
+ if (!EFI_ERROR (Status)) {
+
+ *Info = (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION*)AllocatePool (sizeof
(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
+ if (*Info == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ DEBUG ((DEBUG_INFO, "BIOS querying mode number %d - returning %dx%d @ %dHz\n", ModeNumber, VideoMode-
HActive, VideoMode->VActive, CalculateRefreshRate (VideoMode)));
+
+ *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
+
+ (*Info)->Version = 0;
+ (*Info)->HorizontalResolution = VideoMode->HActive;
+ (*Info)->VerticalResolution = VideoMode->VActive;
+ (*Info)->PixelFormat = PixelBltOnly;
+ (*Info)->PixelsPerScanLine = (*Info)->HorizontalResolution;
+ (*Info)->PixelInformation.RedMask = 0;
+ (*Info)->PixelInformation.GreenMask = 0;
+ (*Info)->PixelInformation.BlueMask = 0;
+ (*Info)->PixelInformation.ReservedMask = 0;
+ }
+ return Status;
+}
+
+/**
+ *
+ * @param Gop Pointer to the instance of the GOP protocol
+ * @param ModeNumber
+ * @return
+ */
+EFI_STATUS
+EFIAPI
+DisplayLinkSetMode (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop,
+ IN UINT32 ModeNumber
+)
+{
+ USB_DISPLAYLINK_DEV *UsbDisplayLinkDev;
+ EFI_STATUS Status;
+ CONST struct VideoMode *VideoMode;
+
+ UsbDisplayLinkDev = USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(Gop);
+
+ // Prevent the DisplayLinkPeriodicTimer from interrupting us (bug 28877).
+ // When the driver is manually loaded, the TPL is TPL_NOTIFY (16) which prevents the interrupt from the timer.
+ // When the GOP driver is sideloaded, the TPL of this call is TPL_APPLICATION (4) and the timer can interrupt us.
+ Gop->Mode->Mode = GRAPHICS_OUTPUT_INVALID_MODE_NUMBER;
+
+ // Get a video mode from the EDID
+ Status = DlEdidGetSupportedVideoModeWithFallback (ModeNumber, UsbDisplayLinkDev->EdidActive.Edid,
UsbDisplayLinkDev->EdidActive.SizeOfEdid, &VideoMode);
+
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ Gop->Mode->Info->Version = 0;
+ Gop->Mode->Info->HorizontalResolution = VideoMode->HActive;
+ Gop->Mode->Info->VerticalResolution = VideoMode->VActive;
+ Gop->Mode->Info->PixelFormat = PixelBltOnly;
+ Gop->Mode->Info->PixelsPerScanLine = Gop->Mode->Info->HorizontalResolution;
+ Gop->Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
+ Gop->Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS)(UINTN)NULL;
+ Gop->Mode->FrameBufferSize = 0;
+
+ //
+ // Allocate the back buffer
+ //
+ if (UsbDisplayLinkDev->Screen != NULL) {
+ FreePool (UsbDisplayLinkDev->Screen);
+ }
+
+ UsbDisplayLinkDev->Screen = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL*)AllocateZeroPool (
+ Gop->Mode->Info->HorizontalResolution *
+ Gop->Mode->Info->VerticalResolution *
+ sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+
+ if (UsbDisplayLinkDev->Screen == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ DEBUG ((DEBUG_INFO, "Video mode %d selected by BIOS - %d x %d.\n", ModeNumber, VideoMode->HActive, VideoMode-
VActive));
+ // Wait until we are sure that we can set the video mode before we tell the firmware
+ Status = DlUsbSendControlWriteMessage (UsbDisplayLinkDev, SET_VIDEO_MODE, 0, VideoMode, sizeof (struct
VideoMode));
+
+ if (Status != EFI_SUCCESS) {
+ // Flag up that we haven't set the video mode correctly yet.
+ DEBUG ((DEBUG_ERROR, "Failed to send USB message to DisplayLink device to set monitor video mode. Monitor
connected correctly?\n"));
+ Gop->Mode->Mode = GRAPHICS_OUTPUT_INVALID_MODE_NUMBER;
+ FreePool (UsbDisplayLinkDev->Screen);
+ UsbDisplayLinkDev->Screen = NULL;
+ } else {
+ BuildBackBuffer (
+ UsbDisplayLinkDev,
+ UsbDisplayLinkDev->Screen,
+ EfiBltBufferToVideo,
+ 0, 0,
+ 0, 0,
+ Gop->Mode->Info->HorizontalResolution,
+ Gop->Mode->Info->VerticalResolution,
+ Gop->Mode->Info->HorizontalResolution * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL),
+ Gop->Mode->Info->HorizontalResolution);
+ // unlock the DisplayLinkPeriodicTimer
+ Gop->Mode->Mode = ModeNumber;
+ }
+
+ return Status;
+}
+
+/**
+ * Implementation of the GOP protocol Blt API function
+ * @param This Pointer to the instance of the GOP protocol
+ * @param BltBuffer
+ * @param BltOperation
+ * @param SourceX
+ * @param SourceY
+ * @param DestinationX
+ * @param DestinationY
+ * @param Width
+ * @param Height
+ * @param Delta
+ * @return
+ */
+EFI_STATUS
+EFIAPI
+DisplayLinkBlt (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
+ IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN Delta OPTIONAL
+)
+{
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev;
+ UsbDisplayLinkDev = USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(This);
+
+ // Drop out if we haven't set the video mode up yet
+ if (This->Mode->Mode == GRAPHICS_OUTPUT_INVALID_MODE_NUMBER) {
+ return EFI_SUCCESS;
+ }
+
+ if ((BltOperation < 0) || (BltOperation >= EfiGraphicsOutputBltOperationMax)) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (Width == 0 || Height == 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ // Lock so we make an atomic write the frame buffer.
+ // We would not want a timer based event (Cursor, ...) to come in while we are doing this operation.
+ EFI_TPL OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
+
+ CONST UINTN BltBufferStride = (Delta == 0) ? Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) : Delta;
+ CONST EFI_STATUS boundsCheckStatus = CheckBounds (This, BltOperation, SourceX, SourceY, Width, Height, DestinationX,
DestinationY);
+ if (EFI_ERROR (boundsCheckStatus)) {
+ gBS->RestoreTPL (OriginalTPL);
+ return boundsCheckStatus;
+ }
+
+ BuildBackBuffer (UsbDisplayLinkDev, BltBuffer, BltOperation, SourceX, SourceY, DestinationX, DestinationY, Width, Height,
BltBufferStride, This->Mode->Info->PixelsPerScanLine);
+
+ gBS->RestoreTPL (OriginalTPL);
+ return EFI_SUCCESS;
+}
+
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.c
new file mode 100644
index 000000000000..c12a80a6e1ab
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.c
@@ -0,0 +1,145 @@
+/**
+ * @file UsbDescriptors.c
+ * @brief Functions to read USB Interface and Capabilities descriptors
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+#include "UsbDescriptors.h"
+
+/**
+ *
+ * @param UsbIo
+ * @param descriptorType
+ * @param index
+ * @param Buffer
+ * @param Length
+ * @param UsbStatus
+ * @return
+ */
+STATIC EFI_STATUS
+ReadDescriptor (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ UINT8 DescriptorType,
+ UINT8 Index,
+ VOID* Buffer,
+ UINT16 Length,
+ UINT32* UsbStatus)
+{
+ EFI_STATUS Status;
+
+ UINT8 Header[2];
+ ZeroMem (Header, sizeof (Header));
+
+ EFI_USB_DEVICE_REQUEST Request;
+ ZeroMem (&Request, sizeof (Request));
+ Request.RequestType = USB_ENDPOINT_DIR_IN | USB_REQ_TYPE_STANDARD | USB_TARGET_DEVICE;
+ Request.Request = USB_REQ_GET_DESCRIPTOR;
+ Request.Index = 0;
+ Request.Value = DescriptorType << 8 | Index;
+ Request.Length = sizeof (Header);
+
+ // Read the descriptor header to see how many bytes it contains
+ Status = UsbIo->UsbControlTransfer (
+ UsbIo,
+ &Request,
+ EfiUsbDataIn,
+ DISPLAYLINK_USB_CTRL_TIMEOUT,
+ Header,
+ sizeof (Header),
+ UsbStatus);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to read length of descriptor type x%x, index %u (code %r, USB status x%x)\n",
+ DescriptorType, Index, Status, *UsbStatus));
+ return Status;
+ }
+ CONST UINT16 TotalLength = Header[0];
+
+ // Now we know the size of it, we can read the entire descriptor
+ Request.Length = TotalLength;
+
+ Status = UsbIo->UsbControlTransfer (
+ UsbIo,
+ &Request,
+ EfiUsbDataIn,
+ DISPLAYLINK_USB_CTRL_TIMEOUT,
+ Buffer,
+ TotalLength,
+ UsbStatus);
+
+ return Status;
+}
+
+/**
+ Perform a USB control transfer to read the DisplayLink vendor descriptor.
+
+ @param UsbIo Pointer to the instance of the USBIO protocol
+ @param Buffer Pointer to the buffer where descriptor should be written
+ @param Length Length of buffer (and the maximum amount of descriptor data that shall be read)
+
+ @retval EFI_SUCCESS The descriptor has been copied into Buffer
+ @retval Other The descriptor could not be read
+**/
+EFI_STATUS
+ReadCapabilitiesDescriptor (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ OUT VOID* Buffer,
+ IN UINT16 Length)
+{
+ UINT32 UsbStatus;
+ EFI_STATUS Status;
+
+ Status = ReadDescriptor (
+ UsbIo,
+ DESCRIPTOR_TYPE_DIRECTFB_CAPABILITY,
+ 0,
+ Buffer,
+ Length,
+ &UsbStatus);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Could not read capabilities descriptor from DL device (code %r, USB status x%x). Unrecognised
firmware version?\n", Status, UsbStatus));
+ }
+
+ return Status;
+}
+
+
+/**
+ An alternative to the UBSIO protocol function EFI_USB_IO_GET_INTERFACE_DESCRIPTOR.
+ This version allows you to specify an index.
+ * @param UsbIo Pointer to the instance of the USBIO protocol
+ * @param interfaceDescriptor Where the descriptor should be written
+ * @param index The index of the descriptor required (the standard USBIO function doesn't let you do this)
+ * @return
+ */
+EFI_STATUS
+UsbDisplayLinkGetInterfaceDescriptor (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ OUT EFI_USB_INTERFACE_DESCRIPTOR* InterfaceDescriptor,
+ UINT8 Index
+ )
+{
+ UINT32 UsbStatus;
+ EFI_STATUS Status;
+
+ Status = ReadDescriptor (
+ UsbIo,
+ USB_DESC_TYPE_INTERFACE,
+ Index,
+ InterfaceDescriptor,
+ sizeof (EFI_USB_INTERFACE_DESCRIPTOR),
+ &UsbStatus);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "USB control transfer failed while reading interface descriptor (code %r, USB status x%x)\n",
Status, UsbStatus));
+ }
+
+ return Status;
+}
+
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.h
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.h
new file mode 100644
index 000000000000..cdc01aad193a
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDescriptors.h
@@ -0,0 +1,109 @@
+/**
+ * @file UsbDescriptors.h
+ * @brief Functions to read USB Interface and Capabilities descriptors
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#ifndef USB_DESCRIPTORS_H_
+#define USB_DESCRIPTORS_H_
+
+ /**
+ Type of the Direct Framebuffer capability descriptor.
+ This is a vendor specific USB descriptor for DisplayLink.
+ @see NR-140082 Section 3.5
+ **/
+#define DESCRIPTOR_TYPE_DIRECTFB_CAPABILITY 0x5e
+
+ /**
+ Identifiers for capabllity keys
+ @see NR-140082 Section 3.2
+ **/
+
+ /**
+ Key for Capabilities 1 - See section 3.2.1
+ **/
+#define CAPABILITIES1_KEY 0x0
+
+ /**
+ Lengths for capabllity fields
+ **/
+#define CAPABILITIES1_LENGTH 0x4
+
+ /**
+ Bits for the capability bitmask Capabilities1
+ **/
+
+ /**
+ This is the first capability defined for the protocol.
+ It represents the mode of operation as of initial release.
+ If a device ever breaks compatibility with this initial release,
+ it will cease
+ to support CapabilityBaseProtocol.
+ **/
+#define CAPABILITIES1_BASE_PROTOCOL (1 << 0)
+
+ /**
+ Idealised VendorDescriptor which is the result
+ of parsing vendor descriptor from device.
+ **/
+ typedef struct {
+ UINT32 Capabilities1;
+ } VendorDescriptor;
+
+#pragma pack(push, 1)
+ typedef struct {
+ UINT16 Key; /** Really of type enum DescrptorKeys */
+ UINT8 Length;
+ UINT8 Value[];
+ } DescriptorKLV;
+
+ typedef struct {
+ UINT8 Length;
+ UINT8 Type;
+ UINT16 CapabilityVersion;
+ UINT8 CapabilityLength;
+ UINT8 Klv[];
+ } VendorDescriptorGeneric;
+#pragma pack(pop)
+
+
+EFI_STATUS UsbDisplayLinkGetInterfaceDescriptor (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ EFI_USB_INTERFACE_DESCRIPTOR* InterfaceDescriptor,
+ UINT8 index
+ );
+
+EFI_STATUS ReadCapabilitiesDescriptor (IN EFI_USB_IO_PROTOCOL *UsbIo, VOID* Buffer, UINT16 Length);
+
+/**
+Parse data in buffer to a VendorDescriptor, if possible.
+
+@param Data Buffer
+@param Length Length of buffer
+
+@retval EFI_SUCCESS The descriptor was parsed successfully
+@retval EFI_UNSUPPORTED Simple Pointer Protocol is not installed on Controller.
+**/
+EFI_STATUS
+UsbDisplayLinkParseCapabilitiesDescriptor (
+ CONST IN VOID* Data,
+ IN UINTN Length,
+ OUT VendorDescriptor* Descriptor
+);
+
+/**
+Decide if binding may proceed, given capabilities
+
+@retval TRUE Binding may proceed
+@retval FALSE Binding is not possible
+**/
+BOOLEAN
+UsbDisplayLinkCapabilitiesSufficientToBind (
+ CONST IN VendorDescriptor* Descriptor
+);
+
+#endif // USB_DESCRIPTORS_H_
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.c
new file mode 100644
index 000000000000..997a3e307f38
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.c
@@ -0,0 +1,1082 @@
+/**
+ * @file UsbDisplayLink.c
+ * @brief USB DisplayLink Driver that manages USB DisplayLink device and produces Graphics Output Protocol
+ * This file implements the functions of the Driver Binding / Start / Stop / Unload interface
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/PrintLib.h>
+#include <Protocol/HiiFont.h>
+
+#include "Edid.h"
+#include "UsbDescriptors.h"
+
+//
+// Functions of Driver Binding Protocol
+//
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingSupported (
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,
+ IN EFI_HANDLE Controller,
+ IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
+);
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingStart (
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,
+ IN EFI_HANDLE Controller,
+ IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
+);
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingStop (
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,
+ IN EFI_HANDLE Controller,
+ IN UINTN NumberOfChildren,
+ IN EFI_HANDLE *ChildHandleBuffer
+);
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingEntryPoint (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+);
+
+
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverCombinedGopBindingEntryPoint (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable,
+ IN EFI_HANDLE DriverBindingHandle
+);
+
+
+// Generated with https://www.guidgen.com/ - "B70E5A79-C6D6-4267-B02E-9108C989E287"
+EFI_GUID gEfiDlGopVariableGuid = { 0xB70E5A79, 0xC6D6, 0x4267,{ 0xB0, 0x2E, 0x91, 0x08, 0xC9, 0x89, 0xE2, 0x87 } };
+
+
+EFI_DRIVER_BINDING_PROTOCOL gUsbDisplayLinkDriverBinding = {
+ UsbDisplayLinkDriverBindingSupported,
+ UsbDisplayLinkDriverBindingStart,
+ UsbDisplayLinkDriverBindingStop,
+ INF_DRIVER_VERSION,
+ NULL,
+ NULL
+};
+
+
+/**
+ * Reads integer environment variable with default fallback.
+ * @param variableName variable name to read
+ * @param defaultValue default value to return if requested not found
+ */
+STATIC UINT32
+ReadEnvironmentInt (
+ CHAR16 *VariableName,
+ UINT32 DefaultValue
+ )
+{
+ UINT32 Result;
+ UINTN DataSize;
+ DataSize = sizeof (Result);
+ CONST EFI_STATUS Status = gRT->GetVariable (VariableName, &gEfiDlGopVariableGuid, (UINT32*)NULL, &DataSize,
&Result);
+ if (!EFI_ERROR (Status) && (sizeof (Result) == DataSize)) {
+ return Result;
+ }
+ return DefaultValue;
+}
+
+/**
+* Reads boolean environment variable with default fallback.
+* @param variableName variable name to read
+* @param defaultValue default value to return if requested not found
+*/
+STATIC BOOLEAN
+ReadEnvironmentBool (
+ CHAR16 *VariableName,
+ BOOLEAN DefaultValue
+ )
+{
+ return ReadEnvironmentInt (VariableName, DefaultValue ? 1 : 0) == 1;
+}
+
+
+/**
+*
+* @param UsbDisplayLinkDev
+* @return
+*/
+STATIC EFI_STATUS
+InitializeUsbDisplayLinkDevice (
+ IN OUT USB_DISPLAYLINK_DEV *UsbDisplayLinkDev
+)
+{
+ EFI_GRAPHICS_OUTPUT_PROTOCOL* Gop;
+ Gop = &UsbDisplayLinkDev->GraphicsOutputProtocol;
+ Gop->QueryMode = DisplayLinkQueryMode;
+ Gop->SetMode = DisplayLinkSetMode;
+ Gop->Blt = DisplayLinkBlt;
+
+ //
+ // Allocate buffer for Graphics Output Protocol mode information
+ //
+ Gop->Mode = (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE*)AllocatePool (sizeof
(EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE));
+ if (Gop->Mode == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ Gop->Mode->Info = (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION*)AllocatePool (sizeof
(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
+ if (Gop->Mode->Info == NULL) {
+ FreePool (Gop->Mode);
+ Gop->Mode = NULL;
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Gop->Mode->MaxMode = MAX(1, DlEdidGetNumSupportedModesInEdid (UsbDisplayLinkDev->EdidActive.Edid,
UsbDisplayLinkDev->EdidActive.SizeOfEdid));
+
+ Gop->Mode->Mode = GRAPHICS_OUTPUT_INVALID_MODE_NUMBER;
+ Gop->Mode->Info->Version = 0;
+ // Initialising the horizontal resolution prevents certain BIOSs from hanging on boot, but
+ // it is not yet clear why. See bug 28194.
+ Gop->Mode->Info->HorizontalResolution = DlVideoModeGetSupportedVideoMode (0)->HActive;
+ Gop->Mode->Info->VerticalResolution = 0;
+ Gop->Mode->Info->PixelFormat = PixelBltOnly;
+ Gop->Mode->Info->PixelsPerScanLine = 0;
+ Gop->Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
+ Gop->Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS)(UINTN)NULL;
+ Gop->Mode->FrameBufferSize = 0;
+
+ // Prevent DlGopSendScreenUpdate from running until we are sure that the video mode is set
+ UsbDisplayLinkDev->LastY2 = 0;
+ UsbDisplayLinkDev->LastY1 = (UINTN)-1;
+
+ return EFI_SUCCESS;
+}
+
+/**
+ Look for alternate settings for the UsbIo handle's interface
+ which offer protocol DL_PROTOCOL_DIRECT_FB.
+
+ @retval -1 Not found
+ @retval Other The alternate setting
+**/
+STATIC INTN
+GetDirectFbAltSetting (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ IN UINT8 ParentInterfaceNumber
+ )
+{
+ EFI_STATUS Status;
+ INTN AltSettingIndex;
+ UINT16 InterfaceIndex;
+
+ AltSettingIndex = -1;
+
+ for (InterfaceIndex = 0; InterfaceIndex <= 0xFF; InterfaceIndex++) {
+ EFI_USB_INTERFACE_DESCRIPTOR interfaceDescriptor;
+ Status = UsbDisplayLinkGetInterfaceDescriptor (UsbIo, &interfaceDescriptor, (UINT8)InterfaceIndex);
+ if (EFI_ERROR (Status)) {
+ break;
+ }
+
+ if (interfaceDescriptor.InterfaceNumber == ParentInterfaceNumber &&
+ (interfaceDescriptor.InterfaceClass == CLASS_VENDOR) &&
+ interfaceDescriptor.InterfaceProtocol == INTERFACE_PROTOCOL_DIRECT_FB) {
+ AltSettingIndex = interfaceDescriptor.AlternateSetting;
+ break;
+ }
+ }
+ return AltSettingIndex;
+}
+
+/**
+ *
+ * @param UsbIo
+ * @param altSettingIndex
+ * @return
+ */
+STATIC EFI_STATUS
+SelectAltSetting (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ IN UINTN AltSettingIndex)
+{
+ // Set alternate setting 1 on the interface
+ EFI_STATUS Status;
+ UINT32 UsbStatus;
+ EFI_USB_DEVICE_REQUEST Request;
+ ZeroMem (&Request, sizeof (Request));
+ Request.RequestType = USB_REQ_TYPE_STANDARD | USB_TARGET_INTERFACE;
+ Request.Request = USB_REQ_SET_INTERFACE;
+ Request.Index = DISPLAYLINK_USB_INTERFACE_NUMBER_NIVO;
+ Request.Value = (UINT16)AltSettingIndex;
+
+ Status = UsbIo->UsbControlTransfer (
+ UsbIo,
+ &Request,
+ EfiUsbNoData,
+ DISPLAYLINK_USB_CTRL_TIMEOUT,
+ NULL,
+ 0,
+ &UsbStatus);
+
+ if (EFI_ERROR (Status)) {
+ Status = EFI_UNSUPPORTED;
+ DEBUG ((DEBUG_ERROR, "USB control transfer failed while attempting to select alt setting %d on interface (code %r, USB
status x%x). DisplayLink device has unsupported firmware version?\n", AltSettingIndex, Status, UsbStatus));
+ }
+ return Status;
+}
+
+
+/**
+ Report whether the driver can support the device attached via UsbIo
+ by seeing what if any capabilities it reports.
+
+ @retval TRUE Device has sufficient capabilities for this driver.
+ @retval FALSE Device lacks sufficient capabilities.
+**/
+STATIC BOOLEAN
+CapabilitiesSupported (
+ IN EFI_USB_IO_PROTOCOL *UsbIo
+ )
+{
+ UINT8 Buffer[256];
+ EFI_STATUS Status;
+
+ Status = ReadCapabilitiesDescriptor (UsbIo, Buffer, sizeof (Buffer));
+ if (EFI_ERROR (Status)) {
+ return FALSE;
+ }
+
+ VendorDescriptor descriptor;
+ Status = UsbDisplayLinkParseCapabilitiesDescriptor (Buffer, sizeof (Buffer), &descriptor);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to parse capabilities descriptor (code %r)\n", Status));
+ return FALSE;
+ }
+
+ return UsbDisplayLinkCapabilitiesSufficientToBind (&descriptor);
+}
+
+
+/**
+ *
+ * @param UsbIo
+ * @param InterfaceDescriptor
+ * @param altSettingIndex
+ * @return
+ */
+STATIC BOOLEAN
+IsDLDirectFbCapableInterface (
+ IN EFI_USB_IO_PROTOCOL *UsbIo,
+ IN EFI_USB_INTERFACE_DESCRIPTOR *InterfaceDescriptor,
+ IN INTN *AltSettingIndex)
+{
+ EFI_STATUS Status;
+ EFI_USB_DEVICE_DESCRIPTOR DeviceDescriptor;
+
+ Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DeviceDescriptor);
+
+ if (EFI_ERROR (Status)) {
+ return FALSE;
+ }
+
+ if (DeviceDescriptor.IdVendor != VENDOR_DISPLAYLINK) {
+ return FALSE;
+ }
+
+ Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, InterfaceDescriptor);
+ if (EFI_ERROR (Status)) {
+ return FALSE;
+ }
+
+ // We can assume that the interface that we want to talk to - the NIVO interface - is number 0
+ if (InterfaceDescriptor->InterfaceNumber != DISPLAYLINK_USB_INTERFACE_NUMBER_NIVO) {
+ return FALSE;
+ }
+
+ // Check if we have an interface (alt setting) descriptor with the correct interface protocol
+ *AltSettingIndex = GetDirectFbAltSetting (UsbIo, InterfaceDescriptor->InterfaceNumber);
+
+ if (*AltSettingIndex == -1) {
+ DEBUG ((DEBUG_ERROR, "DisplayLink GOP: Failed to find setting on device which supports GOP functionality. Check
firmware / device version?\n"));
+ return FALSE;
+ }
+
+ // Now check that the capabilities that we need are properly supported
+ if (CapabilitiesSupported (UsbIo) == FALSE) {
+ DEBUG ((DEBUG_ERROR, "DisplayLink GOP: DL device detected, but it doesn't support the required GOP features. Check
firmware / device version?\n"));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/**
+ * Prints a block of text in the framebuffer (helper function).
+ * @param X x coordinate
+ * @param Y y coordinate
+ */
+STATIC VOID
+DisplayLinkPrintTextToScreenInternal (
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,
+ UINTN X,
+ UINTN Y,
+ IN CHAR16 *Buffer
+ )
+{
+ EFI_STATUS Status;
+ EFI_HII_FONT_PROTOCOL *HiiFont;
+ EFI_IMAGE_OUTPUT *Blt;
+ EFI_FONT_DISPLAY_INFO FontInfo;
+ EFI_HII_OUT_FLAGS Flags;
+
+ Blt = (EFI_IMAGE_OUTPUT*)NULL;
+
+ Status = gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **)&HiiFont);
+ if (!EFI_ERROR (Status)) {
+ Blt = (EFI_IMAGE_OUTPUT*)AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
+ Blt->Width = (UINT16)GraphicsOutput->Mode->Info->HorizontalResolution;
+ Blt->Height = (UINT16)GraphicsOutput->Mode->Info->VerticalResolution;
+ Blt->Image.Screen = GraphicsOutput;
+
+ ZeroMem (&FontInfo, sizeof (EFI_FONT_DISPLAY_INFO));
+ FontInfo.ForegroundColor.Red = 0;
+ FontInfo.ForegroundColor.Green = 0;
+ FontInfo.ForegroundColor.Blue = 0;
+ FontInfo.BackgroundColor.Red = 0xff;
+ FontInfo.BackgroundColor.Green = 0xff;
+ FontInfo.BackgroundColor.Blue = 0xff;
+
+ Flags = EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_OUT_FLAG_CLIP |
+ EFI_HII_OUT_FLAG_CLIP_CLEAN_X | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y |
+ EFI_HII_IGNORE_LINE_BREAK | EFI_HII_DIRECT_TO_SCREEN;
+
+ Status = HiiFont->StringToImage (
+ HiiFont,
+ Flags,
+ Buffer,
+ &FontInfo,
+ &Blt,
+ X,
+ Y,
+ (EFI_HII_ROW_INFO**)NULL,
+ (UINTN*)NULL,
+ (UINTN*)NULL);
+ }
+
+ if (Blt != NULL) {
+ FreePool (Blt);
+ }
+}
+
+
+/**
+* Prints a block of text in the framebuffer.
+* @param X x coordinate
+* @param Y y coordinate
+* @param Format string format similar to stdlib's vsnprintf
+* @param ... arguments
+*/
+VOID
+EFIAPI
+DlGopPrintTextToScreen (
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,
+ UINTN X,
+ UINTN Y,
+ IN CONST CHAR16 *Format,
+ ...
+ )
+{
+ VA_LIST Marker;
+ CHAR16 *Buffer;
+ UINTN BufferSize;
+
+ ASSERT (Format != NULL);
+ ASSERT (((UINTN) Format & BIT0) == 0);
+
+ VA_START(Marker, Format);
+
+ BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
+
+ Buffer = (CHAR16*)AllocatePool (BufferSize);
+ ASSERT (Buffer != NULL);
+
+ UnicodeVSPrint (Buffer, BufferSize, Format, Marker);
+
+ VA_END(Marker);
+
+ DisplayLinkPrintTextToScreenInternal (GraphicsOutput, X, Y, Buffer);
+
+ FreePool (Buffer);
+}
+
+
+/**
+ * Sometimes platforms only write to the first GOP device that they find. Enabling this function allows us to copy the pixels
from this device.
+ * @param UsbDisplayLinkDev
+ */
+#ifdef COPY_PIXELS_FROM_PRIMARY_GOP_DEVICE
+STATIC VOID
+DisplayLinkCopyFromPrimaryGopDevice (
+ IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev
+ )
+{
+ UINTN HandleCount;
+ EFI_HANDLE *HandleBuffer;
+ UINTN HandleIndex;
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop;
+
+ gBS->LocateHandleBuffer (
+ ByProtocol,
+ &gEfiGraphicsOutputProtocolGuid,
+ NULL,
+ &HandleCount,
+ &HandleBuffer);
+
+ for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
+ gBS->HandleProtocol (HandleBuffer[HandleIndex], &gEfiGraphicsOutputProtocolGuid, (VOID**)&Gop);
+ if (Gop != &UsbDisplayLinkDev->GraphicsOutputProtocol && Gop->Mode->FrameBufferBase !=
(EFI_PHYSICAL_ADDRESS)(UINTN)NULL) {
+
+ // See if we need to do a screen update - calculate a really noddy hash to see if any screen updates have happened.
+ STATIC UINT32 prevframeBufferHash = 0; // 4 bytes per pixel
+ UINT32 currFrameBufferHash = 0;
+ UINTN i;
+ for (i = 0; i < (Gop->Mode->Info->HorizontalResolution * Gop->Mode->Info->VerticalResolution); i++) {
+ currFrameBufferHash += ((UINT32*)(UINTN)Gop->Mode->FrameBufferBase)[i];
+ }
+
+ if (currFrameBufferHash != prevframeBufferHash) {
+ prevframeBufferHash = currFrameBufferHash;
+
+ DisplayLinkBlt (
+ &UsbDisplayLinkDev->GraphicsOutputProtocol,
+ (EFI_GRAPHICS_OUTPUT_BLT_PIXEL*)(UINTN)Gop->Mode->FrameBufferBase,
+ EfiBltBufferToVideo,
+ 0,
+ 0,
+ 0,
+ 0,
+ Gop->Mode->Info->HorizontalResolution,
+ Gop->Mode->Info->VerticalResolution,
+ 0);
+ }
+ break;
+ }
+ }
+
+ FreePool (HandleBuffer);
+}
+#endif // COPY_PIXELS_FROM_PRIMARY_GOP_DEVICE
+
+
+/**
+ * Exit from boot services: signal handler.
+ */
+STATIC VOID
+EFIAPI
+DisplayLinkDriverExitBootServices (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev;
+ UsbDisplayLinkDev = (USB_DISPLAYLINK_DEV*)Context;
+
+ gBS->CloseEvent (UsbDisplayLinkDev->TimerEvent);
+}
+
+/**
+ * Periodic screen update: timer callback.
+ */
+VOID
+EFIAPI
+DisplayLinkPeriodicTimer (
+ IN EFI_EVENT Event,
+ IN VOID* Context
+ )
+{
+ EFI_STATUS Status;
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev;
+
+ Status = EFI_SUCCESS;
+ UsbDisplayLinkDev = (USB_DISPLAYLINK_DEV*)Context;
+
+ // Drop out if we haven't set the video mode up yet
+ if (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Mode == GRAPHICS_OUTPUT_INVALID_MODE_NUMBER) {
+ // Restart the one-shot timer to poll the status again.
+ Status = gBS->SetTimer (UsbDisplayLinkDev->TimerEvent, TimerRelative, DISPLAYLINK_SCREEN_UPDATE_TIMER_PERIOD);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create timer.\n"));
+ }
+ return;
+ }
+
+#ifdef COPY_PIXELS_FROM_PRIMARY_GOP_DEVICE
+ DisplayLinkCopyFromPrimaryGopDevice (UsbDisplayLinkDev);
+#endif // COPY_PIXELS_FROM_PRIMARY_GOP_DEVICE
+
+ if (UsbDisplayLinkDev->ShowBandwidth) {
+ STATIC UINTN Count = 0;
+
+ if (Count++ % 50 == 0) {
+ DlGopPrintTextToScreen (&UsbDisplayLinkDev->GraphicsOutputProtocol, 32, 48, (CONST CHAR16*)L" Bandwidth: %d
MB/s ", UsbDisplayLinkDev->DataSent * 10000000 / DISPLAYLINK_SCREEN_UPDATE_TIMER_PERIOD / 50 / 1024 / 1024);
+ UsbDisplayLinkDev->DataSent = 0;
+ }
+ }
+
+ if (UsbDisplayLinkDev->ShowTestPattern)
+ {
+ if (UsbDisplayLinkDev->ShowTestPattern == 5) {
+ DlGopSendTestPattern (UsbDisplayLinkDev, 0);
+ } else if (UsbDisplayLinkDev->ShowTestPattern >= 10) {
+ DlGopSendTestPattern (UsbDisplayLinkDev, 1);
+ UsbDisplayLinkDev->ShowTestPattern = 0;
+ }
+ UsbDisplayLinkDev->ShowTestPattern++;
+
+ }
+
+ // Send the latest version of the frame buffer to the DL device over USB
+ DlGopSendScreenUpdate (UsbDisplayLinkDev);
+
+ // Restart the timer now we've finished
+ Status = gBS->SetTimer (UsbDisplayLinkDev->TimerEvent, TimerRelative, DISPLAYLINK_SCREEN_UPDATE_TIMER_PERIOD);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to create timer.\n"));
+ }
+}
+
+/*
******************************************************************************************************
*/
+/*
******************************************************************************************************
*/
+/* ****************** START OF FUNCTIONS WHICH IMPLEMENT DRIVER BINDING INTERFACE ******************
*/
+/*
******************************************************************************************************
*/
+/*
******************************************************************************************************
*/
+
+/**
+ Check whether USB DisplayLink driver supports this device.
+
+ @param This The USB DisplayLink driver binding protocol.
+ @param Controller The controller handle to check.
+ @param RemainingDevicePath The remaining device path.
+
+ @retval EFI_SUCCESS The driver supports this controller.
+ @retval other This device isn't supported.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingSupported (
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,
+ IN EFI_HANDLE Controller,
+ IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
+ )
+{
+ EFI_STATUS Status;
+ EFI_USB_IO_PROTOCOL *UsbIo;
+
+ Status = gBS->OpenProtocol (
+ Controller,
+ &gEfiUsbIoProtocolGuid,
+ (VOID **) &UsbIo,
+ This->DriverBindingHandle,
+ Controller,
+ EFI_OPEN_PROTOCOL_BY_DRIVER);
+
+ if (EFI_ERROR (Status)) {
+ return Status;
+ }
+
+ //
+ // Use the USB I/O Protocol interface to check whether Controller is
+ // a DisplayLink device that can be managed by this driver.
+ //
+ Status = EFI_UNSUPPORTED;
+ EFI_USB_INTERFACE_DESCRIPTOR DummyInterfaceDescriptor;
+ INTN DummyAltSettingIndex;
+
+ if (IsDLDirectFbCapableInterface (UsbIo, &DummyInterfaceDescriptor, &DummyAltSettingIndex)){
+ Status = EFI_SUCCESS;
+ }
+
+ gBS->CloseProtocol (
+ Controller,
+ &gEfiUsbIoProtocolGuid,
+ This->DriverBindingHandle,
+ Controller);
+
+ return Status;
+}
+
+
+/**
+ Starts the DisplayLink device with this driver.
+
+ This function consumes USB I/O Protocol, intializes USB DisplayLink device,
+ installs Graphics Output Protocol
+ Transfer to manage the USB DisplayLink device.
+
+ @param This The USB DisplayLink driver binding instance.
+ @param Controller Handle of device to bind driver to.
+ @param RemainingDevicePath Optional parameter use to pick a specific child
+ device to start.
+
+ @retval EFI_SUCCESS This driver supports this device.
+ @retval EFI_UNSUPPORTED This driver does not support this device.
+ @retval EFI_DEVICE_ERROR This driver cannot be started due to device Error.
+ @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources.
+ @retval EFI_ALREADY_STARTED This driver has been started.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingStart (
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,
+ IN EFI_HANDLE Controller,
+ IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
+ )
+{
+ EFI_STATUS Status;
+ USB_DISPLAYLINK_DEV *UsbDisplayLinkDev;
+ UINT8 EndpointNumber;
+ EFI_USB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
+ UINT8 Index;
+ BOOLEAN FoundOut;
+ BOOLEAN FoundIn;
+ EFI_TPL OriginalTPL;
+ INTN altSettingIndex;
+
+ OriginalTPL = gBS->RaiseTPL (TPL_CALLBACK);
+
+ UsbDisplayLinkDev = (USB_DISPLAYLINK_DEV*)AllocateZeroPool (sizeof (USB_DISPLAYLINK_DEV));
+ if (UsbDisplayLinkDev == NULL) {
+ DEBUG ((DEBUG_ERROR, "Device initialialisation - Failed to allocate memory for device.\n"));
+ gBS->RestoreTPL (OriginalTPL);
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ UsbDisplayLinkDev->Signature = USB_DISPLAYLINK_DEV_SIGNATURE;
+
+ UsbDisplayLinkDev->ShowBandwidth = ReadEnvironmentBool (L"DisplayLinkShowBandwidth", FALSE);
+ UsbDisplayLinkDev->ShowTestPattern = ReadEnvironmentBool (L"DisplayLinkShowTestPatterns", FALSE);
+
+ //
+ // Open USB I/O Protocol
+ //
+ Status = gBS->OpenProtocol (
+ Controller,
+ &gEfiUsbIoProtocolGuid,
+ (VOID **) &UsbDisplayLinkDev->UsbIo,
+ This->DriverBindingHandle,
+ Controller,
+ EFI_OPEN_PROTOCOL_BY_DRIVER);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to open usbio protocol. Is USB correctly supported on this platform?.\n"));
+ Status = EFI_UNSUPPORTED;
+ goto ErrorExit2;
+ }
+
+ if (!IsDLDirectFbCapableInterface (UsbDisplayLinkDev->UsbIo, &UsbDisplayLinkDev->InterfaceDescriptor, &altSettingIndex))
{
+ Status = EFI_UNSUPPORTED;
+ goto ErrorExit4;
+ }
+
+ Status = SelectAltSetting (UsbDisplayLinkDev->UsbIo, altSettingIndex);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "DisplayLink GOP: Failed to select alternate setting.\n"));
+ Status = EFI_UNSUPPORTED;
+ goto ErrorExit4;
+ }
+
+ //
+ // Parse endpoint descriptor
+ //
+ EndpointNumber = UsbDisplayLinkDev->InterfaceDescriptor.NumEndpoints;
+
+ //
+ // Traverse endpoints to find bulk endpoint
+ //
+ FoundOut = FALSE;
+ FoundIn = FALSE;
+ for (Index = 0; Index < EndpointNumber; Index++) {
+ UsbDisplayLinkDev->UsbIo->UsbGetEndpointDescriptor (
+ UsbDisplayLinkDev->UsbIo,
+ Index,
+ &EndpointDescriptor);
+
+ if ((EndpointDescriptor.Attributes & (BIT0 | BIT1)) == USB_ENDPOINT_BULK) {
+ if (!FoundOut && (EndpointDescriptor.EndpointAddress & BIT7) == 0) {
+ CopyMem (&UsbDisplayLinkDev->BulkOutEndpointDescriptor, &EndpointDescriptor, sizeof (EndpointDescriptor));
+ FoundOut = TRUE;
+ } else if (!FoundIn && (EndpointDescriptor.EndpointAddress & BIT7) == BIT7) {
+ CopyMem (&UsbDisplayLinkDev->BulkInEndpointDescriptor, &EndpointDescriptor, sizeof (EndpointDescriptor));
+ FoundIn = TRUE;
+ }
+ }
+ }
+
+ if (FoundOut == FALSE) {
+ Status = EFI_UNSUPPORTED;
+ DEBUG ((DEBUG_ERROR, "No endpoints found. Num endpoints searched = %d.\n", EndpointNumber));
+ goto ErrorExit4;
+ }
+
+ Status = DlReadEdid (UsbDisplayLinkDev);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to read monitor EDID from DisplayLink device (code %r)\n", Status));
+ goto ErrorExit7;
+ }
+
+ Status = InitializeUsbDisplayLinkDevice (UsbDisplayLinkDev);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to initialise DisplayLink device (code %r)\n", Status));
+ goto ErrorExit7;
+ }
+
+ Status = gBS->InstallMultipleProtocolInterfaces (
+ &Controller,
+ &gEfiGraphicsOutputProtocolGuid,
+ &UsbDisplayLinkDev->GraphicsOutputProtocol,
+ &gEfiEdidDiscoveredProtocolGuid,
+ &UsbDisplayLinkDev->EdidDiscovered,
+ &gEfiEdidActiveProtocolGuid,
+ &UsbDisplayLinkDev->EdidActive,
+ NULL);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "Failed to install Graphics Output and EDID protocol interfaces - driver not installed correctly -
%r\n", Status));
+ goto ErrorExit8;
+ }
+
+ UsbDisplayLinkDev->ControllerNameTable = (EFI_UNICODE_STRING_TABLE*)NULL;
+
+ AddUnicodeString2 (
+ "eng",
+ mUsbDisplayLinkComponentName.SupportedLanguages,
+ &UsbDisplayLinkDev->ControllerNameTable,
+ (CONST CHAR16*)L"Generic Usb DisplayLink",
+ TRUE);
+
+ AddUnicodeString2 (
+ "en",
+ mUsbDisplayLinkComponentName2.SupportedLanguages,
+ &UsbDisplayLinkDev->ControllerNameTable,
+ (CONST CHAR16*)L"Generic Usb DisplayLink",
+ FALSE);
+
+ //
+ // Setup a periodic timer
+ //
+ Status = gBS->CreateEvent (
+ EVT_TIMER | EVT_NOTIFY_SIGNAL,
+ TPL_CALLBACK,
+ DisplayLinkPeriodicTimer,
+ UsbDisplayLinkDev,
+ &UsbDisplayLinkDev->TimerEvent);
+
+ if (EFI_ERROR (Status)) {
+ Status = EFI_OUT_OF_RESOURCES;
+ DEBUG ((DEBUG_ERROR, "Failed to create screeen update polling event.\n"));
+ goto ErrorExit8;
+ }
+
+ // Start one-shot timer. The rendering operations can take quite a long time, so we
+ // don't want another timer event to happen until we have finished; so we'll restart
+ // the timer from DisplayLinkPeriodicTimer, the event handler function.
+ Status = gBS->SetTimer (UsbDisplayLinkDev->TimerEvent, TimerRelative, DISPLAYLINK_SCREEN_UPDATE_TIMER_PERIOD);
+ if (EFI_ERROR (Status)) {
+ Status = EFI_OUT_OF_RESOURCES;
+ DEBUG ((DEBUG_ERROR, "Failed to create screen update polling timer.\n"));
+ goto ErrorExit8;
+ }
+
+ Status = gBS->CreateEventEx (
+ EVT_NOTIFY_SIGNAL,
+ TPL_NOTIFY,
+ DisplayLinkDriverExitBootServices,
+ UsbDisplayLinkDev,
+ &gEfiEventExitBootServicesGuid,
+ &UsbDisplayLinkDev->DriverExitBootServicesEvent);
+
+ if (EFI_ERROR (Status)) {
+ Status = EFI_OUT_OF_RESOURCES;
+ DEBUG ((DEBUG_ERROR, "Failed to create event for bootexit.\n"));
+ goto ErrorExit8;
+ }
+
+ gBS->RestoreTPL (OriginalTPL);
+
+ DEBUG ((DEBUG_INFO, "DisplayLink GOP driver successfully bound to device.\n"));
+
+ return EFI_SUCCESS;
+
+ //
+ // Error handler
+ //
+ ErrorExit8:
+ ErrorExit7:
+ ErrorExit4:
+ gBS->CloseProtocol (
+ Controller,
+ &gEfiUsbIoProtocolGuid,
+ This->DriverBindingHandle,
+ Controller);
+
+ ErrorExit2:
+ if (UsbDisplayLinkDev != NULL) {
+ FreePool (UsbDisplayLinkDev);
+ UsbDisplayLinkDev = (USB_DISPLAYLINK_DEV*)NULL;
+ }
+
+ DEBUG ((DEBUG_ERROR, "Exiting - Failed to initialise driver.\n"));
+
+ gBS->RestoreTPL (OriginalTPL);
+ return Status;
+}
+
+/**
+Entrypoint of USB DisplayLink Driver.
+
+This function is the entrypoint of a combined USB DisplayLink GOP Driver. It installs Driver Binding
+Protocols together with Component Name Protocols.
+
+@param ImageHandle The firmware allocated handle for the EFI image.
+@param SystemTable A pointer to the EFI System Table.
+@param DriverBindingHandle The Driver binding handle
+
+@retval EFI_SUCCESS The entry point is executed successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverCombinedGopBindingEntryPoint (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable,
+ IN EFI_HANDLE DriverBindingHandle
+)
+{
+ EFI_STATUS Status;
+
+ Status = EfiLibInstallDriverBindingComponentName2 (
+ ImageHandle,
+ SystemTable,
+ &gUsbDisplayLinkDriverBinding,
+ DriverBindingHandle,
+ &mUsbDisplayLinkComponentName,
+ &mUsbDisplayLinkComponentName2);
+
+ ASSERT_EFI_ERROR (Status);
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+Entrypoint of USB DisplayLink Driver.
+
+This function is the entrypoint of USB DisplayLink Driver. It installs Driver Binding
+Protocols together with Component Name Protocols.
+
+@param ImageHandle The firmware allocated handle for the EFI image.
+@param SystemTable A pointer to the EFI System Table.
+
+@retval EFI_SUCCESS The entry point is executed successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingEntryPoint (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+)
+{
+ return UsbDisplayLinkDriverCombinedGopBindingEntryPoint (ImageHandle, SystemTable, ImageHandle);
+}
+
+
+/**
+Unloads an image.
+@param ImageHandle Handle that identifies the image to be unloaded.
+@retval EFI_SUCCESS The image has been unloaded.
+@retval EFI_INVALID_PARAMETER ImageHandle is not a valid image handle.
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverCombinedGopUnload (
+ IN EFI_HANDLE ImageHandle
+)
+{
+ EFI_STATUS Status = EFI_SUCCESS;
+ EFI_STATUS handleDisconnectStatus;
+ EFI_HANDLE *HandleBuffer;
+ UINTN HandleCount;
+ UINTN Index;
+
+ //
+ // Retrieve array of all handles in the handle database
+ //
+ handleDisconnectStatus = gBS->LocateHandleBuffer (
+ AllHandles,
+ NULL,
+ NULL,
+ &HandleCount,
+ &HandleBuffer
+ );
+ if (! EFI_ERROR (handleDisconnectStatus)) {
+ //
+ // Disconnect the current driver from handles in the handle database
+ //
+ for (Index = 0; Index < HandleCount; Index++) {
+ Status = gBS->DisconnectController (HandleBuffer[Index], gImageHandle, NULL);
+ }
+ //
+ // Free the array of handles
+ //
+ if (HandleBuffer != NULL)
+ {
+ FreePool (HandleBuffer);
+ }
+ }
+
+ // Even if we didn't manage to disconnect the handles, try to uninstall the protocols
+ //
+ // Uninstall protocols installed in the driver entry point
+ //
+ Status = gBS->UninstallMultipleProtocolInterfaces (
+ ImageHandle,
+ &gEfiDriverBindingProtocolGuid,
+ &gUsbDisplayLinkDriverBinding,
+ &gEfiComponentNameProtocolGuid,
+ &mUsbDisplayLinkComponentName,
+ &gEfiComponentName2ProtocolGuid,
+ &mUsbDisplayLinkComponentName2,
+ NULL
+ );
+
+ if (EFI_ERROR (handleDisconnectStatus))
+ {
+ return handleDisconnectStatus;
+ }
+ return Status;
+}
+
+
+/**
+ Stop the USB DisplayLink device handled by this driver.
+
+ @param This The USB DisplayLink driver binding protocol.
+ @param Controller The controller to release.
+ @param NumberOfChildren The number of handles in ChildHandleBuffer.
+ @param ChildHandleBuffer The array of child handle.
+
+ @retval EFI_SUCCESS The device was stopped.
+ @retval EFI_UNSUPPORTED Simple Pointer Protocol is not installed on Controller.
+ @retval Others Fail to uninstall protocols attached on the device.
+
+**/
+EFI_STATUS
+EFIAPI
+UsbDisplayLinkDriverBindingStop (
+ IN EFI_DRIVER_BINDING_PROTOCOL *This,
+ IN EFI_HANDLE Controller,
+ IN UINTN NumberOfChildren,
+ IN EFI_HANDLE *ChildHandleBuffer
+ )
+{
+ EFI_STATUS Status;
+ USB_DISPLAYLINK_DEV *UsbDisplayLinkDev;
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutputProtocol;
+
+ Status = gBS->OpenProtocol (
+ Controller,
+ &gEfiGraphicsOutputProtocolGuid,
+ (VOID **) &GraphicsOutputProtocol,
+ This->DriverBindingHandle,
+ Controller,
+ EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+
+ if (EFI_ERROR (Status)) {
+ return EFI_UNSUPPORTED;
+ }
+
+ UsbDisplayLinkDev = USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(GraphicsOutputProtocol);
+
+ // Reset the video mode to clear the display. Don't drop out if there is a problem, just press on.
+ // Note that this will also clear the frame buffer, as the screen buffer will be re-allocated with AllocateZeroPool.
+ if ((GraphicsOutputProtocol->Mode != NULL) &&
+ (GraphicsOutputProtocol->Mode->Mode != GRAPHICS_OUTPUT_INVALID_MODE_NUMBER)) {
+ Status = DisplayLinkSetMode (GraphicsOutputProtocol, GraphicsOutputProtocol->Mode->Mode);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_WARN, "Driver stop - Problem resetting video mode - %r.\n", Status));
+ }
+ }
+
+ // Reset the alt setting on the interface (to the DL3 alt setting)
+ Status = SelectAltSetting (UsbDisplayLinkDev->UsbIo, 0);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_WARN, "Error resetting USB interface alternate setting - %r.\n", Status));
+ }
+
+ Status = gBS->UninstallMultipleProtocolInterfaces (
+ Controller,
+ &gEfiGraphicsOutputProtocolGuid,
+ &UsbDisplayLinkDev->GraphicsOutputProtocol,
+ &gEfiEdidDiscoveredProtocolGuid,
+ &UsbDisplayLinkDev->EdidDiscovered,
+ &gEfiEdidActiveProtocolGuid,
+ &UsbDisplayLinkDev->EdidActive,
+ NULL);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_WARN, "Error uninstalling Graphics Output and EDID protocol interfaces - %r.\n", Status));
+ return Status;
+ }
+
+ gBS->CloseEvent (UsbDisplayLinkDev->TimerEvent);
+
+ gBS->CloseProtocol (
+ Controller,
+ &gEfiUsbIoProtocolGuid,
+ This->DriverBindingHandle,
+ Controller);
+
+ //
+ // Free all resources.
+ //
+ if (UsbDisplayLinkDev->ControllerNameTable != NULL) {
+ FreeUnicodeStringTable (UsbDisplayLinkDev->ControllerNameTable);
+ }
+
+ if (UsbDisplayLinkDev->Screen != NULL) {
+ FreePool (UsbDisplayLinkDev->Screen);
+ UsbDisplayLinkDev->Screen = NULL;
+ }
+
+ if (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode) {
+ if (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info) {
+ FreePool (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info);
+ UsbDisplayLinkDev->GraphicsOutputProtocol.Mode->Info = NULL;
+ }
+ FreePool (UsbDisplayLinkDev->GraphicsOutputProtocol.Mode);
+ UsbDisplayLinkDev->GraphicsOutputProtocol.Mode = NULL;
+ }
+
+ FreePool (UsbDisplayLinkDev);
+
+ return EFI_SUCCESS;
+
+}
+
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.h
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.h
new file mode 100644
index 000000000000..497a2621bc2c
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbDisplayLink.h
@@ -0,0 +1,278 @@
+/**
+ * @file UsbDisplayLink.h
+ * @brief Helper routine and corresponding data struct used by USB DisplayLink Driver.
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#ifndef _EFI_USB_DISPLAYLINK_H_
+#define _EFI_USB_DISPLAYLINK_H_
+
+#include <Uefi/UefiBaseType.h>
+#include <Uefi/UefiSpec.h>
+
+#include <Protocol/EdidActive.h>
+#include <Protocol/EdidDiscovered.h>
+#include <Protocol/EdidOverride.h>
+#include <Protocol/GraphicsOutput.h>
+#include <Protocol/UsbIo.h>
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/ReportStatusCodeLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiLib.h>
+
+#define VENDOR_DISPLAYLINK 0x17e9
+#define CLASS_VENDOR 0xFF
+
+#define DISPLAYLINK_USB_INTERFACE_NUMBER_NIVO ((UINTN)0)
+
+#define INTERFACE_PROTOCOL_DIRECT_FB 4
+
+#define USB_TRANSFER_LENGTH (64 * 1024)
+#define DISPLAYLINK_MODE_DATA_LENGTH (146)
+#define DISPLAYLINK_USB_CTRL_TIMEOUT (1000)
+#define DISPLAYLINK_USB_BULK_TIMEOUT (1)
+
+#define DISPLAYLINK_SCREEN_UPDATE_TIMER_PERIOD ((UINTN)1000000) // 0.1s in us
+#define DISPLAYLINK_FULL_SCREEN_UPDATE_PERIOD ((UINTN)30000) // 3s in ticks
+
+#define DISPLAYLINK_FIXED_VERTICAL_REFRESH_RATE ((UINT16)60)
+
+// Requests to read values from the firmware
+#define EDID_BLOCK_SIZE 128
+#define EDID_DETAILED_TIMING_INVALID_PIXEL_CLOCK ((UINT16)(0x64))
+
+/** Structures ported from firmware - protocol.h */
+enum ID {
+ // VideoCommands
+ GET_OUTPUT_EDID = 0,
+ SET_VIDEO_MODE = 1
+};
+
+typedef struct {
+ UINT32 HorizontalResolution;
+ UINT32 VerticalResolution;
+ UINT32 ColorDepth;
+ UINT32 RefreshRate;
+ UINT8 Commands[DISPLAYLINK_MODE_DATA_LENGTH];
+} DISPLAYLINK_MODE_DATA;
+
+#define GRAPHICS_OUTPUT_INVALID_MODE_NUMBER 0xffff
+
+/**
+ * Device instance of USB display.
+ */
+typedef struct {
+ UINT64 Signature;
+ EFI_HANDLE Handle;
+ EFI_USB_IO_PROTOCOL *UsbIo;
+ EFI_USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
+ EFI_USB_ENDPOINT_DESCRIPTOR BulkOutEndpointDescriptor;
+ EFI_USB_ENDPOINT_DESCRIPTOR BulkInEndpointDescriptor;
+ EFI_GRAPHICS_OUTPUT_PROTOCOL GraphicsOutputProtocol;
+ EFI_EDID_DISCOVERED_PROTOCOL EdidDiscovered;
+ EFI_EDID_ACTIVE_PROTOCOL EdidActive;
+ EFI_UNICODE_STRING_TABLE *ControllerNameTable;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Screen;
+ UINTN DataSent; /** Debug - used to track the bandwidth */
+ EFI_EVENT TimerEvent;
+ EFI_EVENT DriverExitBootServicesEvent;
+ BOOLEAN ShowBandwidth; /** Debugging - show the bandwidth on the screen */
+ BOOLEAN ShowTestPattern; /** Show a colourbar pattern instead of the BLTd contents of the
framebuffer */
+ UINTN LastY1; /** Used to track if we can do a partial screen update */
+ UINTN LastY2;
+ UINTN LastWidth;
+ UINTN TimeSinceLastScreenUpdate; /** Do a full screen update every (x) seconds */
+} USB_DISPLAYLINK_DEV;
+
+#define USB_DISPLAYLINK_DEV_SIGNATURE SIGNATURE_32 ('d', 'l', 'i', 'n')
+
+struct VideoMode {
+ UINT8 Reserved1; /* Reserved - must be 0. */
+ UINT8 Reserved2; /* Reserved - must be 2. */
+
+ // Values matching the EDID Detailed Timing Descriptor spec
+ UINT16 PixelClock;
+ UINT16 HActive;
+ UINT16 HBlanking;
+ UINT16 HSyncOffset; // Horizontal Front Porch
+ UINT16 HSyncWidth;
+ UINT16 VActive;
+ UINT16 VBlanking;
+ UINT16 VSyncOffset; // Vertical Front Porch
+ UINT16 VSyncWidth;
+ // End of Edid Detailed Timing Descriptor
+
+ UINT16 Flags /*ModeFlags*/;
+ UINT16 Accumulate;
+ UINT16 Reserved3; /* Reserved - must be 0. */
+ UINT16 Reserved4; /* Reserved - must be 0. */
+ UINT16 InsetLeft;
+ UINT16 InsetTop;
+ UINT16 InsetRight;
+ UINT16 InsetBottom;
+ UINT32 FillValue;
+ UINT32 Reserved5; /* Reserved - must be 0. */
+ UINT8 Vic;
+ UINT8 ActiveFormat;
+ UINT16 Reserved6;
+};
+
+#define USB_DISPLAYLINK_DEV_FROM_GRAPHICS_OUTPUT_PROTOCOL(a) \
+ CR(a, USB_DISPLAYLINK_DEV, GraphicsOutputProtocol, USB_DISPLAYLINK_DEV_SIGNATURE)
+
+//
+// Global Variables
+//
+extern EFI_DRIVER_BINDING_PROTOCOL gUsbDisplayLinkDriverBinding;
+extern EFI_COMPONENT_NAME_PROTOCOL mUsbDisplayLinkComponentName;
+extern EFI_COMPONENT_NAME2_PROTOCOL mUsbDisplayLinkComponentName2;
+
+
+/* ******************************************* */
+/* ******** GOP interface functions ******** */
+/* ******************************************* */
+
+/**
+ * Implementation of the GOP protocol QueryMode API function
+ * @param This Instance of the GOP protocol
+ * @param ModeNumber
+ * @param SizeOfInfo
+ * @param Info
+ * @return
+ */
+EFI_STATUS
+ EFIAPI
+ DisplayLinkQueryMode (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
+ IN UINT32 ModeNumber,
+ OUT UINTN *SizeOfInfo,
+ OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info
+ );
+
+
+/**
+ * Implementation of the GOP protocol SetMode API function
+ * @param This
+ * @param ModeNumber
+ * @return
+ */
+EFI_STATUS
+ EFIAPI
+ DisplayLinkSetMode (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
+ IN UINT32 ModeNumber
+ );
+
+/**
+ * Implementation of the GOP protocol Blt API function
+ * @param This
+ * @param BltBuffer
+ * @param BltOperation
+ * @param SourceX
+ * @param SourceY
+ * @param DestinationX
+ * @param DestinationY
+ * @param Width
+ * @param Height
+ * @param Delta
+ * @return
+ */
+EFI_STATUS
+ EFIAPI
+ DisplayLinkBlt (
+ IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
+ IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
+ IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
+ IN UINTN SourceX,
+ IN UINTN SourceY,
+ IN UINTN DestinationX,
+ IN UINTN DestinationY,
+ IN UINTN Width,
+ IN UINTN Height,
+ IN UINTN Delta OPTIONAL
+ );
+
+/* *************************** */
+/* ** GOP helper functions ** */
+/* *************************** */
+
+VOID
+EFIAPI
+DlGopPrintTextToScreen (
+ EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,
+ UINTN X,
+ UINTN Y,
+ IN CONST CHAR16 *Format,
+ ...
+);
+
+EFI_STATUS
+DlGopSendTestPattern (
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev,
+ UINTN PatternNumber
+);
+
+EFI_STATUS
+DlGopSendScreenUpdate (
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev
+);
+
+
+/* ******************************************* */
+/* ******** USB interface functions ******** */
+/* ******************************************* */
+
+EFI_STATUS
+DlUsbSendControlWriteMessage (
+ IN USB_DISPLAYLINK_DEV *Device,
+ IN UINT8 Request,
+ IN UINT16 Value,
+ IN CONST VOID *ControlMsg,
+ IN UINT16 ControlMsgLen
+);
+
+EFI_STATUS
+DlUsbSendControlReadMessage (
+ IN USB_DISPLAYLINK_DEV *Device,
+ IN UINT8 Request,
+ IN UINT16 Value,
+ OUT VOID *ControlMsg,
+ IN UINT16 ControlMsgLen
+);
+
+EFI_STATUS
+DlUsbBulkWrite (
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev,
+ CONST UINT8* Buffer,
+ UINTN DataLen,
+ UINT32 *USBStatus
+);
+
+UINTN
+DlUsbBulkRead (
+ USB_DISPLAYLINK_DEV* UsbDisplayLinkDev,
+ UINT8* Buffer,
+ UINTN BufferLen
+);
+
+/* ******************************************* */
+/* ******** Video Mode functions ******** */
+/* ******************************************* */
+
+// Pre-calculated video modes
+UINT32
+DlVideoModeGetNumSupportedVideoModes ();
+
+CONST struct VideoMode *
+DlVideoModeGetSupportedVideoMode (
+ UINT32 index
+);
+
+#endif
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbTransfer.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbTransfer.c
new file mode 100644
index 000000000000..252293da39d4
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/UsbTransfer.c
@@ -0,0 +1,180 @@
+/**
+ * @file UsbTransfer.c
+ * @brief Wrapper of UEFI USB bulk and control transfer interface for USB DisplayLink driver.
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+
+/**
+ * Write the data to the DisplayLink device using the USBIO protocol.
+ * @param UsbDisplayLinkDev
+ * @param Buffer
+ * @param DataLen
+ * @param USBStatus
+ * @return
+ * EFI_SUCCESS The bulk transfer has been successfully executed.
+ * EFI_INVALID_PARAMETER If DeviceEndpoint is not valid.
+ * EFI_INVALID_PARAMETER Data is NULL.
+ * EFI_INVALID_PARAMETER DataLength is NULL.
+ * EFI_INVALID_PARAMETER Status is NULL.
+ * EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
+ * EFI_TIMEOUT The bulk transfer cannot be completed within Timeout timeframe.
+ * EFI_DEVICE_ERROR The transfer failed other than timeout, and the transfer status is returned in Status.
+ */
+EFI_STATUS
+DlUsbBulkWrite (
+ IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev,
+ IN CONST UINT8* Buffer,
+ IN UINTN DataLen,
+ OUT UINT32 *USBStatus
+ )
+{
+ EFI_STATUS Status;
+ Status = UsbDisplayLinkDev->UsbIo->UsbBulkTransfer (
+ UsbDisplayLinkDev->UsbIo,
+ UsbDisplayLinkDev->BulkOutEndpointDescriptor.EndpointAddress,
+ (VOID*)Buffer,
+ &DataLen,
+ DISPLAYLINK_USB_BULK_TIMEOUT,
+ USBStatus);
+
+ return Status;
+}
+
+/**
+* Read data from the DisplayLink device using the USBIO protocol.
+* @param UsbDisplayLinkDev
+* @param Buffer
+* @param BufferLen
+* @return 0 if an error occurred or 0 bytes were read, otherwise the number of bytes read
+ */
+UINTN
+DlUsbBulkRead (
+ IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev,
+ IN UINT8* Buffer,
+ IN UINTN BufferLen
+ )
+{
+ UINT32 Result;
+ UINTN ReadLen;
+ EFI_STATUS Status;
+
+ ReadLen = BufferLen;
+
+ Status = UsbDisplayLinkDev->UsbIo->UsbBulkTransfer (
+ UsbDisplayLinkDev->UsbIo,
+ UsbDisplayLinkDev->BulkInEndpointDescriptor.EndpointAddress,
+ Buffer,
+ &ReadLen,
+ DISPLAYLINK_USB_BULK_TIMEOUT,
+ &Result);
+
+ if (EFI_ERROR (Status)) {
+ return 0;
+ }
+
+ return ReadLen;
+}
+
+
+/**
+Send a control message (e.g set video mode) message to the DisplayLink device.
+
+@param Device USB device handle.
+@param request Request type, e.g. SET_VIDEO_MODE
+@param value
+@param controlMsg Pointer to the message to send.
+@param controlMsgLen Length of the message.
+
+@retval EFI_SUCCESS Successfully sent message.
+
+**/
+EFI_STATUS
+DlUsbSendControlWriteMessage (
+ IN USB_DISPLAYLINK_DEV *Device,
+ IN UINT8 Request,
+ IN UINT16 Value,
+ IN CONST VOID *ControlMsg,
+ IN UINT16 ControlMsgLen
+ )
+{
+ EFI_STATUS Status;
+ UINT32 UsbStatus;
+ EFI_USB_DEVICE_REQUEST UsbRequest;
+
+ ZeroMem (&Request, sizeof (Request));
+ UsbRequest.RequestType = USB_REQ_TYPE_VENDOR | USB_TARGET_INTERFACE;
+ UsbRequest.Index = Device->InterfaceDescriptor.InterfaceNumber;
+ UsbRequest.Request = Request;
+ UsbRequest.Value = Value;
+ UsbRequest.Length = ControlMsgLen;
+
+ Status = Device->UsbIo->UsbControlTransfer (
+ Device->UsbIo,
+ &UsbRequest,
+ EfiUsbDataOut,
+ DISPLAYLINK_USB_CTRL_TIMEOUT,
+ (VOID *)ControlMsg,
+ ControlMsgLen,
+ &UsbStatus);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "USB write control transfer failed - %r (USB status x%x).\n", Status, UsbStatus));
+ Status = EFI_DEVICE_ERROR;
+ }
+ return Status;
+}
+
+
+/**
+Request data from the DisplayLink device (e.g. the monitor EDID)
+
+@param Device USB device handle.
+@param request Request type, e.g. GET_OUTPUT_EDID
+@param value
+@param controlMsg Pointer to the message to send.
+@param controlMsgLen Length of the message.
+
+@retval EFI_SUCCESS Successfully sent message.
+
+**/
+EFI_STATUS
+DlUsbSendControlReadMessage (
+ IN USB_DISPLAYLINK_DEV *Device,
+ IN UINT8 Request,
+ IN UINT16 Value,
+ OUT VOID *ControlMsg,
+ IN UINT16 ControlMsgLen
+ )
+{
+ EFI_STATUS Status;
+ UINT32 UsbStatus;
+ EFI_USB_DEVICE_REQUEST UsbRequest;
+
+ ZeroMem (&UsbRequest, sizeof (UsbRequest));
+ UsbRequest.RequestType = USB_REQ_TYPE_VENDOR | USB_TARGET_INTERFACE | USB_ENDPOINT_DIR_IN;
+ UsbRequest.Request = Request;
+ UsbRequest.Value = Value;
+ UsbRequest.Index = Device->InterfaceDescriptor.InterfaceNumber;
+ UsbRequest.Length = ControlMsgLen;
+
+ Status = Device->UsbIo->UsbControlTransfer (
+ Device->UsbIo,
+ &UsbRequest,
+ EfiUsbDataIn,
+ DISPLAYLINK_USB_CTRL_TIMEOUT,
+ (VOID *)ControlMsg,
+ ControlMsgLen,
+ &UsbStatus);
+
+ if (EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_ERROR, "USB read control transfer failed - %r (USB status x%x).\n", Status, UsbStatus));
+ Status = EFI_DEVICE_ERROR;
+ }
+ return Status;
+}
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/VideoModes.c
b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/VideoModes.c
new file mode 100644
index 000000000000..6218c093147c
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/VideoModes.c
@@ -0,0 +1,254 @@
+/**
+ * @file VideoModes.c
+ * @brief Pre-calculated video timings sent to the DisplayLink device when a video mode is selected
+ *
+ * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause-Patent
+ *
+**/
+
+#include "UsbDisplayLink.h"
+
+
+// Supported video modes - must be in order of pixel count (i.e. hres x vres)
+
+STATIC CONST struct VideoMode ModeData[] = {
+ {
+ // 640 x 480 @ 60Hz
+ .Reserved2 = 2,
+ .PixelClock = 2517,
+ .HActive = 640,
+ .HBlanking = 160,
+ .HSyncOffset = 16,
+ .HSyncWidth = 96,
+ .VActive = 480,
+ .VBlanking = 45,
+ .VSyncOffset = 10,
+ .VSyncWidth = 2,
+ .Flags = 0x00000300,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 800 x 600 @ 60Hz
+ .Reserved2 = 2,
+ .PixelClock = 4000,
+ .HActive = 800,
+ .HBlanking = 256,
+ .HSyncOffset = 40,
+ .HSyncWidth = 128,
+ .VActive = 600,
+ .VBlanking = 28,
+ .VSyncOffset = 1,
+ .VSyncWidth = 3,
+ .Flags = 0x00000000,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1024x768 @ 60Hz
+ .Reserved1 = 0,
+ .Reserved2 = 2,
+ .PixelClock = 6500,
+ .HActive = 1024,
+ .HBlanking = 320,
+ .HSyncOffset = 24,
+ .HSyncWidth = 136,
+ .VActive = 768,
+ .VBlanking = 38,
+ .VSyncOffset = 3,
+ .VSyncWidth = 6,
+ .Flags = 0x00000300,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1360x768 @ 60Hz
+ .Reserved1 = 0,
+ .Reserved2 = 2,
+ .PixelClock = 8550,
+ .HActive = 1360,
+ .HBlanking = 432,
+ .HSyncOffset = 64,
+ .HSyncWidth = 112,
+ .VActive = 768,
+ .VBlanking = 27,
+ .VSyncOffset = 3,
+ .VSyncWidth = 6,
+ .Flags = 0x00000000,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1280x960 @ 60Hz
+ .Reserved1 = 0,
+ .Reserved2 = 2,
+ .PixelClock = 10800,
+ .HActive = 1280,
+ .HBlanking = 520,
+ .HSyncOffset = 96,
+ .HSyncWidth = 112,
+ .VActive = 960,
+ .VBlanking = 40,
+ .VSyncOffset = 1,
+ .VSyncWidth = 3,
+ .Flags = 0x00000000,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1280x1024 @ 60Hz
+ .Reserved1 = 0,
+ .Reserved2 = 2,
+ .PixelClock = 10800,
+ .HActive = 1280,
+ .HBlanking = 408,
+ .HSyncOffset = 48,
+ .HSyncWidth = 112,
+ .VActive = 1024,
+ .VBlanking = 42,
+ .VSyncOffset = 1,
+ .VSyncWidth = 3,
+ .Flags = 0x00000000,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1600x900 @ 60Hz
+ .Reserved2 = 2,
+ .PixelClock = 11825,
+ .HActive = 1600,
+ .HBlanking = 512,
+ .HSyncOffset = 88,
+ .HSyncWidth = 168,
+ .VActive = 900,
+ .VBlanking = 34,
+ .VSyncOffset = 3,
+ .VSyncWidth = 5,
+ .Flags = 0x00000500,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1400x1050 @ 60Hz
+ .Reserved1 = 0,
+ .Reserved2 = 2,
+ .PixelClock = 12175,
+ .HActive = 1400,
+ .HBlanking = 464,
+ .HSyncOffset = 88,
+ .HSyncWidth = 144,
+ .VActive = 1050,
+ .VBlanking = 39,
+ .VSyncOffset = 3,
+ .VSyncWidth = 4,
+ .Flags = 0x00000100,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1600x1200 @ 60Hz
+ .Reserved1 = 0,
+ .Reserved2 = 2,
+ .PixelClock = 16200,
+ .HActive = 1600,
+ .HBlanking = 560,
+ .HSyncOffset = 64,
+ .HSyncWidth = 192,
+ .VActive = 1200,
+ .VBlanking = 50,
+ .VSyncOffset = 1,
+ .VSyncWidth = 3,
+ .Flags = 0x00000000,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ },
+ {
+ // 1920 x 1080
+ .Reserved2 = 2,
+ .PixelClock = 14850,
+ .HActive = 1920,
+ .HBlanking = 280,
+ .HSyncOffset = 88,
+ .HSyncWidth = 44,
+ .VActive = 1080,
+ .VBlanking = 45,
+ .VSyncOffset = 4,
+ .VSyncWidth = 5,
+ .Flags = 0x00000000,
+ .Accumulate = 1,
+ .Reserved3 = 0,
+ .Reserved4 = 0,
+ .Reserved5 = 0x00000000,
+ .Vic = 0,
+ .ActiveFormat = 0,
+ }
+};
+
+STATIC CONST UINT32 NumSupportedVideoModes = (sizeof (ModeData) / sizeof (struct VideoMode));
+
+/**
+Find the number of pre-calculated video modes that we support.
+
+@retval Number of modes.
+
+**/
+UINT32 DlVideoModeGetNumSupportedVideoModes ()
+{
+ return NumSupportedVideoModes;
+}
+
+/**
+Get one of the pre-calculated video modes
+
+@param index The video mode that we want.
+
+@retval NULL The index was out of range.
+
+**/
+CONST struct VideoMode *DlVideoModeGetSupportedVideoMode (
+ UINT32 Index
+ )
+{
+ if (Index >= NumSupportedVideoModes) {
+ return NULL;
+ }
+ return &ModeData[Index];
+}
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkPkg.dsc b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkPkg.dsc
new file mode 100644
index 000000000000..955331ba6076
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkPkg.dsc
@@ -0,0 +1,61 @@
+#/** @file
+#
+# Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+#**/
+
+[Defines]
+ PLATFORM_NAME = DisplayLinkPkg
+ PLATFORM_GUID = ad3b37b0-f798-4f97-9b3f-0c6f43d7c993
+ PLATFORM_VERSION = 0.1
+ DSC_SPECIFICATION = 0x0001001C
+ OUTPUT_DIRECTORY = Build/DisplayLink
+ SUPPORTED_ARCHITECTURES = X64|IA32|AARCH64|ARM
+ BUILD_TARGETS = DEBUG|RELEASE|NOOPT
+ SKUID_IDENTIFIER = DEFAULT
+
+[LibraryClasses]
+ BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
+ BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
+ DebugLib|MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf
+ DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
+ DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
+ PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+ PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
+ ReportStatusCodeLib|MdeModulePkg/Library/DxeReportStatusCodeLib/DxeReportStatusCodeLib.inf
+ UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
+ UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
+ UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
+ UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
+ UefiUsbLib|MdePkg/Library/UefiUsbLib/UefiUsbLib.inf
+
+[LibraryClasses.common.UEFI_DRIVER]
+ MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
+
+[LibraryClasses.AARCH64]
+ NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
+ NULL|MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
+
+[LibraryClasses.ARM]
+ NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
+ NULL|MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
+
+[PcdsFixedAtBuild]
+!ifdef $(DEBUG_ENABLE_OUTPUT)
+ gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x3f
+ gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80080043 # Flags to control amount of debug output - see
https://github.com/tianocore/tianocore.github.io/wiki/EDK-II-Debugging
+ gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x07
+!endif
+
+[Components]
+ Drivers/DisplayLink/DisplayLinkPkg/DisplayLinkGop/DisplayLinkGopDxe.inf
+
+[BuildOptions]
+ *_*_*_CC_FLAGS = -D DISABLE_NEW_DEPRECATED_INTERFACES -D
INF_DRIVER_VERSION=$(INF_DRIVER_VERSION)
+ GCC:RELEASE_*_*_CC_FLAGS = -DMDEPKG_NDEBUG
+ MSFT:RELEASE_*_*_CC_FLAGS = /D MDEPKG_NDEBUG
+!ifdef $(COPY_PIXELS_FROM_PRIMARY_GOP_DEVICE)
+ *_*_*_CC_FLAGS = -D COPY_PIXELS_FROM_PRIMARY_GOP_DEVICE
+!endif
diff --git a/Drivers/DisplayLink/DisplayLinkPkg/ReadMe.md b/Drivers/DisplayLink/DisplayLinkPkg/ReadMe.md
new file mode 100644
index 000000000000..40061f1eb46d
--- /dev/null
+++ b/Drivers/DisplayLink/DisplayLinkPkg/ReadMe.md
@@ -0,0 +1,77 @@
+# DISPLAYLINK DRIVERS
+This package contains a GOP driver for Universal USB-connected docks containing the
+DisplayLink DL-6xxx chip or newer.
+
+[DisplayLink Website](http://www.displaylink.com)
+
+[Products](https://www.displaylink.com/products/universal-docking-stations)
+
+# INDEX
+
+* [Resolutions Supported](#resolutions-supported)
+* [Frame rates](#frame-rates)
+* [Multiple monitor outputs](#multiple-monitor-outputs)
+* [Multiple DisplayLink devices](#multiple-displaylink-devices)
+* [Behaviour with no monitor connected](#behaviour-with-no-monitor-connected)
+
+# Resolutions supported
+
+The driver supports the following resolutions:
+
+640 x 480 @ 60Hz
+
+800 x 600 @ 60Hz
+
+1024x768 @ 60Hz
+
+1360x768 @ 60Hz
+
+1280x960 @ 60Hz
+
+1280x1024 @ 60Hz
+
+1600x900 @ 60Hz
+
+1400x1050 @ 60Hz
+
+1600x1200 @ 60Hz
+
+1920x1080 @ 60Hz
+
+
+Note that the list of resolutions advertised by the driver may be smaller than
+this if a connected monitor does not support a particular resolution. The driver
+interrogates connected monitors to see which modes can be supported.It is the
+responsibility of the BIOS to select the video mode from this list which most
+closely matches its requirements. In some cases this may lead to the BIOS
+scaling its display.
+
+# Frame rates
+
+The driver is limited to a maximum of ten frames per second. Some slower systems
+at higher screen resolutions may perform at a lower rate than this.
+
+# Multiple monitor outputs
+
+If multiple monitors are connected to the DisplayLinkdevice, the display will be
+duplicated (cloned) across all outputs at the same resolution. The resolution
+used will be limited by the capability of the monitor with the
+lowest specification.
+
+# Multiple DisplayLink devices
+
+The driver will support the connection of multiple DisplayLink devices. The
+exact behaviourof the system with multiple devices connected is defined by the
+rest of the BIOS; usually, the BIOS causes the displays to be duplicated
+(cloned) across all devices. Note that the system performance and frame rate
+will be affected by the number of DisplayLink devices connected.
+
+# Behaviour with no monitor connected
+
+The driver uses the EDID (Extended Display Identification Data) protocol to
+detect the list of resolutions that a monitor will support.In some monitors this
+may take some time, and occasionally no EDID information will be returned at
+all. In this case the driver will not be able to detect that there is a monitor
+connected. To improve the user experience in these cases, the driver will behave
+as if there is a monitor connected, and will fall back to presenting the full
+range of supported resolutions to the BIOS.
diff --git a/Maintainers.txt b/Maintainers.txt
index 876ae5612ad8..47aac133abb1 100644
--- a/Maintainers.txt
+++ b/Maintainers.txt
@@ -47,6 +47,11 @@ Drivers/OptionRomPkg
W: https://github.com/tianocore/tianocore.github.io/wiki/OptionRomPkg
M: Ray Ni <ray.ni@intel.com>

+Drivers/DisplayLink
+M: Leif Lindholm <leif.lindholm@linaro.org>
+M: Ard Bieshuevel <ard.bieshuevel@linaro.org>
+R: Andy Hayes <andy.hayes@displaylink.com>
+
Platform
M: Ard Biesheuvel <ard.biesheuvel@linaro.org>
M: Leif Lindholm <leif.lindholm@linaro.org>
--
2.20.1


[PATCH v2 9/9] EmbeddedPkg: convert Lauterbach README.txt to 7-bit safe Readme.md

Leif Lindholm
 

This file contained what looked like windows 1250 encoded single
quotation marks. Convert them to regular 's. Rework the file to
markdown format and and rename it Readme.md while we're at it.

Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: "Kinney, Michael D" <michael.d.kinney@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
EmbeddedPkg/Scripts/LauterbachT32/README.txt | 7 -------
EmbeddedPkg/Scripts/LauterbachT32/Readme.md | 16 ++++++++++++++++
2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/EmbeddedPkg/Scripts/LauterbachT32/README.txt b/EmbeddedPkg/Scripts/LauterbachT32/README.txt
deleted file mode 100644
index 06602ab8763a..000000000000
--- a/EmbeddedPkg/Scripts/LauterbachT32/README.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-DXE Phase Debug
-===============
-Update the memsize variable in EfiLoadDxe.cmm for the actual amount of memory available in your system. Allow your system to boot to the point that the DXE core is initialized (so that the System Table and Debug Information table is present in memory) and execute this script (using the toolbar button or ‘do EfiLoadDxe’ from the command area). It will scan memory for the debug info table and load modules in it.
-
-SEC/PEI Phase Debug
-===================
-There is no way to autodetect where these images reside so you must pass an address for the memory-mapped Firmware Volume containing these images. To do this, enter ‘do EfiLoadFv <addr>’ where <addr> is the base address for the firmware volume containing the SEC or PEI code. To be more efficient you may want to create a script that calls this, like MyBoardLoadSec.cmm which contains the call to EfiLoadFv. You can them map this script to a T32 menu or toolbar button for quick access.
diff --git a/EmbeddedPkg/Scripts/LauterbachT32/Readme.md b/EmbeddedPkg/Scripts/LauterbachT32/Readme.md
new file mode 100644
index 000000000000..51d2c8da5405
--- /dev/null
+++ b/EmbeddedPkg/Scripts/LauterbachT32/Readme.md
@@ -0,0 +1,16 @@
+# DXE Phase Debug
+Update the memsize variable in EfiLoadDxe.cmm for the actual amount of memory
+available in your system. Allow your system to boot to the point that the DXE
+core is initialized (so that the System Table and Debug Information table is
+present in memory) and execute this script (using the toolbar button or
+'do EfiLoadDxe' from the command area). It will scan memory for the debug info
+table and load modules in it.
+
+# SEC/PEI Phase Debug
+There is no way to autodetect where these images reside so you must pass an
+address for the memory-mapped Firmware Volume containing these images. To do
+this, enter 'do EfiLoadFv <addr>' where <addr> is the base address for the
+firmware volume containing the SEC or PEI code. To be more efficient you may
+want to create a script that calls this, like MyBoardLoadSec.cmm which contains
+the call to EfiLoadFv. You can them map this script to a T32 menu or toolbar
+button for quick access.
--
2.20.1


[PATCH v2 8/9] BaseTools: correct line endings for ConvertFce Python script

Leif Lindholm
 

Cc: Bob Feng <bob.c.feng@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
Reviewed-by: Bob Feng <bob.c.feng@intel.com>
---
BaseTools/Scripts/ConvertFceToStructurePcd.py | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/BaseTools/Scripts/ConvertFceToStructurePcd.py b/BaseTools/Scripts/ConvertFceToStructurePcd.py
index 10f19dbe2f3c..89e6a727a201 100644
--- a/BaseTools/Scripts/ConvertFceToStructurePcd.py
+++ b/BaseTools/Scripts/ConvertFceToStructurePcd.py
@@ -506,8 +506,8 @@ class mainprocess(object):
for i in range(len(info_list)-1,-1,-1):
if len(info_list[i]) == 0:
info_list.remove(info_list[i])
- for i in (inf_list, title_all, header_list):
- i.sort()
+ for i in (inf_list, title_all, header_list):
+ i.sort()
return keys,title_all,info_list,header_list,inf_list

def remove_bracket(self,List):
@@ -519,9 +519,9 @@ class mainprocess(object):
List[List.index(i)][i.index(j)] = "|".join(tmp)
else:
List[List.index(i)][i.index(j)] = j
- for i in List:
- if type(i) == type([0,0]):
- i.sort()
+ for i in List:
+ if type(i) == type([0,0]):
+ i.sort()
return List

def write_all(self):
--
2.20.1


[PATCH v2 7/9] ArmPkg: ArmScmiDxe - convert .h to from 8859-x to 7-bit

Leif Lindholm
 

A paragraph sign in a comment came from some ISO8859 encoding,
convert it to the word "section" to remain 7-bit safe, since we're
not actually doing anything special.

Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: "Kinney, Michael D" <michael.d.kinney@intel.com>
Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
---
ArmPkg/Drivers/ArmScmiDxe/ArmScmiPerformanceProtocolPrivate.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ArmPkg/Drivers/ArmScmiDxe/ArmScmiPerformanceProtocolPrivate.h b/ArmPkg/Drivers/ArmScmiDxe/ArmScmiPerformanceProtocolPrivate.h
index ee8734bbaab0..b274b5ab2ad4 100644
--- a/ArmPkg/Drivers/ArmScmiDxe/ArmScmiPerformanceProtocolPrivate.h
+++ b/ArmPkg/Drivers/ArmScmiDxe/ArmScmiPerformanceProtocolPrivate.h
@@ -23,7 +23,7 @@
#define NUM_REMAIN_PERF_LEVELS(Lvls) (Lvls >> NUM_REMAIN_PERF_LEVELS_SHIFT)

/** Return values for SCMI_MESSAGE_ID_PERFORMANCE_DESCRIBE_LEVELS command.
- SCMI Spec § 4.5.2.5
+ SCMI Spec section 4.5.2.5
**/
typedef struct {
UINT32 NumLevels;
--
2.20.1