Mirrors_UI_SDK/GacUI
1
0
Fork 0
mirror of https://github.com/vczh-libraries/Release.git synced 2026-02-06 03:42:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
b9ee2b3e22bb8e910aef777b68da396f597950f8
GacUI/Import/VlppGlrParserCompiler.h
vczh 2cbfa381c0 Update release
2025-12-22 05:29:21 -08:00

3276 lines
111 KiB
C++
Raw Blame History

/***********************************************************************
THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY
DEVELOPER: Zihan Chen(vczh)
***********************************************************************/
#include "VlppOS.h"
#include "Vlpp.h"
#include "VlppGlrParser.h"
#include "VlppReflection.h"
#include "VlppRegex.h"
/***********************************************************************
.\PARSERGEN_GLOBAL\PARSERSYMBOL.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_PARSERSYMBOl
#define VCZH_PARSER2_PARSERGEN_PARSERSYMBOl
namespace vl
{
namespace glr
{
namespace parsergen
{
template<typename T>
struct MappedOwning
{
private:
collections::List<Ptr<T>> items;
public:
collections::List<WString> order;
collections::Dictionary<WString, T*> map;
bool Add(const WString& name, T* item)
{
items.Add(Ptr(item));
if (map.Keys().Contains(name)) return false;
order.Add(name);
map.Add(name, item);
return true;
}
Ptr<T> Remove(const WString& name)
{
vint indexKey = map.Keys().IndexOf(name);
if (indexKey == -1) return nullptr;
auto raw = map.Values()[indexKey];
vint indexItem = items.IndexOf(raw);
auto shared = items[indexItem];
items.RemoveAt(indexItem);
order.Remove(name);
map.Remove(name);
return shared;
}
};
template<typename ...TArgs>
void Fill(collections::List<WString>& ss, TArgs&& ...args)
{
WString items[] = { args... };
for (auto& item : items)
{
ss.Add(item);
}
}
/***********************************************************************
ParserSymbolManager
***********************************************************************/
#define GLR_PARSER_ERROR_LIST(ERROR_ITEM)\
/* AstSymbolManager */\
ERROR_ITEM(DuplicatedFileGroup, fileGroupName)\
ERROR_ITEM(DuplicatedFile, fileName)\
ERROR_ITEM(FileGroupDependencyNotExists, fileGroupName, dependency)\
ERROR_ITEM(FileGroupCyclicDependency, fileGroupName, dependency)\
ERROR_ITEM(DuplicatedSymbolInFile, fileName, symbolName)\
ERROR_ITEM(DuplicatedSymbolInFileGroup, fileName, symbolName, anotherFileName)\
ERROR_ITEM(DuplicatedClassProp, fileName, className, propName)\
ERROR_ITEM(DuplicatedEnumItem, fileName, enumName, propName)\
ERROR_ITEM(BaseClassNotExists, fileName, className, typeName)\
ERROR_ITEM(BaseClassNotClass, fileName, className, typeName)\
ERROR_ITEM(BaseClassNotPublic, fileName, className, typeName)\
ERROR_ITEM(BaseClassCyclicDependency, fileName, className)\
ERROR_ITEM(FieldTypeNotExists, fileName, className, propName)\
ERROR_ITEM(FieldTypeNotClass, fileName, className, propName)\
ERROR_ITEM(FieldTypeNotPublic, fileName, className, propName)\
/* LexerSymbolManager */\
ERROR_ITEM(InvalidTokenDefinition, code)\
ERROR_ITEM(DuplicatedToken, tokenName)\
ERROR_ITEM(DuplicatedTokenByDisplayText, tokenName)\
ERROR_ITEM(InvalidTokenRegex, tokenName, errorMessage)\
ERROR_ITEM(TokenRegexNotPure, tokenName)\
ERROR_ITEM(DuplicatedTokenFragment, fragmentName)\
ERROR_ITEM(TokenFragmentNotExists, fragmentName)\
/* SyntaxSymbolManager */\
ERROR_ITEM(DuplicatedRule, ruleName)\
ERROR_ITEM(RuleIsIndirectlyLeftRecursive, ruleNames) /* Indirect left recursion must be resolved before */\
/* SyntaxAst(ResolveName) */\
ERROR_ITEM(RuleNameConflictedWithToken, ruleName)\
ERROR_ITEM(TypeNotUniqueInRule, ruleName, name)\
ERROR_ITEM(TypeNotExistsInRule, ruleName, name)\
ERROR_ITEM(TypeNotClassInRule, ruleName, name)\
ERROR_ITEM(TokenOrRuleNotExistsInRule, ruleName, name)\
ERROR_ITEM(ReferencedRuleNotPublicInRuleOfDifferentFile, ruleName, name)\
ERROR_ITEM(LiteralNotValidToken, ruleName, name)\
ERROR_ITEM(LiteralIsDiscardedToken, ruleName, name)\
ERROR_ITEM(ConditionalLiteralNotValidToken, ruleName, name)\
ERROR_ITEM(ConditionalLiteralIsDiscardedToken, ruleName, name)\
ERROR_ITEM(ConditionalLiteralIsDisplayText, ruleName, name)\
ERROR_ITEM(DuplicatedSwitch, switchName)\
ERROR_ITEM(UnusedSwitch, switchName)\
ERROR_ITEM(SwitchNotExists, ruleName, switchName)\
ERROR_ITEM(SyntaxInvolvesSwitchWithIllegalRuleName, ruleName) /* A syntax uses switch should not use rule name that has _SWITCH/SWITCH_ */\
/* SyntaxAst(CalculateTypes) */\
ERROR_ITEM(RuleMixedPartialClauseWithOtherClause, ruleName)\
ERROR_ITEM(RuleWithDifferentPartialTypes, ruleName, ruleType, newType)\
ERROR_ITEM(RuleExplicitTypeIsNotCompatibleWithClauseType, ruleName, ruleType, newType) /* The type of the rule is explicitly specified, but it is incompatible with its clauses */\
ERROR_ITEM(RuleCannotResolveToDeterministicType, ruleName, ruleType, newType) /* Unable to resolve to one type from clauses (token, type) or (create, partial) */\
ERROR_ITEM(CyclicDependedRuleTypeIncompatible, ruleName, ruleTypes) /* Types of rules are not compatible to each other when they build cyclic dependency by reuse clauses */\
ERROR_ITEM(ReuseClauseCannotResolveToDeterministicType, ruleName, ruleTypes) /* A reuse clause contains multiple use rule but their types are not compatible to each other */\
ERROR_ITEM(ReuseClauseContainsNoUseRule, ruleName) /* A reuse clause contains no use rule therefore the type cannot be determined */\
/* SyntaxAst(ValidateSwitchesAndConditions, condition) */\
ERROR_ITEM(PushedSwitchIsNotTested, ruleName, switchName)\
ERROR_ITEM(SwitchUnaffectedRuleNotExist)\
/* SyntaxAst(RewriteSyntax_Switch, condition) */\
ERROR_ITEM(SwitchUnaffectedRuleExpandedToNoClause, ruleName)\
ERROR_ITEM(SwitchAffectedRuleExpandedToNoClause, ruleName, expandedRuleName)\
/* SyntaxAst(ValidateTypes) */\
ERROR_ITEM(FieldNotExistsInClause, ruleName, clauseType, fieldName) /* The field does not exist in the type of the clause */\
ERROR_ITEM(RuleTypeMismatchedToField, ruleName, clauseType, fieldName, fieldRuleType) /* The rule type is not compatible to the assigning field */\
ERROR_ITEM(AssignmentToNonEnumField, ruleName, clauseType, fieldName) /* Assignment can only assign fields in enum types */\
ERROR_ITEM(EnumItemMismatchedToField, ruleName, clauseType, fieldName, enumItem) /* Try to assign an unexisting or mismatched enum item to a field in an enum type */\
ERROR_ITEM(UseRuleWithPartialRule, ruleName, useRuleName) /* A use rule should not be used with a partial rule */\
ERROR_ITEM(UseRuleInNonReuseClause, ruleName, useRuleName) /* A use rule should only appear in reuse clause */\
ERROR_ITEM(PartialRuleUsedOnField, ruleName, clauseType, partialRuleName, fieldName) /* A partial rule does not create object, it cannot be assigned to a field */\
ERROR_ITEM(ClauseTypeMismatchedToPartialRule, ruleName, clauseType, partialRuleName, partialRuleType) /* A clause uses a partial rule of an incompatible type */\
/* SyntaxAst(ValidateStructure, counting) */\
ERROR_ITEM(ClauseNotCreateObject, ruleName) /* A reuse clause does not contain use rule in some potential sequences */\
ERROR_ITEM(UseRuleUsedInOptionalBody, ruleName, useRuleName)\
ERROR_ITEM(UseRuleUsedInLoopBody, ruleName, useRuleName)\
ERROR_ITEM(ClauseTooManyUseRule, ruleName) /* Multiple use rules in a potential sequence in a clause */\
ERROR_ITEM(NonArrayFieldAssignedInLoop, ruleName, clauseType, fieldName)\
ERROR_ITEM(NonLoopablePartialRuleUsedInLoop, ruleName, clauseType, partialRuleName)\
ERROR_ITEM(ClauseCouldExpandToEmptySequence, ruleName)\
ERROR_ITEM(LoopBodyCouldExpandToEmptySequence, ruleName)\
ERROR_ITEM(OptionalBodyCouldExpandToEmptySequence, ruleName)\
ERROR_ITEM(NegativeOptionalEndsAClause, ruleName) /* Negative optional syntax cannot ends a clause */\
ERROR_ITEM(MultiplePrioritySyntaxInAClause, ruleName)\
/* SyntaxAst(ValidateStructure, relationship) */\
ERROR_ITEM(FieldAssignedMoreThanOnce, ruleName, clauseType, fieldName)\
ERROR_ITEM(PartialRuleIsRecursive, ruleName)\
enum class ParserErrorType
{
#define ParserErrorType_EnumItem(NAME, ...) NAME,
GLR_PARSER_ERROR_LIST(ParserErrorType_EnumItem)
#undef ParserErrorType_EnumItem
};
enum class ParserDefFileType
{
AstGroup,
Ast,
Lexer,
Syntax,
};
struct ParserErrorLocation
{
ParserDefFileType type;
WString name;
ParsingTextRange codeRange;
};
struct ParserError
{
ParserErrorType type;
ParserErrorLocation location;
WString arg1;
WString arg2;
WString arg3;
WString arg4;
};
class ParserSymbolManager : public Object
{
using ErrorList = collections::List<ParserError>;
using StringItems = collections::List<WString>;
protected:
ErrorList errors;
public:
WString name;
StringItems astIncludes;
StringItems syntaxIncludes;
StringItems cppNss;
WString headerGuard;
const auto& Errors() const { return errors; }
template<typename ...TArgs>
void AddError(ParserErrorType type, ParserErrorLocation location, TArgs&& ...args)
{
ParserError error;
error.type = type;
error.location = location;
if constexpr (sizeof...(args) > 0)
{
WString sargs[] = { WString(args)... };
WString* dargs[] = { &error.arg1,&error.arg2,&error.arg3,&error.arg4 };
constexpr vint sl = sizeof(sargs) / sizeof(*sargs);
constexpr vint dl = sizeof(dargs) / sizeof(*dargs);
constexpr vint ml = sl < dl ? sl : dl;
for (vint i = 0; i < ml; i++)
{
*dargs[i] = sargs[i];
}
}
errors.Add(std::move(error));
}
};
/***********************************************************************
Utility
***********************************************************************/
extern void InitializeParserSymbolManager(ParserSymbolManager& manager);
}
}
}
#endif
/***********************************************************************
.\AST\ASTSYMBOL.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_AST_ASTSYMBOL
#define VCZH_PARSER2_AST_ASTSYMBOL
namespace vl
{
namespace glr
{
namespace parsergen
{
class AstEnumSymbol;
class AstClassSymbol;
class AstDefFile;
class AstDefFileGroup;
class AstSymbolManager;
/***********************************************************************
AstSymbol
***********************************************************************/
class AstSymbol : public Object
{
protected:
AstDefFile* ownerFile = nullptr;
WString name;
AstSymbol(AstDefFile* _file, const WString& _name);
public:
bool isPublic = false;
AstDefFile* Owner() const { return ownerFile; }
const WString& Name() const { return name; }
};
/***********************************************************************
AstEnumSymbol
***********************************************************************/
class AstEnumItemSymbol : public AstSymbol
{
friend class AstEnumSymbol;
protected:
AstEnumSymbol* parent = nullptr;
AstEnumItemSymbol(AstEnumSymbol* _parent, const WString& name);
public:
vint value = 0;
AstEnumSymbol* Parent() const { return parent; }
};
class AstEnumSymbol : public AstSymbol
{
friend class AstDefFile;
protected:
MappedOwning<AstEnumItemSymbol> items;
AstEnumSymbol(AstDefFile* _file, const WString& _name);
public:
AstEnumItemSymbol* CreateItem(const WString& itemName, ParsingTextRange codeRange = {});
const auto& Items() const { return items.map; }
const auto& ItemOrder() const { return items.order; }
};
/***********************************************************************
AstClassSymbol
***********************************************************************/
enum class AstPropType
{
Token,
Type,
Array,
};
class AstClassPropSymbol : public AstSymbol
{
friend class AstClassSymbol;
protected:
AstClassSymbol* parent = nullptr;
AstClassPropSymbol(AstClassSymbol* _parent, const WString& name);
public:
AstPropType propType = AstPropType::Token;
AstSymbol* propSymbol = nullptr;
AstClassSymbol* Parent() const { return parent; }
bool SetPropType(AstPropType _type, const WString& typeName = WString::Empty, ParsingTextRange codeRange = {});
};
enum class AstClassType
{
Defined,
Generated_ToResolve,
Generated_Common,
};
class AstClassSymbol : public AstSymbol
{
friend class AstDefFile;
protected:
MappedOwning<AstClassPropSymbol> props;
AstClassSymbol(AstDefFile* _file, const WString& _name);
public:
AstClassType classType = AstClassType::Defined;
AstClassSymbol* baseClass = nullptr;
collections::List<AstClassSymbol*> derivedClasses;
AstClassSymbol* derivedClass_ToResolve = nullptr;
AstClassSymbol* derivedClass_Common = nullptr;
bool SetBaseClass(const WString& typeName, ParsingTextRange codeRange = {});
AstClassSymbol* CreateDerivedClass_ToResolve(ParsingTextRange codeRange);
AstClassSymbol* CreateDerivedClass_Common(ParsingTextRange codeRange);
AstClassPropSymbol* CreateProp(const WString& propName, ParsingTextRange codeRange = {});
const auto& Props() const { return props.map; }
const auto& PropOrder() const { return props.order; }
};
extern AstClassSymbol* FindCommonBaseClass(AstClassSymbol* c1, AstClassSymbol* c2);
extern AstClassPropSymbol* FindPropSymbol(AstClassSymbol*& type, const WString& name);
/***********************************************************************
AstDefFile
***********************************************************************/
class AstDefFile : public Object
{
friend class AstDefFileGroup;
using DependenciesList = collections::List<WString>;
using StringItems = collections::List<WString>;
protected:
AstDefFileGroup* ownerGroup = nullptr;
WString name;
MappedOwning<AstSymbol> symbols;
template<typename T>
T* CreateSymbol(const WString& symbolName, ParsingTextRange codeRange);
AstDefFile(AstDefFileGroup* _ownerGroup, const WString& _name);
public:
AstDefFileGroup* Owner() const { return ownerGroup; }
const WString& Name() const { return name; }
AstEnumSymbol* CreateEnum(const WString& symbolName, bool isPublic = false, ParsingTextRange codeRange = {});
AstClassSymbol* CreateClass(const WString& symbolName, bool isPublic = false, ParsingTextRange codeRange = {});
const auto& Symbols() const { return symbols.map; }
const auto& SymbolOrder() const { return symbols.order; }
template<typename ...TArgs>
void AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args);
};
/***********************************************************************
AstDefFileGroup
***********************************************************************/
class AstDefFileGroup : public Object
{
friend class AstDefFile;
friend class AstSymbolManager;
using DependenciesList = collections::List<WString>;
using StringItems = collections::List<WString>;
using SymbolMap = collections::Dictionary<WString, AstSymbol*>;
protected:
AstSymbolManager* ownerManager = nullptr;
WString name;
MappedOwning<AstDefFile> files;
SymbolMap symbolMap;
AstDefFileGroup(AstSymbolManager* _ownerManager, const WString& _name);
public:
DependenciesList dependencies;
StringItems cppNss;
StringItems refNss;
WString classPrefix;
AstSymbolManager* Owner() const { return ownerManager; }
const WString& Name() const { return name; }
bool AddDependency(const WString& dependency, ParsingTextRange codeRange = {});
AstDefFile* CreateFile(const WString& name);
const auto& Files() const { return files.map; }
const auto& FileOrder() const { return files.order; }
const auto& Symbols() const { return symbolMap; }
collections::LazyList<WString> SymbolOrder()
{
return From(files.order)
.Select([this](const WString& fileName) { return files.map[fileName]; })
.SelectMany([](AstDefFile* file) { return From(file->SymbolOrder()); })
;
}
template<typename ...TArgs>
void AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args);
};
/***********************************************************************
AstSymbolManager
***********************************************************************/
class AstSymbolManager : public Object
{
friend class AstDefFile;
using SymbolGroup = collections::Group<WString, AstSymbol*>;
using FileMap = collections::Dictionary<WString, AstDefFile*>;
protected:
ParserSymbolManager& global;
MappedOwning<AstDefFileGroup> fileGroups;
SymbolGroup symbolGroup;
FileMap fileMap;
public:
AstSymbolManager(ParserSymbolManager& _global);
AstDefFileGroup* CreateFileGroup(const WString& name);
const ParserSymbolManager& Global() const { return global; }
const auto& FileGroups() const { return fileGroups.map; }
const auto& FileGroupOrder() const { return fileGroups.order; }
const auto& Symbols() const { return symbolGroup; }
const auto& Files() const { return fileMap; }
};
extern AstDefFile* CreateParserGenTypeAst(AstSymbolManager& manager);
extern AstDefFile* CreateParserGenRuleAst(AstSymbolManager& manager);
/***********************************************************************
AddError
***********************************************************************/
template<typename ...TArgs>
void AstDefFile::AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args)
{
auto&& global = const_cast<ParserSymbolManager&>(ownerGroup->Owner()->Global());
global.AddError(type, { ParserDefFileType::Ast,name,codeRange }, std::forward<TArgs&&>(args)...);
}
template<typename ...TArgs>
void AstDefFileGroup::AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args)
{
auto&& global = const_cast<ParserSymbolManager&>(ownerManager->Global());
global.AddError(type, { ParserDefFileType::AstGroup,name,codeRange }, std::forward<TArgs&&>(args)...);
}
}
}
}
#endif
/***********************************************************************
.\LEXER\LEXERSYMBOL.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_LEXER_LEXERSYMBOL
#define VCZH_PARSER2_LEXER_LEXERSYMBOL
namespace vl
{
namespace glr
{
namespace parsergen
{
class LexerSymbolManager;
/***********************************************************************
LexerSymbolManager
***********************************************************************/
class TokenSymbol : public Object
{
friend class LexerSymbolManager;
protected:
LexerSymbolManager* ownerManager;
WString name;
TokenSymbol(LexerSymbolManager* _ownerManager, const WString& _name);
public:
WString regex;
WString displayText;
bool discarded = false;
LexerSymbolManager* Owner() { return ownerManager; }
const WString& Name() { return name; }
};
class LexerSymbolManager : public Object
{
using TokenMap = collections::Dictionary<WString, TokenSymbol*>;
protected:
MappedOwning<TokenSymbol> tokens;
TokenMap tokensByDisplayText;
ParserSymbolManager& global;
public:
LexerSymbolManager(ParserSymbolManager& _global);
TokenSymbol* CreateToken(const WString& _name, const WString& _regex, ParsingTextRange codeRange = {});
TokenSymbol* CreateDiscardedToken(const WString& _name, const WString& _regex, ParsingTextRange codeRange = {});
const ParserSymbolManager& Global() const { return global; }
const auto& Tokens() const { return tokens.map; }
const auto& TokensByDisplayText() const { return tokensByDisplayText; }
const auto& TokenOrder() const { return tokens.order; }
template<typename ...TArgs>
void AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args) const
{
global.AddError(type, { ParserDefFileType::Lexer,WString::Empty,codeRange }, std::forward<TArgs&&>(args)...);
}
};
extern void CreateParserGenLexer(LexerSymbolManager& manager);
}
}
}
#endif
/***********************************************************************
.\PARSERGEN_GLOBAL\PARSERCPPGEN.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_PARSERCPPGEN
#define VCZH_PARSER2_PARSERGEN_PARSERCPPGEN
namespace vl
{
namespace glr
{
namespace parsergen
{
class AstDefFileGroup;
class AstClassPropSymbol;
class AstClassSymbol;
class TokenSymbol;
class SyntaxSymbolManager;
/***********************************************************************
Output
***********************************************************************/
struct CppAstGenOutput
{
WString astH;
WString astCpp;
WString builderH;
WString builderCpp;
WString emptyH;
WString emptyCpp;
WString copyH;
WString copyCpp;
WString traverseH;
WString traverseCpp;
WString jsonH;
WString jsonCpp;
};
struct CppSyntaxGenOutput
{
WString syntaxH;
WString syntaxCpp;
};
struct CppParserGenOutput
{
WString assemblyH;
WString assemblyCpp;
WString lexerH;
WString lexerCpp;
collections::Dictionary<AstDefFileGroup*, Ptr<CppAstGenOutput>> astOutputs;
collections::Dictionary<SyntaxSymbolManager*, Ptr<CppSyntaxGenOutput>> syntaxOutputs;
collections::Dictionary<AstClassSymbol*, vint32_t> classIds;
collections::Dictionary<AstClassPropSymbol*, vint32_t> fieldIds;
collections::Dictionary<TokenSymbol*, vint32_t> tokenIds;
};
/***********************************************************************
Utility
***********************************************************************/
extern Ptr<CppParserGenOutput> GenerateParserFileNames(ParserSymbolManager& manager);
extern void WriteCppStringBody(const WString& body, stream::StreamWriter& writer);
extern void WriteFileComment(const WString& name, stream::StreamWriter& writer);
extern void WriteNssName(const collections::List<WString>& cppNss, stream::StreamWriter& writer);
extern WString WriteNssBegin(const collections::List<WString>& cppNss, stream::StreamWriter& writer);
extern void WriteNssEnd(const collections::List<WString>& cppNss, stream::StreamWriter& writer);
extern void WriteLoadDataFunctionHeader(const WString& prefix, const WString& functionName, stream::StreamWriter& writer);
extern void WriteLoadDataFunctionCpp(const WString& prefix, const WString& functionName, stream::MemoryStream& rawData, bool compressData, stream::StreamWriter& writer);
}
}
}
#endif
/***********************************************************************
.\AST\ASTCPPGEN.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_AST_ASTCPPGEN
#define VCZH_PARSER2_AST_ASTCPPGEN
namespace vl
{
namespace glr
{
namespace parsergen
{
extern void GenerateAstFileNames(AstSymbolManager& manager, Ptr<CppParserGenOutput> parserOutput);
extern void WriteAstHeaderFile (AstDefFileGroup* group, stream::StreamWriter& writer);
extern void WriteAstCppFile (AstDefFileGroup* group, const WString& astHeaderName, stream::StreamWriter& writer);
extern void WriteAstUtilityHeaderFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, const WString& extraNss, stream::StreamWriter& writer, Func<void(const WString&)> callback);
extern void WriteAstUtilityCppFile (AstDefFileGroup* group, const WString& utilityHeaderFile, const WString& extraNss, stream::StreamWriter& writer, Func<void(const WString&)> callback);
extern void WriteParserUtilityHeaderFile (AstSymbolManager& manager, Ptr<CppParserGenOutput> output, const WString& guardPostfix, stream::StreamWriter& writer, Func<void(const WString&)> callback);
extern void WriteParserUtilityCppFile (AstSymbolManager& manager, const WString& utilityHeaderFile, stream::StreamWriter& writer, Func<void(const WString&)> callback);
extern void WriteAstBuilderHeaderFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteAstBuilderCppFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteEmptyVisitorHeaderFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteEmptyVisitorCppFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteCopyVisitorHeaderFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteCopyVisitorCppFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteTraverseVisitorHeaderFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteTraverseVisitorCppFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteJsonVisitorHeaderFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteJsonVisitorCppFile (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, stream::StreamWriter& writer);
extern void WriteAstAssemblerHeaderFile (AstSymbolManager& manager, Ptr<CppParserGenOutput> output, stream::StreamWriter& writer);
extern void WriteAstAssemblerCppFile (AstSymbolManager& manager, Ptr<CppParserGenOutput> output, stream::StreamWriter& writer);
extern void WriteAstFiles (AstDefFileGroup* group, Ptr<CppAstGenOutput> output, collections::Dictionary<WString, WString>& files);
extern void WriteAstFiles (AstSymbolManager& manager, Ptr<CppParserGenOutput> output, collections::Dictionary<WString, WString>& files);
}
}
}
#endif
/***********************************************************************
.\LEXER\LEXERCPPGEN.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_LEXER_LEXERCPPGEN
#define VCZH_PARSER2_LEXER_LEXERCPPGEN
namespace vl
{
namespace glr
{
namespace parsergen
{
extern void WriteLexerHeaderFile (LexerSymbolManager& manager, Ptr<CppParserGenOutput> output, stream::StreamWriter& writer);
extern void WriteLexerCppFile (LexerSymbolManager& manager, Ptr<CppParserGenOutput> output, stream::StreamWriter& writer);
extern void WriteLexerFiles (LexerSymbolManager& manager, Ptr<CppParserGenOutput> output, collections::Dictionary<WString, WString>& files);
}
}
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEAST.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:RuleAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEAST_AST
#define VCZH_PARSER2_PARSERGEN_RULEAST_AST
namespace vl::glr::parsergen
{
class GlrAlternativeSyntax;
class GlrAndCondition;
class GlrAssignment;
class GlrClause;
class GlrCondition;
class GlrCreateClause;
class GlrLoopSyntax;
class GlrNotCondition;
class GlrOptionalSyntax;
class GlrOrCondition;
class GlrPartialClause;
class GlrPushConditionSyntax;
class GlrRefCondition;
class GlrRefSyntax;
class GlrReuseClause;
class GlrRule;
class GlrSequenceSyntax;
class GlrSwitchItem;
class GlrSyntax;
class GlrSyntaxFile;
class GlrTestConditionBranch;
class GlrTestConditionSyntax;
class GlrUseSyntax;
enum class GlrSwitchValue
{
UNDEFINED_ENUM_ITEM_VALUE = -1,
False = 0,
True = 1,
};
enum class GlrRefType
{
UNDEFINED_ENUM_ITEM_VALUE = -1,
Id = 0,
Literal = 1,
ConditionalLiteral = 2,
};
enum class GlrOptionalPriority
{
UNDEFINED_ENUM_ITEM_VALUE = -1,
Equal = 0,
PreferTake = 1,
PreferSkip = 2,
};
enum class GlrAssignmentType
{
UNDEFINED_ENUM_ITEM_VALUE = -1,
Strong = 0,
Weak = 1,
};
class GlrCondition abstract : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrCondition>
{
public:
class IVisitor : public virtual vl::reflection::IDescriptable, vl::reflection::Description<IVisitor>
{
public:
virtual void Visit(GlrRefCondition* node) = 0;
virtual void Visit(GlrNotCondition* node) = 0;
virtual void Visit(GlrAndCondition* node) = 0;
virtual void Visit(GlrOrCondition* node) = 0;
};
virtual void Accept(GlrCondition::IVisitor* visitor) = 0;
};
class GlrRefCondition : public GlrCondition, vl::reflection::Description<GlrRefCondition>
{
public:
vl::glr::ParsingToken name;
void Accept(GlrCondition::IVisitor* visitor) override;
};
class GlrNotCondition : public GlrCondition, vl::reflection::Description<GlrNotCondition>
{
public:
vl::Ptr<GlrCondition> condition;
void Accept(GlrCondition::IVisitor* visitor) override;
};
class GlrAndCondition : public GlrCondition, vl::reflection::Description<GlrAndCondition>
{
public:
vl::Ptr<GlrCondition> first;
vl::Ptr<GlrCondition> second;
void Accept(GlrCondition::IVisitor* visitor) override;
};
class GlrOrCondition : public GlrCondition, vl::reflection::Description<GlrOrCondition>
{
public:
vl::Ptr<GlrCondition> first;
vl::Ptr<GlrCondition> second;
void Accept(GlrCondition::IVisitor* visitor) override;
};
class GlrSwitchItem : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrSwitchItem>
{
public:
vl::glr::ParsingToken name;
GlrSwitchValue value = GlrSwitchValue::UNDEFINED_ENUM_ITEM_VALUE;
};
class GlrSyntax abstract : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrSyntax>
{
public:
class IVisitor : public virtual vl::reflection::IDescriptable, vl::reflection::Description<IVisitor>
{
public:
virtual void Visit(GlrRefSyntax* node) = 0;
virtual void Visit(GlrUseSyntax* node) = 0;
virtual void Visit(GlrLoopSyntax* node) = 0;
virtual void Visit(GlrOptionalSyntax* node) = 0;
virtual void Visit(GlrSequenceSyntax* node) = 0;
virtual void Visit(GlrAlternativeSyntax* node) = 0;
virtual void Visit(GlrPushConditionSyntax* node) = 0;
virtual void Visit(GlrTestConditionSyntax* node) = 0;
};
virtual void Accept(GlrSyntax::IVisitor* visitor) = 0;
};
class GlrRefSyntax : public GlrSyntax, vl::reflection::Description<GlrRefSyntax>
{
public:
GlrRefType refType = GlrRefType::UNDEFINED_ENUM_ITEM_VALUE;
vl::glr::ParsingToken literal;
vl::glr::ParsingToken field;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrUseSyntax : public GlrSyntax, vl::reflection::Description<GlrUseSyntax>
{
public:
vl::glr::ParsingToken name;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrLoopSyntax : public GlrSyntax, vl::reflection::Description<GlrLoopSyntax>
{
public:
vl::Ptr<GlrSyntax> syntax;
vl::Ptr<GlrSyntax> delimiter;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrOptionalSyntax : public GlrSyntax, vl::reflection::Description<GlrOptionalSyntax>
{
public:
GlrOptionalPriority priority = GlrOptionalPriority::UNDEFINED_ENUM_ITEM_VALUE;
vl::Ptr<GlrSyntax> syntax;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrSequenceSyntax : public GlrSyntax, vl::reflection::Description<GlrSequenceSyntax>
{
public:
vl::Ptr<GlrSyntax> first;
vl::Ptr<GlrSyntax> second;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrAlternativeSyntax : public GlrSyntax, vl::reflection::Description<GlrAlternativeSyntax>
{
public:
vl::Ptr<GlrSyntax> first;
vl::Ptr<GlrSyntax> second;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrPushConditionSyntax : public GlrSyntax, vl::reflection::Description<GlrPushConditionSyntax>
{
public:
vl::collections::List<vl::Ptr<GlrSwitchItem>> switches;
vl::Ptr<GlrSyntax> syntax;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrTestConditionBranch : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrTestConditionBranch>
{
public:
vl::Ptr<GlrCondition> condition;
vl::Ptr<GlrSyntax> syntax;
};
class GlrTestConditionSyntax : public GlrSyntax, vl::reflection::Description<GlrTestConditionSyntax>
{
public:
vl::collections::List<vl::Ptr<GlrTestConditionBranch>> branches;
void Accept(GlrSyntax::IVisitor* visitor) override;
};
class GlrClause abstract : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrClause>
{
public:
class IVisitor : public virtual vl::reflection::IDescriptable, vl::reflection::Description<IVisitor>
{
public:
virtual void Visit(GlrCreateClause* node) = 0;
virtual void Visit(GlrPartialClause* node) = 0;
virtual void Visit(GlrReuseClause* node) = 0;
};
virtual void Accept(GlrClause::IVisitor* visitor) = 0;
};
class GlrAssignment : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrAssignment>
{
public:
GlrAssignmentType type = GlrAssignmentType::UNDEFINED_ENUM_ITEM_VALUE;
vl::glr::ParsingToken field;
vl::glr::ParsingToken value;
};
class GlrCreateClause : public GlrClause, vl::reflection::Description<GlrCreateClause>
{
public:
vl::glr::ParsingToken type;
vl::Ptr<GlrSyntax> syntax;
vl::collections::List<vl::Ptr<GlrAssignment>> assignments;
void Accept(GlrClause::IVisitor* visitor) override;
};
class GlrPartialClause : public GlrClause, vl::reflection::Description<GlrPartialClause>
{
public:
vl::glr::ParsingToken type;
vl::Ptr<GlrSyntax> syntax;
vl::collections::List<vl::Ptr<GlrAssignment>> assignments;
void Accept(GlrClause::IVisitor* visitor) override;
};
class GlrReuseClause : public GlrClause, vl::reflection::Description<GlrReuseClause>
{
public:
vl::Ptr<GlrSyntax> syntax;
vl::collections::List<vl::Ptr<GlrAssignment>> assignments;
void Accept(GlrClause::IVisitor* visitor) override;
};
class GlrRule : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrRule>
{
public:
vl::glr::ParsingToken attPublic;
vl::glr::ParsingToken attParser;
vl::glr::ParsingToken name;
vl::glr::ParsingToken type;
vl::collections::List<vl::Ptr<GlrClause>> clauses;
};
class GlrSyntaxFile : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrSyntaxFile>
{
public:
vl::collections::List<vl::Ptr<GlrSwitchItem>> switches;
vl::collections::List<vl::Ptr<GlrRule>> rules;
};
}
namespace vl::reflection::description
{
#ifndef VCZH_DEBUG_NO_REFLECTION
DECL_TYPE_INFO(vl::glr::parsergen::GlrCondition)
DECL_TYPE_INFO(vl::glr::parsergen::GlrCondition::IVisitor)
DECL_TYPE_INFO(vl::glr::parsergen::GlrRefCondition)
DECL_TYPE_INFO(vl::glr::parsergen::GlrNotCondition)
DECL_TYPE_INFO(vl::glr::parsergen::GlrAndCondition)
DECL_TYPE_INFO(vl::glr::parsergen::GlrOrCondition)
DECL_TYPE_INFO(vl::glr::parsergen::GlrSwitchValue)
DECL_TYPE_INFO(vl::glr::parsergen::GlrSwitchItem)
DECL_TYPE_INFO(vl::glr::parsergen::GlrSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrSyntax::IVisitor)
DECL_TYPE_INFO(vl::glr::parsergen::GlrRefType)
DECL_TYPE_INFO(vl::glr::parsergen::GlrRefSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrUseSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrLoopSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrOptionalPriority)
DECL_TYPE_INFO(vl::glr::parsergen::GlrOptionalSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrSequenceSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrAlternativeSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrPushConditionSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrTestConditionBranch)
DECL_TYPE_INFO(vl::glr::parsergen::GlrTestConditionSyntax)
DECL_TYPE_INFO(vl::glr::parsergen::GlrClause)
DECL_TYPE_INFO(vl::glr::parsergen::GlrClause::IVisitor)
DECL_TYPE_INFO(vl::glr::parsergen::GlrAssignmentType)
DECL_TYPE_INFO(vl::glr::parsergen::GlrAssignment)
DECL_TYPE_INFO(vl::glr::parsergen::GlrCreateClause)
DECL_TYPE_INFO(vl::glr::parsergen::GlrPartialClause)
DECL_TYPE_INFO(vl::glr::parsergen::GlrReuseClause)
DECL_TYPE_INFO(vl::glr::parsergen::GlrRule)
DECL_TYPE_INFO(vl::glr::parsergen::GlrSyntaxFile)
#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA
BEGIN_INTERFACE_PROXY_NOPARENT_SHAREDPTR(vl::glr::parsergen::GlrCondition::IVisitor)
void Visit(vl::glr::parsergen::GlrRefCondition* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrNotCondition* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrAndCondition* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrOrCondition* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
END_INTERFACE_PROXY(vl::glr::parsergen::GlrCondition::IVisitor)
BEGIN_INTERFACE_PROXY_NOPARENT_SHAREDPTR(vl::glr::parsergen::GlrSyntax::IVisitor)
void Visit(vl::glr::parsergen::GlrRefSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrUseSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrLoopSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrOptionalSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrSequenceSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrAlternativeSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrPushConditionSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrTestConditionSyntax* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
END_INTERFACE_PROXY(vl::glr::parsergen::GlrSyntax::IVisitor)
BEGIN_INTERFACE_PROXY_NOPARENT_SHAREDPTR(vl::glr::parsergen::GlrClause::IVisitor)
void Visit(vl::glr::parsergen::GlrCreateClause* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrPartialClause* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrReuseClause* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
END_INTERFACE_PROXY(vl::glr::parsergen::GlrClause::IVisitor)
#endif
#endif
/// <summary>Load all reflectable AST types, only available when <b>VCZH_DEBUG_NO_REFLECTION</b> is off.</summary>
/// <returns>Returns true if this operation succeeded.</returns>
extern bool ParserGenRuleAstLoadTypes();
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEAST_BUILDER.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:RuleAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEAST_AST_BUILDER
#define VCZH_PARSER2_PARSERGEN_RULEAST_AST_BUILDER
namespace vl::glr::parsergen::builder
{
class MakeAlternativeSyntax : public vl::glr::ParsingAstBuilder<GlrAlternativeSyntax>
{
public:
MakeAlternativeSyntax& first(const vl::Ptr<GlrSyntax>& value);
MakeAlternativeSyntax& second(const vl::Ptr<GlrSyntax>& value);
};
class MakeAndCondition : public vl::glr::ParsingAstBuilder<GlrAndCondition>
{
public:
MakeAndCondition& first(const vl::Ptr<GlrCondition>& value);
MakeAndCondition& second(const vl::Ptr<GlrCondition>& value);
};
class MakeAssignment : public vl::glr::ParsingAstBuilder<GlrAssignment>
{
public:
MakeAssignment& field(const vl::WString& value);
MakeAssignment& type(GlrAssignmentType value);
MakeAssignment& value(const vl::WString& value);
};
class MakeCreateClause : public vl::glr::ParsingAstBuilder<GlrCreateClause>
{
public:
MakeCreateClause& assignments(const vl::Ptr<GlrAssignment>& value);
MakeCreateClause& syntax(const vl::Ptr<GlrSyntax>& value);
MakeCreateClause& type(const vl::WString& value);
};
class MakeLoopSyntax : public vl::glr::ParsingAstBuilder<GlrLoopSyntax>
{
public:
MakeLoopSyntax& delimiter(const vl::Ptr<GlrSyntax>& value);
MakeLoopSyntax& syntax(const vl::Ptr<GlrSyntax>& value);
};
class MakeNotCondition : public vl::glr::ParsingAstBuilder<GlrNotCondition>
{
public:
MakeNotCondition& condition(const vl::Ptr<GlrCondition>& value);
};
class MakeOptionalSyntax : public vl::glr::ParsingAstBuilder<GlrOptionalSyntax>
{
public:
MakeOptionalSyntax& priority(GlrOptionalPriority value);
MakeOptionalSyntax& syntax(const vl::Ptr<GlrSyntax>& value);
};
class MakeOrCondition : public vl::glr::ParsingAstBuilder<GlrOrCondition>
{
public:
MakeOrCondition& first(const vl::Ptr<GlrCondition>& value);
MakeOrCondition& second(const vl::Ptr<GlrCondition>& value);
};
class MakePartialClause : public vl::glr::ParsingAstBuilder<GlrPartialClause>
{
public:
MakePartialClause& assignments(const vl::Ptr<GlrAssignment>& value);
MakePartialClause& syntax(const vl::Ptr<GlrSyntax>& value);
MakePartialClause& type(const vl::WString& value);
};
class MakePushConditionSyntax : public vl::glr::ParsingAstBuilder<GlrPushConditionSyntax>
{
public:
MakePushConditionSyntax& switches(const vl::Ptr<GlrSwitchItem>& value);
MakePushConditionSyntax& syntax(const vl::Ptr<GlrSyntax>& value);
};
class MakeRefCondition : public vl::glr::ParsingAstBuilder<GlrRefCondition>
{
public:
MakeRefCondition& name(const vl::WString& value);
};
class MakeRefSyntax : public vl::glr::ParsingAstBuilder<GlrRefSyntax>
{
public:
MakeRefSyntax& field(const vl::WString& value);
MakeRefSyntax& literal(const vl::WString& value);
MakeRefSyntax& refType(GlrRefType value);
};
class MakeReuseClause : public vl::glr::ParsingAstBuilder<GlrReuseClause>
{
public:
MakeReuseClause& assignments(const vl::Ptr<GlrAssignment>& value);
MakeReuseClause& syntax(const vl::Ptr<GlrSyntax>& value);
};
class MakeRule : public vl::glr::ParsingAstBuilder<GlrRule>
{
public:
MakeRule& attParser(const vl::WString& value);
MakeRule& attPublic(const vl::WString& value);
MakeRule& clauses(const vl::Ptr<GlrClause>& value);
MakeRule& name(const vl::WString& value);
MakeRule& type(const vl::WString& value);
};
class MakeSequenceSyntax : public vl::glr::ParsingAstBuilder<GlrSequenceSyntax>
{
public:
MakeSequenceSyntax& first(const vl::Ptr<GlrSyntax>& value);
MakeSequenceSyntax& second(const vl::Ptr<GlrSyntax>& value);
};
class MakeSwitchItem : public vl::glr::ParsingAstBuilder<GlrSwitchItem>
{
public:
MakeSwitchItem& name(const vl::WString& value);
MakeSwitchItem& value(GlrSwitchValue value);
};
class MakeSyntaxFile : public vl::glr::ParsingAstBuilder<GlrSyntaxFile>
{
public:
MakeSyntaxFile& rules(const vl::Ptr<GlrRule>& value);
MakeSyntaxFile& switches(const vl::Ptr<GlrSwitchItem>& value);
};
class MakeTestConditionBranch : public vl::glr::ParsingAstBuilder<GlrTestConditionBranch>
{
public:
MakeTestConditionBranch& condition(const vl::Ptr<GlrCondition>& value);
MakeTestConditionBranch& syntax(const vl::Ptr<GlrSyntax>& value);
};
class MakeTestConditionSyntax : public vl::glr::ParsingAstBuilder<GlrTestConditionSyntax>
{
public:
MakeTestConditionSyntax& branches(const vl::Ptr<GlrTestConditionBranch>& value);
};
class MakeUseSyntax : public vl::glr::ParsingAstBuilder<GlrUseSyntax>
{
public:
MakeUseSyntax& name(const vl::WString& value);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEAST_COPY.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:RuleAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEAST_AST_COPY_VISITOR
#define VCZH_PARSER2_PARSERGEN_RULEAST_AST_COPY_VISITOR
namespace vl::glr::parsergen::copy_visitor
{
/// <summary>A copy visitor, overriding all abstract methods with AST copying code.</summary>
class RuleAstVisitor
: public virtual vl::glr::CopyVisitorBase
, protected virtual GlrCondition::IVisitor
, protected virtual GlrSyntax::IVisitor
, protected virtual GlrClause::IVisitor
{
protected:
void CopyFields(GlrAlternativeSyntax* from, GlrAlternativeSyntax* to);
void CopyFields(GlrAndCondition* from, GlrAndCondition* to);
void CopyFields(GlrAssignment* from, GlrAssignment* to);
void CopyFields(GlrClause* from, GlrClause* to);
void CopyFields(GlrCondition* from, GlrCondition* to);
void CopyFields(GlrCreateClause* from, GlrCreateClause* to);
void CopyFields(GlrLoopSyntax* from, GlrLoopSyntax* to);
void CopyFields(GlrNotCondition* from, GlrNotCondition* to);
void CopyFields(GlrOptionalSyntax* from, GlrOptionalSyntax* to);
void CopyFields(GlrOrCondition* from, GlrOrCondition* to);
void CopyFields(GlrPartialClause* from, GlrPartialClause* to);
void CopyFields(GlrPushConditionSyntax* from, GlrPushConditionSyntax* to);
void CopyFields(GlrRefCondition* from, GlrRefCondition* to);
void CopyFields(GlrRefSyntax* from, GlrRefSyntax* to);
void CopyFields(GlrReuseClause* from, GlrReuseClause* to);
void CopyFields(GlrRule* from, GlrRule* to);
void CopyFields(GlrSequenceSyntax* from, GlrSequenceSyntax* to);
void CopyFields(GlrSwitchItem* from, GlrSwitchItem* to);
void CopyFields(GlrSyntax* from, GlrSyntax* to);
void CopyFields(GlrSyntaxFile* from, GlrSyntaxFile* to);
void CopyFields(GlrTestConditionBranch* from, GlrTestConditionBranch* to);
void CopyFields(GlrTestConditionSyntax* from, GlrTestConditionSyntax* to);
void CopyFields(GlrUseSyntax* from, GlrUseSyntax* to);
protected:
virtual void Visit(GlrSwitchItem* node);
virtual void Visit(GlrTestConditionBranch* node);
virtual void Visit(GlrAssignment* node);
virtual void Visit(GlrRule* node);
virtual void Visit(GlrSyntaxFile* node);
void Visit(GlrRefCondition* node) override;
void Visit(GlrNotCondition* node) override;
void Visit(GlrAndCondition* node) override;
void Visit(GlrOrCondition* node) override;
void Visit(GlrRefSyntax* node) override;
void Visit(GlrUseSyntax* node) override;
void Visit(GlrLoopSyntax* node) override;
void Visit(GlrOptionalSyntax* node) override;
void Visit(GlrSequenceSyntax* node) override;
void Visit(GlrAlternativeSyntax* node) override;
void Visit(GlrPushConditionSyntax* node) override;
void Visit(GlrTestConditionSyntax* node) override;
void Visit(GlrCreateClause* node) override;
void Visit(GlrPartialClause* node) override;
void Visit(GlrReuseClause* node) override;
public:
virtual vl::Ptr<GlrCondition> CopyNode(GlrCondition* node);
virtual vl::Ptr<GlrSyntax> CopyNode(GlrSyntax* node);
virtual vl::Ptr<GlrClause> CopyNode(GlrClause* node);
virtual vl::Ptr<GlrSwitchItem> CopyNode(GlrSwitchItem* node);
virtual vl::Ptr<GlrTestConditionBranch> CopyNode(GlrTestConditionBranch* node);
virtual vl::Ptr<GlrAssignment> CopyNode(GlrAssignment* node);
virtual vl::Ptr<GlrRule> CopyNode(GlrRule* node);
virtual vl::Ptr<GlrSyntaxFile> CopyNode(GlrSyntaxFile* node);
vl::Ptr<GlrAlternativeSyntax> CopyNode(GlrAlternativeSyntax* node);
vl::Ptr<GlrAndCondition> CopyNode(GlrAndCondition* node);
vl::Ptr<GlrCreateClause> CopyNode(GlrCreateClause* node);
vl::Ptr<GlrLoopSyntax> CopyNode(GlrLoopSyntax* node);
vl::Ptr<GlrNotCondition> CopyNode(GlrNotCondition* node);
vl::Ptr<GlrOptionalSyntax> CopyNode(GlrOptionalSyntax* node);
vl::Ptr<GlrOrCondition> CopyNode(GlrOrCondition* node);
vl::Ptr<GlrPartialClause> CopyNode(GlrPartialClause* node);
vl::Ptr<GlrPushConditionSyntax> CopyNode(GlrPushConditionSyntax* node);
vl::Ptr<GlrRefCondition> CopyNode(GlrRefCondition* node);
vl::Ptr<GlrRefSyntax> CopyNode(GlrRefSyntax* node);
vl::Ptr<GlrReuseClause> CopyNode(GlrReuseClause* node);
vl::Ptr<GlrSequenceSyntax> CopyNode(GlrSequenceSyntax* node);
vl::Ptr<GlrTestConditionSyntax> CopyNode(GlrTestConditionSyntax* node);
vl::Ptr<GlrUseSyntax> CopyNode(GlrUseSyntax* node);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEAST_EMPTY.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:RuleAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEAST_AST_EMPTY_VISITOR
#define VCZH_PARSER2_PARSERGEN_RULEAST_AST_EMPTY_VISITOR
namespace vl::glr::parsergen::empty_visitor
{
/// <summary>An empty visitor, overriding all abstract methods with empty implementations.</summary>
class ConditionVisitor : public vl::Object, public GlrCondition::IVisitor
{
protected:
// Dispatch (virtual) --------------------------------
public:
// Visitor Members -----------------------------------
void Visit(GlrRefCondition* node) override;
void Visit(GlrNotCondition* node) override;
void Visit(GlrAndCondition* node) override;
void Visit(GlrOrCondition* node) override;
};
/// <summary>An empty visitor, overriding all abstract methods with empty implementations.</summary>
class SyntaxVisitor : public vl::Object, public GlrSyntax::IVisitor
{
protected:
// Dispatch (virtual) --------------------------------
public:
// Visitor Members -----------------------------------
void Visit(GlrRefSyntax* node) override;
void Visit(GlrUseSyntax* node) override;
void Visit(GlrLoopSyntax* node) override;
void Visit(GlrOptionalSyntax* node) override;
void Visit(GlrSequenceSyntax* node) override;
void Visit(GlrAlternativeSyntax* node) override;
void Visit(GlrPushConditionSyntax* node) override;
void Visit(GlrTestConditionSyntax* node) override;
};
/// <summary>An empty visitor, overriding all abstract methods with empty implementations.</summary>
class ClauseVisitor : public vl::Object, public GlrClause::IVisitor
{
protected:
// Dispatch (virtual) --------------------------------
public:
// Visitor Members -----------------------------------
void Visit(GlrCreateClause* node) override;
void Visit(GlrPartialClause* node) override;
void Visit(GlrReuseClause* node) override;
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEAST_JSON.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:RuleAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEAST_AST_JSON_VISITOR
#define VCZH_PARSER2_PARSERGEN_RULEAST_AST_JSON_VISITOR
namespace vl::glr::parsergen::json_visitor
{
/// <summary>A JSON visitor, overriding all abstract methods with AST to JSON serialization code.</summary>
class RuleAstVisitor
: public vl::glr::JsonVisitorBase
, protected virtual GlrCondition::IVisitor
, protected virtual GlrSyntax::IVisitor
, protected virtual GlrClause::IVisitor
{
protected:
virtual void PrintFields(GlrAlternativeSyntax* node);
virtual void PrintFields(GlrAndCondition* node);
virtual void PrintFields(GlrAssignment* node);
virtual void PrintFields(GlrClause* node);
virtual void PrintFields(GlrCondition* node);
virtual void PrintFields(GlrCreateClause* node);
virtual void PrintFields(GlrLoopSyntax* node);
virtual void PrintFields(GlrNotCondition* node);
virtual void PrintFields(GlrOptionalSyntax* node);
virtual void PrintFields(GlrOrCondition* node);
virtual void PrintFields(GlrPartialClause* node);
virtual void PrintFields(GlrPushConditionSyntax* node);
virtual void PrintFields(GlrRefCondition* node);
virtual void PrintFields(GlrRefSyntax* node);
virtual void PrintFields(GlrReuseClause* node);
virtual void PrintFields(GlrRule* node);
virtual void PrintFields(GlrSequenceSyntax* node);
virtual void PrintFields(GlrSwitchItem* node);
virtual void PrintFields(GlrSyntax* node);
virtual void PrintFields(GlrSyntaxFile* node);
virtual void PrintFields(GlrTestConditionBranch* node);
virtual void PrintFields(GlrTestConditionSyntax* node);
virtual void PrintFields(GlrUseSyntax* node);
protected:
void Visit(GlrRefCondition* node) override;
void Visit(GlrNotCondition* node) override;
void Visit(GlrAndCondition* node) override;
void Visit(GlrOrCondition* node) override;
void Visit(GlrRefSyntax* node) override;
void Visit(GlrUseSyntax* node) override;
void Visit(GlrLoopSyntax* node) override;
void Visit(GlrOptionalSyntax* node) override;
void Visit(GlrSequenceSyntax* node) override;
void Visit(GlrAlternativeSyntax* node) override;
void Visit(GlrPushConditionSyntax* node) override;
void Visit(GlrTestConditionSyntax* node) override;
void Visit(GlrCreateClause* node) override;
void Visit(GlrPartialClause* node) override;
void Visit(GlrReuseClause* node) override;
public:
RuleAstVisitor(vl::stream::StreamWriter& _writer);
void Print(GlrCondition* node);
void Print(GlrSyntax* node);
void Print(GlrClause* node);
void Print(GlrSwitchItem* node);
void Print(GlrTestConditionBranch* node);
void Print(GlrAssignment* node);
void Print(GlrRule* node);
void Print(GlrSyntaxFile* node);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEAST_TRAVERSE.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:RuleAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEAST_AST_TRAVERSE_VISITOR
#define VCZH_PARSER2_PARSERGEN_RULEAST_AST_TRAVERSE_VISITOR
namespace vl::glr::parsergen::traverse_visitor
{
/// <summary>A traverse visitor, overriding all abstract methods with AST visiting code.</summary>
class RuleAstVisitor
: public vl::Object
, protected virtual GlrCondition::IVisitor
, protected virtual GlrSyntax::IVisitor
, protected virtual GlrClause::IVisitor
{
protected:
virtual void Traverse(vl::glr::ParsingToken& token);
virtual void Traverse(vl::glr::ParsingAstBase* node);
virtual void Traverse(GlrAlternativeSyntax* node);
virtual void Traverse(GlrAndCondition* node);
virtual void Traverse(GlrAssignment* node);
virtual void Traverse(GlrClause* node);
virtual void Traverse(GlrCondition* node);
virtual void Traverse(GlrCreateClause* node);
virtual void Traverse(GlrLoopSyntax* node);
virtual void Traverse(GlrNotCondition* node);
virtual void Traverse(GlrOptionalSyntax* node);
virtual void Traverse(GlrOrCondition* node);
virtual void Traverse(GlrPartialClause* node);
virtual void Traverse(GlrPushConditionSyntax* node);
virtual void Traverse(GlrRefCondition* node);
virtual void Traverse(GlrRefSyntax* node);
virtual void Traverse(GlrReuseClause* node);
virtual void Traverse(GlrRule* node);
virtual void Traverse(GlrSequenceSyntax* node);
virtual void Traverse(GlrSwitchItem* node);
virtual void Traverse(GlrSyntax* node);
virtual void Traverse(GlrSyntaxFile* node);
virtual void Traverse(GlrTestConditionBranch* node);
virtual void Traverse(GlrTestConditionSyntax* node);
virtual void Traverse(GlrUseSyntax* node);
protected:
virtual void Finishing(vl::glr::ParsingAstBase* node);
virtual void Finishing(GlrAlternativeSyntax* node);
virtual void Finishing(GlrAndCondition* node);
virtual void Finishing(GlrAssignment* node);
virtual void Finishing(GlrClause* node);
virtual void Finishing(GlrCondition* node);
virtual void Finishing(GlrCreateClause* node);
virtual void Finishing(GlrLoopSyntax* node);
virtual void Finishing(GlrNotCondition* node);
virtual void Finishing(GlrOptionalSyntax* node);
virtual void Finishing(GlrOrCondition* node);
virtual void Finishing(GlrPartialClause* node);
virtual void Finishing(GlrPushConditionSyntax* node);
virtual void Finishing(GlrRefCondition* node);
virtual void Finishing(GlrRefSyntax* node);
virtual void Finishing(GlrReuseClause* node);
virtual void Finishing(GlrRule* node);
virtual void Finishing(GlrSequenceSyntax* node);
virtual void Finishing(GlrSwitchItem* node);
virtual void Finishing(GlrSyntax* node);
virtual void Finishing(GlrSyntaxFile* node);
virtual void Finishing(GlrTestConditionBranch* node);
virtual void Finishing(GlrTestConditionSyntax* node);
virtual void Finishing(GlrUseSyntax* node);
protected:
void Visit(GlrRefCondition* node) override;
void Visit(GlrNotCondition* node) override;
void Visit(GlrAndCondition* node) override;
void Visit(GlrOrCondition* node) override;
void Visit(GlrRefSyntax* node) override;
void Visit(GlrUseSyntax* node) override;
void Visit(GlrLoopSyntax* node) override;
void Visit(GlrOptionalSyntax* node) override;
void Visit(GlrSequenceSyntax* node) override;
void Visit(GlrAlternativeSyntax* node) override;
void Visit(GlrPushConditionSyntax* node) override;
void Visit(GlrTestConditionSyntax* node) override;
void Visit(GlrCreateClause* node) override;
void Visit(GlrPartialClause* node) override;
void Visit(GlrReuseClause* node) override;
public:
void InspectInto(GlrCondition* node);
void InspectInto(GlrSyntax* node);
void InspectInto(GlrClause* node);
void InspectInto(GlrSwitchItem* node);
void InspectInto(GlrTestConditionBranch* node);
void InspectInto(GlrAssignment* node);
void InspectInto(GlrRule* node);
void InspectInto(GlrSyntaxFile* node);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEAST.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:TypeAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEAST_AST
#define VCZH_PARSER2_PARSERGEN_TYPEAST_AST
namespace vl::glr::parsergen
{
class GlrAstFile;
class GlrClass;
class GlrClassProp;
class GlrEnum;
class GlrEnumItem;
class GlrType;
enum class GlrPropType
{
UNDEFINED_ENUM_ITEM_VALUE = -1,
Token = 0,
Type = 1,
Array = 2,
};
class GlrType abstract : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrType>
{
public:
class IVisitor : public virtual vl::reflection::IDescriptable, vl::reflection::Description<IVisitor>
{
public:
virtual void Visit(GlrEnum* node) = 0;
virtual void Visit(GlrClass* node) = 0;
};
virtual void Accept(GlrType::IVisitor* visitor) = 0;
vl::glr::ParsingToken attPublic;
vl::glr::ParsingToken name;
};
class GlrEnumItem : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrEnumItem>
{
public:
vl::glr::ParsingToken name;
};
class GlrEnum : public GlrType, vl::reflection::Description<GlrEnum>
{
public:
vl::collections::List<vl::Ptr<GlrEnumItem>> items;
void Accept(GlrType::IVisitor* visitor) override;
};
class GlrClassProp : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrClassProp>
{
public:
vl::glr::ParsingToken name;
GlrPropType propType = GlrPropType::UNDEFINED_ENUM_ITEM_VALUE;
vl::glr::ParsingToken propTypeName;
};
class GlrClass : public GlrType, vl::reflection::Description<GlrClass>
{
public:
vl::glr::ParsingToken attAmbiguous;
vl::glr::ParsingToken baseClass;
vl::collections::List<vl::Ptr<GlrClassProp>> props;
void Accept(GlrType::IVisitor* visitor) override;
};
class GlrAstFile : public vl::glr::ParsingAstBase, vl::reflection::Description<GlrAstFile>
{
public:
vl::collections::List<vl::Ptr<GlrType>> types;
};
}
namespace vl::reflection::description
{
#ifndef VCZH_DEBUG_NO_REFLECTION
DECL_TYPE_INFO(vl::glr::parsergen::GlrType)
DECL_TYPE_INFO(vl::glr::parsergen::GlrType::IVisitor)
DECL_TYPE_INFO(vl::glr::parsergen::GlrEnumItem)
DECL_TYPE_INFO(vl::glr::parsergen::GlrEnum)
DECL_TYPE_INFO(vl::glr::parsergen::GlrPropType)
DECL_TYPE_INFO(vl::glr::parsergen::GlrClassProp)
DECL_TYPE_INFO(vl::glr::parsergen::GlrClass)
DECL_TYPE_INFO(vl::glr::parsergen::GlrAstFile)
#ifdef VCZH_DESCRIPTABLEOBJECT_WITH_METADATA
BEGIN_INTERFACE_PROXY_NOPARENT_SHAREDPTR(vl::glr::parsergen::GlrType::IVisitor)
void Visit(vl::glr::parsergen::GlrEnum* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
void Visit(vl::glr::parsergen::GlrClass* node) override
{
INVOKE_INTERFACE_PROXY(Visit, node);
}
END_INTERFACE_PROXY(vl::glr::parsergen::GlrType::IVisitor)
#endif
#endif
/// <summary>Load all reflectable AST types, only available when <b>VCZH_DEBUG_NO_REFLECTION</b> is off.</summary>
/// <returns>Returns true if this operation succeeded.</returns>
extern bool ParserGenTypeAstLoadTypes();
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEAST_BUILDER.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:TypeAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEAST_AST_BUILDER
#define VCZH_PARSER2_PARSERGEN_TYPEAST_AST_BUILDER
namespace vl::glr::parsergen::builder
{
class MakeAstFile : public vl::glr::ParsingAstBuilder<GlrAstFile>
{
public:
MakeAstFile& types(const vl::Ptr<GlrType>& value);
};
class MakeClass : public vl::glr::ParsingAstBuilder<GlrClass>
{
public:
MakeClass& attAmbiguous(const vl::WString& value);
MakeClass& baseClass(const vl::WString& value);
MakeClass& props(const vl::Ptr<GlrClassProp>& value);
MakeClass& attPublic(const vl::WString& value);
MakeClass& name(const vl::WString& value);
};
class MakeClassProp : public vl::glr::ParsingAstBuilder<GlrClassProp>
{
public:
MakeClassProp& name(const vl::WString& value);
MakeClassProp& propType(GlrPropType value);
MakeClassProp& propTypeName(const vl::WString& value);
};
class MakeEnum : public vl::glr::ParsingAstBuilder<GlrEnum>
{
public:
MakeEnum& items(const vl::Ptr<GlrEnumItem>& value);
MakeEnum& attPublic(const vl::WString& value);
MakeEnum& name(const vl::WString& value);
};
class MakeEnumItem : public vl::glr::ParsingAstBuilder<GlrEnumItem>
{
public:
MakeEnumItem& name(const vl::WString& value);
};
class MakeType : public vl::glr::ParsingAstBuilder<GlrType>
{
public:
MakeType& attPublic(const vl::WString& value);
MakeType& name(const vl::WString& value);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEAST_COPY.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:TypeAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEAST_AST_COPY_VISITOR
#define VCZH_PARSER2_PARSERGEN_TYPEAST_AST_COPY_VISITOR
namespace vl::glr::parsergen::copy_visitor
{
/// <summary>A copy visitor, overriding all abstract methods with AST copying code.</summary>
class TypeAstVisitor
: public virtual vl::glr::CopyVisitorBase
, protected virtual GlrType::IVisitor
{
protected:
void CopyFields(GlrAstFile* from, GlrAstFile* to);
void CopyFields(GlrClass* from, GlrClass* to);
void CopyFields(GlrClassProp* from, GlrClassProp* to);
void CopyFields(GlrEnum* from, GlrEnum* to);
void CopyFields(GlrEnumItem* from, GlrEnumItem* to);
void CopyFields(GlrType* from, GlrType* to);
protected:
virtual void Visit(GlrEnumItem* node);
virtual void Visit(GlrClassProp* node);
virtual void Visit(GlrAstFile* node);
void Visit(GlrEnum* node) override;
void Visit(GlrClass* node) override;
public:
virtual vl::Ptr<GlrType> CopyNode(GlrType* node);
virtual vl::Ptr<GlrEnumItem> CopyNode(GlrEnumItem* node);
virtual vl::Ptr<GlrClassProp> CopyNode(GlrClassProp* node);
virtual vl::Ptr<GlrAstFile> CopyNode(GlrAstFile* node);
vl::Ptr<GlrClass> CopyNode(GlrClass* node);
vl::Ptr<GlrEnum> CopyNode(GlrEnum* node);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEAST_EMPTY.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:TypeAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEAST_AST_EMPTY_VISITOR
#define VCZH_PARSER2_PARSERGEN_TYPEAST_AST_EMPTY_VISITOR
namespace vl::glr::parsergen::empty_visitor
{
/// <summary>An empty visitor, overriding all abstract methods with empty implementations.</summary>
class TypeVisitor : public vl::Object, public GlrType::IVisitor
{
protected:
// Dispatch (virtual) --------------------------------
public:
// Visitor Members -----------------------------------
void Visit(GlrEnum* node) override;
void Visit(GlrClass* node) override;
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEAST_JSON.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:TypeAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEAST_AST_JSON_VISITOR
#define VCZH_PARSER2_PARSERGEN_TYPEAST_AST_JSON_VISITOR
namespace vl::glr::parsergen::json_visitor
{
/// <summary>A JSON visitor, overriding all abstract methods with AST to JSON serialization code.</summary>
class TypeAstVisitor
: public vl::glr::JsonVisitorBase
, protected virtual GlrType::IVisitor
{
protected:
virtual void PrintFields(GlrAstFile* node);
virtual void PrintFields(GlrClass* node);
virtual void PrintFields(GlrClassProp* node);
virtual void PrintFields(GlrEnum* node);
virtual void PrintFields(GlrEnumItem* node);
virtual void PrintFields(GlrType* node);
protected:
void Visit(GlrEnum* node) override;
void Visit(GlrClass* node) override;
public:
TypeAstVisitor(vl::stream::StreamWriter& _writer);
void Print(GlrType* node);
void Print(GlrEnumItem* node);
void Print(GlrClassProp* node);
void Print(GlrAstFile* node);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEAST_TRAVERSE.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:TypeAst
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEAST_AST_TRAVERSE_VISITOR
#define VCZH_PARSER2_PARSERGEN_TYPEAST_AST_TRAVERSE_VISITOR
namespace vl::glr::parsergen::traverse_visitor
{
/// <summary>A traverse visitor, overriding all abstract methods with AST visiting code.</summary>
class TypeAstVisitor
: public vl::Object
, protected virtual GlrType::IVisitor
{
protected:
virtual void Traverse(vl::glr::ParsingToken& token);
virtual void Traverse(vl::glr::ParsingAstBase* node);
virtual void Traverse(GlrAstFile* node);
virtual void Traverse(GlrClass* node);
virtual void Traverse(GlrClassProp* node);
virtual void Traverse(GlrEnum* node);
virtual void Traverse(GlrEnumItem* node);
virtual void Traverse(GlrType* node);
protected:
virtual void Finishing(vl::glr::ParsingAstBase* node);
virtual void Finishing(GlrAstFile* node);
virtual void Finishing(GlrClass* node);
virtual void Finishing(GlrClassProp* node);
virtual void Finishing(GlrEnum* node);
virtual void Finishing(GlrEnumItem* node);
virtual void Finishing(GlrType* node);
protected:
void Visit(GlrEnum* node) override;
void Visit(GlrClass* node) override;
public:
void InspectInto(GlrType* node);
void InspectInto(GlrEnumItem* node);
void InspectInto(GlrClassProp* node);
void InspectInto(GlrAstFile* node);
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGEN_ASSEMBLER.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:ParserGen
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_AST_ASSEMBLER
#define VCZH_PARSER2_PARSERGEN_AST_ASSEMBLER
namespace vl::glr::parsergen
{
enum class ParserGenClasses : vl::vint32_t
{
AlternativeSyntax = 0,
AndCondition = 1,
Assignment = 2,
AstFile = 3,
Class = 4,
ClassProp = 5,
Clause = 6,
Condition = 7,
CreateClause = 8,
Enum = 9,
EnumItem = 10,
LoopSyntax = 11,
NotCondition = 12,
OptionalSyntax = 13,
OrCondition = 14,
PartialClause = 15,
PushConditionSyntax = 16,
RefCondition = 17,
RefSyntax = 18,
ReuseClause = 19,
Rule = 20,
SequenceSyntax = 21,
SwitchItem = 22,
Syntax = 23,
SyntaxFile = 24,
TestConditionBranch = 25,
TestConditionSyntax = 26,
Type = 27,
UseSyntax = 28,
};
enum class ParserGenFields : vl::vint32_t
{
AlternativeSyntax_first = 0,
AlternativeSyntax_second = 1,
AndCondition_first = 2,
AndCondition_second = 3,
Assignment_field = 4,
Assignment_type = 5,
Assignment_value = 6,
AstFile_types = 7,
Class_attAmbiguous = 8,
Class_baseClass = 9,
Class_props = 10,
ClassProp_name = 11,
ClassProp_propType = 12,
ClassProp_propTypeName = 13,
CreateClause_assignments = 14,
CreateClause_syntax = 15,
CreateClause_type = 16,
Enum_items = 17,
EnumItem_name = 18,
LoopSyntax_delimiter = 19,
LoopSyntax_syntax = 20,
NotCondition_condition = 21,
OptionalSyntax_priority = 22,
OptionalSyntax_syntax = 23,
OrCondition_first = 24,
OrCondition_second = 25,
PartialClause_assignments = 26,
PartialClause_syntax = 27,
PartialClause_type = 28,
PushConditionSyntax_switches = 29,
PushConditionSyntax_syntax = 30,
RefCondition_name = 31,
RefSyntax_field = 32,
RefSyntax_literal = 33,
RefSyntax_refType = 34,
ReuseClause_assignments = 35,
ReuseClause_syntax = 36,
Rule_attParser = 37,
Rule_attPublic = 38,
Rule_clauses = 39,
Rule_name = 40,
Rule_type = 41,
SequenceSyntax_first = 42,
SequenceSyntax_second = 43,
SwitchItem_name = 44,
SwitchItem_value = 45,
SyntaxFile_rules = 46,
SyntaxFile_switches = 47,
TestConditionBranch_condition = 48,
TestConditionBranch_syntax = 49,
TestConditionSyntax_branches = 50,
Type_attPublic = 51,
Type_name = 52,
UseSyntax_name = 53,
};
extern const wchar_t* ParserGenTypeName(ParserGenClasses type);
extern const wchar_t* ParserGenCppTypeName(ParserGenClasses type);
extern const wchar_t* ParserGenFieldName(ParserGenFields field);
extern const wchar_t* ParserGenCppFieldName(ParserGenFields field);
class ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase
{
protected:
vl::Ptr<vl::glr::ParsingAstBase> CreateAstNode(vl::vint32_t type) override;
void SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, vl::Ptr<vl::glr::ParsingAstBase> value) override;
void SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, const vl::regex::RegexToken& token, vl::vint32_t tokenIndex) override;
void SetField(vl::glr::ParsingAstBase* object, vl::vint32_t field, vl::vint32_t enumItem, bool weakAssignment) override;
vl::Ptr<vl::glr::ParsingAstBase> ResolveAmbiguity(vl::vint32_t type, vl::collections::Array<vl::Ptr<vl::glr::ParsingAstBase>>& candidates) override;
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGEN_LEXER.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:ParserGen
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_LEXER
#define VCZH_PARSER2_PARSERGEN_LEXER
namespace vl::glr::parsergen
{
enum class ParserGenTokens : vl::vint32_t
{
ATT_AMBIGUOUS = 0,
ATT_PUBLIC = 1,
ATT_PARSER = 2,
CLASS = 3,
ENUM = 4,
VAR = 5,
SWITCH = 6,
TOKEN = 7,
AS = 8,
PARTIAL = 9,
OPEN_ROUND = 10,
CLOSE_ROUND = 11,
OPEN_SQUARE = 12,
CLOSE_SQUARE = 13,
OPEN_CURLY = 14,
CLOSE_CURLY = 15,
OPEN_PUSH = 16,
OPEN_TEST = 17,
AND = 18,
OR = 19,
COMMA = 20,
COLON = 21,
SEMICOLON = 22,
INFER = 23,
ALTERNATIVE = 24,
USE = 25,
ASSIGN = 26,
WEAK_ASSIGN = 27,
POSITIVE = 28,
NEGATIVE = 29,
ID = 30,
STRING = 31,
CONDITIONAL_LITERAL = 32,
SPACE = 33,
COMMENT = 34,
};
constexpr vl::vint ParserGenTokenCount = 35;
extern bool ParserGenTokenDeleter(vl::vint token);
extern const wchar_t* ParserGenTokenId(ParserGenTokens token);
extern const wchar_t* ParserGenTokenDisplayText(ParserGenTokens token);
extern const wchar_t* ParserGenTokenRegex(ParserGenTokens token);
extern void ParserGenLexerData(vl::stream::IStream& outputStream);
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENRULEPARSER.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:ParserGen
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_RULEPARSER_SYNTAX
#define VCZH_PARSER2_PARSERGEN_RULEPARSER_SYNTAX
namespace vl::glr::parsergen
{
enum class RuleParserStates
{
Cond0 = 0,
Cond1 = 8,
Cond2 = 14,
Cond = 20,
SwitchItem = 23,
TestBranch = 28,
Syntax0 = 34,
Syntax1 = 73,
Syntax2 = 78,
Syntax = 84,
Assignment = 87,
Clause = 93,
Rule = 112,
File = 122,
};
const wchar_t* RuleParserRuleName(vl::vint index);
const wchar_t* RuleParserStateLabel(vl::vint index);
extern void ParserGenRuleParserData(vl::stream::IStream& outputStream);
class RuleParser
: public vl::glr::ParserBase<ParserGenTokens, RuleParserStates, ParserGenAstInsReceiver>
, protected vl::glr::automaton::IExecutor::ITypeCallback
{
protected:
vl::WString GetClassName(vl::vint32_t classIndex) const override;
vl::vint32_t FindCommonBaseClass(vl::vint32_t class1, vl::vint32_t class2) const override;
public:
RuleParser();
vl::Ptr<vl::glr::parsergen::GlrSyntaxFile> ParseFile(const vl::WString& input, vl::vint codeIndex = -1) const;
vl::Ptr<vl::glr::parsergen::GlrSyntaxFile> ParseFile(vl::collections::List<vl::regex::RegexToken>& tokens, vl::vint codeIndex = -1) const;
};
}
#endif
/***********************************************************************
.\PARSERGEN_GENERATED\PARSERGENTYPEPARSER.H
***********************************************************************/
/***********************************************************************
This file is generated by: Vczh Parser Generator
From parser definition:ParserGen
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_TYPEPARSER_SYNTAX
#define VCZH_PARSER2_PARSERGEN_TYPEPARSER_SYNTAX
namespace vl::glr::parsergen
{
enum class TypeParserStates
{
EnumItem = 0,
Enum = 4,
classProp = 12,
Class = 23,
Type = 34,
File = 38,
};
const wchar_t* TypeParserRuleName(vl::vint index);
const wchar_t* TypeParserStateLabel(vl::vint index);
extern void ParserGenTypeParserData(vl::stream::IStream& outputStream);
class TypeParser
: public vl::glr::ParserBase<ParserGenTokens, TypeParserStates, ParserGenAstInsReceiver>
, protected vl::glr::automaton::IExecutor::ITypeCallback
{
protected:
vl::WString GetClassName(vl::vint32_t classIndex) const override;
vl::vint32_t FindCommonBaseClass(vl::vint32_t class1, vl::vint32_t class2) const override;
public:
TypeParser();
vl::Ptr<vl::glr::parsergen::GlrAstFile> ParseFile(const vl::WString& input, vl::vint codeIndex = -1) const;
vl::Ptr<vl::glr::parsergen::GlrAstFile> ParseFile(vl::collections::List<vl::regex::RegexToken>& tokens, vl::vint codeIndex = -1) const;
};
}
#endif
/***********************************************************************
.\PARSERGEN_PRINTER\ASTTOCODE.H
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_ASTTOCODE
#define VCZH_PARSER2_PARSERGEN_ASTTOCODE
namespace vl::glr::parsergen
{
extern Ptr<GlrAstFile> TypeSymbolToAst(
const AstSymbolManager& manager,
bool createGeneratedTypes
);
extern void TypeAstToCode(
Ptr<GlrAstFile> file,
stream::TextWriter& writer
);
extern void SyntaxAstToCode(
Ptr<GlrSyntaxFile> file,
stream::TextWriter& writer
);
}
#endif
/***********************************************************************
.\SYNTAX\SYNTAXSYMBOL.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_SYNTAX_SYNTAXSYMBOL
#define VCZH_PARSER2_SYNTAX_SYNTAXSYMBOL
namespace vl
{
namespace glr
{
namespace parsergen
{
class AstSymbolManager;
class AstClassSymbol;
class StateSymbol;
class EdgeSymbol;
class RuleSymbol;
class SyntaxSymbolManager;
class CompactSyntaxBuilder;
/***********************************************************************
StateSymbol
***********************************************************************/
class StateSymbol : public Object
{
friend class EdgeSymbol;
friend class SyntaxSymbolManager;
friend class CompactSyntaxBuilder;
using EdgeList = collections::List<EdgeSymbol*>;
protected:
SyntaxSymbolManager* ownerManager;
RuleSymbol* rule;
EdgeList inEdges;
EdgeList outEdges;
StateSymbol(RuleSymbol* _rule);
public:
WString label;
bool endingState = false;
SyntaxSymbolManager* Owner() { return ownerManager; }
RuleSymbol* Rule() { return rule; }
const EdgeList& InEdges() { return inEdges; }
const EdgeList& OutEdges() { return outEdges; }
void GetOutEdgesInStableOrder(collections::List<StateSymbol*>& orderedStates, EdgeList& orderedEdges);
};
/***********************************************************************
EdgeSymbol
***********************************************************************/
enum class EdgeInputType
{
Epsilon, // No input is needed to execute this edge.
PrefixMergeRule, // Rule transition that created from accumulated transitions, it is a temporarily mark and will be converted back to Rule, during prefix-merge process
PrefixMergeDiscardedRule, // Rule transition that leads accmuulated transitions, converted to PrefixMergeDiscardedRule during prefix-merge process
CrossReferencedToken, // Token transition that created from accumulated transitions, it is a temporarily mark and will be converted back to Token, during cross-reference process
Ending, // An epsilon edge that reduces the current rule.
LeftRec, // An epsilon edge that reduces the current rule, which is the first input of one of its left recursive clause.
Token, // An token is read to execute this edge.
Rule, // A rule is reduced to execute this edge.
};
struct EdgeInput
{
EdgeInputType type = EdgeInputType::Epsilon;
// Token
vint32_t token = -1;
Nullable<WString> condition;
// Rule
automaton::ReturnRuleType ruleType = automaton::ReturnRuleType::Field;
RuleSymbol* rule = nullptr;
auto operator<=>(const EdgeInput&) const = default;
};
struct EdgeCompetition
{
vint32_t competitionId = -1;
bool highPriority = false;
auto operator<=>(const EdgeCompetition&) const = default;
};
class EdgeSymbol : public Object
{
friend class SyntaxSymbolManager;
friend class CompactSyntaxBuilder;
using InsList = collections::List<AstIns>;
using EdgeList = collections::List<EdgeSymbol*>;
using CompetitionList = collections::List<EdgeCompetition>;
protected:
SyntaxSymbolManager* ownerManager;
StateSymbol* fromState;
StateSymbol* toState;
EdgeSymbol(StateSymbol* _from, StateSymbol* _to);
public:
EdgeInput input; // Input of this edge.
CompetitionList competitions; // Competitions this edge involves in.
// (filled by BuildCompactNFA)
// If any important edge forms a cross referenced NFA edge, it becomes important too.
InsList insAfterInput; // Instructions to execute after pushing the value from a token or a reduced rule.
EdgeList returnEdges; // Edges of rule reduction.
// InsBeforeInput will be copied to a cross-referenced edge.
// When a reduction is done, only insAfterInput need to execute.
SyntaxSymbolManager* Owner() { return ownerManager; }
StateSymbol* From() { return fromState; }
StateSymbol* To() { return toState; }
};
/***********************************************************************
RuleSymbol
***********************************************************************/
class RuleSymbol : public Object
{
friend class SyntaxSymbolManager;
using StateList = collections::List<StateSymbol*>;
protected:
SyntaxSymbolManager* ownerManager;
WString name;
vint pmRuleIndex = -1;
RuleSymbol(SyntaxSymbolManager* _ownerManager, const WString& _name, vint _fileIndex);
public:
StateList startStates;
vint fileIndex = -1;
bool isPublic = false;
bool isParser = false;
bool isPartial = false;
bool assignedNonArrayField = false;
AstClassSymbol* ruleType = nullptr;
SyntaxSymbolManager* Owner() { return ownerManager; }
const WString& Name() { return name; }
};
/***********************************************************************
SyntaxSymbolManager
***********************************************************************/
enum class SyntaxPhase
{
EpsilonNFA, // An automaton that has edges of:
// Epsilon
// Token
// Rule
// Ending
CompactNFA, // An automaton that has edges of
// Token
// Rule
// Ending
// LeftRec
// with ignored but still existing edges
// PrefixMergeDiscardedRule
// Epsilon edges are eliminated by compressing multiple edges into one.
// Epsilon edges to the ending state will be compressed to an Ending edge.
// The first edge of Rule in left-recursive clauses becomes a LeftRec edge, with its fromState changed to the ending state.
// fromState and toState of non-LeftRec edges belong to the same clause.
// PrefixMergeRule transitions will be built from several Rule transitions.
// Such Rule transitions will be disconnected but still stored, and PrefixMergeRule will be renamed to Rule.
CrossReferencedNFA, // An automaton that has edges of
// Token
// Ending
// LeftRec
// with ignored but still existing edges
// Rule
// PrefixMergeDiscardedRule
// Edges of Rule are compressed to an edge that pointing towards states in other clauses.
// Multiple edges of rule are stored in returnEdges in the order of execution.
// insBeforeInput of an edge contains insBeforeInput from its returnEdges.
// returnEdges of an edge will be pushed to a stack when it is executed.
// Executing an Ending edge pops a returnEdges and execute its insAfterInput only.
// automaton::Executable is exactly the same to CrossReferencedNFA, stored a more cache friendly way.
// Rule transitions will be kept, but it is not logged, and also ignored during building automaton.
};
struct PrefixMergeCache;
struct PrefixMergeSolutionApplication
{
collections::Array<EdgeSymbol*> edgesToMerge;
collections::SortedList<RuleSymbol*> prefixRules;
};
using PrefixMergeSolutionApplicationList = collections::List<Ptr<PrefixMergeSolutionApplication>>;
struct PrefixMergeSolutionValue
{
collections::SortedList<RuleSymbol*> prefixRules;
PrefixMergeSolutionApplicationList applications;
};
using PrefixMergeSolutionKey = Tuple<RuleSymbol*, StateSymbol*>;
using PrefixMergeSolutionMap = collections::Dictionary<PrefixMergeSolutionKey, Ptr<PrefixMergeSolutionValue>>;
struct PrefixMergeApplicationItems;
class SyntaxSymbolManager : public Object
{
using StateList = collections::List<Ptr<StateSymbol>>;
using EdgeList = collections::List<Ptr<EdgeSymbol>>;
using StartEndStatePair = collections::Pair<StateSymbol*, StateSymbol*>;
protected:
MappedOwning<RuleSymbol> rules;
StateList states;
EdgeList edges;
ParserSymbolManager& global;
SyntaxPhase phase = SyntaxPhase::EpsilonNFA;
protected:
struct IncrementalChange
{
StateList createdStates;
EdgeList createdEdges;
bool reuseOps = true; // In ApplyIncrementalChange, true means to keep opStates and opEdges, false means to remove
collections::SortedList<StateSymbol*> opStates;
collections::SortedList<EdgeSymbol*> opEdges;
};
static StartEndStatePair EliminateEpsilonEdges(RuleSymbol* rule, StateList& newStates, EdgeList& newEdges);
static void BuildLeftRecEdge(EdgeSymbol* newEdge, EdgeSymbol* endingEdge, EdgeSymbol* lrecPrefixEdge);
static void EliminateLeftRecursion(RuleSymbol* rule, StateSymbol* startState, StateSymbol* endState, StateList& newStates, EdgeList& newEdges);
static void MergeEdgesWithSameInput(RuleSymbol* rule, StateSymbol* startState, StateList& newStates, EdgeList& newEdges);
static void MergeEdgesWithSameRuleUsingLeftrec(RuleSymbol* rule, StateSymbol* startState, StateList& newStates, EdgeList& newEdges);
Ptr<PrefixMergeCache> CreatePrefixMergeCache();
static void PrefixMergeCrossReference_SolveInState(
PrefixMergeCache* cache,
RuleSymbol* rule,
StateSymbol* currentState,
Ptr<PrefixMergeSolutionApplication> application);
static void PrefixMergeCrossReference_Solve(
PrefixMergeCache* cache,
bool forStartState,
RuleSymbol* rule,
StateSymbol* startState,
PrefixMergeSolutionMap& prefixMergeSolutions);
static void PrefixMergeCrossReference_Solve(PrefixMergeCache* cache, PrefixMergeSolutionMap& prefixMergeSolutions);
static EdgeSymbol* PrefixMergeCrossReference_AccumulatedEdges(
StateSymbol* fromState,
const WString& pmLabel,
const collections::List<Ptr<collections::List<EdgeSymbol*>>>& accumulatedEdgesList,
IncrementalChange& ic);
static void PrefixMergeCrossReference_Apply(
PrefixMergeCache* cache,
collections::List<EdgeSymbol*>& accumulatedEdges,
PrefixMergeApplicationItems& pmai);
static void PrefixMergeCrossReference_Apply(
PrefixMergeCache* cache,
RuleSymbol* rule,
StateSymbol* currentState,
Ptr<PrefixMergeSolutionValue> solution,
IncrementalChange& ic);
static void ApplyIncrementalChange(const IncrementalChange& ic, StateList& newStates, EdgeList& newEdges);
void BuildCompactNFAInternal();
protected:
void FixCrossReferencedRuleEdge(
StateSymbol* startState,
collections::Group<StateSymbol*,
EdgeSymbol*>& orderedEdges,
collections::List<EdgeSymbol*>& accumulatedEdges);
void BuildCrossReferencedNFAInternal();
public:
SyntaxSymbolManager(ParserSymbolManager& _global);
WString name;
vint32_t usedCompetitionIds = 0;
PrefixMergeSolutionMap prefixMergeSolutions;
RuleSymbol* CreateRule(const WString& name, vint fileIndex, bool isPublic, bool isParser, ParsingTextRange codeRange = {});
void RemoveRule(const WString& name);
StateSymbol* CreateState(RuleSymbol* rule);
EdgeSymbol* CreateEdge(StateSymbol* from, StateSymbol* to);
void BuildCompactNFA();
void BuildCrossReferencedNFA();
void BuildAutomaton(vint tokenCount, automaton::Executable& executable, automaton::Metadata& metadata);
void GetStatesInStableOrder(collections::List<StateSymbol*>& order);
WString GetStateGlobalLabel(StateSymbol* state, vint index);
const ParserSymbolManager& Global() const { return global; }
const auto& Rules() const { return rules.map; }
const auto& RuleOrder() { return rules.order; }
SyntaxPhase Phase() { return phase; }
template<typename ...TArgs>
void AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args) const
{
global.AddError(type, { ParserDefFileType::Syntax,name,codeRange }, std::forward<TArgs&&>(args)...);
}
};
extern void CreateParserGenTypeSyntax(AstSymbolManager& ast, SyntaxSymbolManager& manager);
extern void CreateParserGenRuleSyntax(AstSymbolManager& ast, SyntaxSymbolManager& manager);
}
}
}
#endif
/***********************************************************************
.\PARSERGEN\COMPILER.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_PARSERGEN_COMPILER
#define VCZH_PARSER2_PARSERGEN_COMPILER
namespace vl
{
namespace glr
{
namespace parsergen
{
namespace compile_syntax
{
template<typename TClause>
struct GenericRuleClausePath
{
RuleSymbol* ruleSymbol = nullptr;
TClause* clause = nullptr;
GenericRuleClausePath() = default;
GenericRuleClausePath(RuleSymbol* _ruleSymbol, TClause* _clause)
: ruleSymbol(_ruleSymbol), clause(_clause) {}
bool operator==(const GenericRuleClausePath& p) const
{
if (ruleSymbol != p.ruleSymbol) return false;
if (clause != p.clause) return false;
return true;
}
};
using RuleClausePath = GenericRuleClausePath<GlrClause>;
using RuleSymbolPair = collections::Pair<RuleSymbol*, RuleSymbol*>;
using GlrRuleMap = collections::Dictionary<RuleSymbol*, GlrRule*>;
using LiteralTokenMap = collections::Dictionary<GlrRefSyntax*, vint32_t>;
using RuleDependencies = collections::Group<RuleSymbol*, RuleSymbol*>;
using ClauseReuseDependencies = collections::Group<GlrReuseClause*, RuleSymbol*>;
using ClauseTypeMap = collections::Dictionary<GlrClause*, AstClassSymbol*>;
using ClauseList = collections::List<GlrClause*>;
struct VisitorContext
{
const ParserSymbolManager& global;
const AstSymbolManager& astManager;
const LexerSymbolManager& lexerManager;
const SyntaxSymbolManager& syntaxManager;
// ResolveName
GlrRuleMap astRules; // RuleSymbol -> GlrRule
LiteralTokenMap literalTokens;
RuleDependencies ruleReuseDependencies; // RuleSymbol -> !rule in that rule
ClauseReuseDependencies clauseReuseDependencies; // GlrReuseClause -> !rule in that clause
ClauseTypeMap clauseTypes; // GlrClause -> type
Ptr<regex::RegexLexer> cachedLexer;
// ValidateStructure
RuleDependencies partialRuleDependencies; // RuleSymbol -> direct referenced partial rule in that partial rule
VisitorContext(
const AstSymbolManager& _astManager,
const LexerSymbolManager& _lexerManager,
const SyntaxSymbolManager& _syntaxManager
)
: global(_syntaxManager.Global())
, astManager(_astManager)
, lexerManager(_lexerManager)
, syntaxManager(_syntaxManager)
{
}
const regex::RegexLexer& GetCachedLexer()
{
if (!cachedLexer)
{
auto tokens = From(lexerManager.TokenOrder())
.Select([&](const WString& name) { return lexerManager.Tokens()[name]->regex; });
cachedLexer = Ptr(new regex::RegexLexer(tokens));
}
return *cachedLexer.Obj();
}
};
using SwitchMap = collections::Dictionary<WString, collections::Pair<bool, GlrSwitchItem*>>;
using RuleSwitchMap = collections::Group<RuleSymbol*, WString>;
using ClauseSwitchMap = collections::Group<GlrClause*, WString>;
struct VisitorSwitchContext
{
SwitchMap switches;
ClauseSwitchMap clauseAffectedSwitches; // GlrClause -> all switches that affect how it parses
RuleSwitchMap ruleAffectedSwitches; // RuleSymbol -> all switches that affect how it parses
};
}
/***********************************************************************
Compiler
***********************************************************************/
extern WString UnescapeLiteral(const WString& literal, wchar_t quot);
extern void CompileAst(AstSymbolManager& astManager, collections::List<collections::Pair<AstDefFile*, Ptr<GlrAstFile>>>& files);
extern void CompileAst(AstSymbolManager& astManager, AstDefFile* astDefFile, Ptr<GlrAstFile> file);
extern void CompileLexer(LexerSymbolManager& lexerManager, const WString& input);
extern Ptr<GlrSyntaxFile> CompileSyntax(AstSymbolManager& astManager, LexerSymbolManager& lexerManager, SyntaxSymbolManager& syntaxManager, Ptr<CppParserGenOutput> output, collections::List<Ptr<GlrSyntaxFile>>& files);
extern Ptr<GlrSyntaxFile> CompileSyntax(AstSymbolManager& astManager, LexerSymbolManager& lexerManager, SyntaxSymbolManager& syntaxManager, Ptr<CppParserGenOutput> output, Ptr<GlrSyntaxFile> file);
}
}
}
#endif
/***********************************************************************
.\SYNTAX\SYNTAXCPPGEN.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_SYNTAX_SYNTAXCPPGEN
#define VCZH_PARSER2_SYNTAX_SYNTAXCPPGEN
namespace vl
{
namespace glr
{
namespace parsergen
{
extern Ptr<CppSyntaxGenOutput> GenerateSyntaxFileNames (SyntaxSymbolManager& manager, Ptr<CppParserGenOutput> output);
extern void WriteSyntaxHeaderFile (SyntaxSymbolManager& manager, automaton::Executable& executable, automaton::Metadata& metadata, Ptr<CppParserGenOutput> output, stream::StreamWriter& writer);
extern void WriteSyntaxCppFile (SyntaxSymbolManager& manager, automaton::Executable& executable, automaton::Metadata& metadata, Ptr<CppParserGenOutput> output, stream::StreamWriter& writer);
extern void WriteSyntaxFiles (SyntaxSymbolManager& manager, automaton::Executable& executable, automaton::Metadata& metadata, Ptr<CppParserGenOutput> output, collections::Dictionary<WString, WString>& files);
}
}
}
#endif
/***********************************************************************
.\SYNTAX\SYNTAXSYMBOLWRITER.H
***********************************************************************/
/***********************************************************************
Author: Zihan Chen (vczh)
Licensed under https://github.com/vczh-libraries/License
***********************************************************************/
#ifndef VCZH_PARSER2_SYNTAX_SYNTAXWRITER
#define VCZH_PARSER2_SYNTAX_SYNTAXWRITER
namespace vl
{
namespace glr
{
namespace parsergen
{
/***********************************************************************
AutomatonBuilder
***********************************************************************/
class AutomatonBuilder
{
public:
struct StatePair
{
StateSymbol* begin;
StateSymbol* end;
};
protected:
using StatePosMap = collections::Dictionary<StateSymbol*, vint>;
using StateBuilder = Func<StatePair()>;
using AssignmentBuilder = Func<StatePair(StatePair)>;
protected:
vint usedFieldIds = 0;
collections::List<AstIns> fieldIns;
RuleSymbol* ruleSymbol;
WString clauseDisplayText;
StatePosMap startPoses;
StatePosMap endPoses;
StateSymbol* CreateState()
{
return ruleSymbol->Owner()->CreateState(ruleSymbol);
}
EdgeSymbol* CreateEdge(StateSymbol* from, StateSymbol* to)
{
return ruleSymbol->Owner()->CreateEdge(from, to);
}
StatePair BuildRuleSyntaxInternal(RuleSymbol* rule, vint32_t field, automaton::ReturnRuleType ruleType);
public:
AutomatonBuilder(RuleSymbol* _ruleSymbol);
StatePair BuildTokenSyntax(vint32_t tokenId, const WString& displayText, Nullable<WString> condition, vint32_t field);
StatePair BuildFieldRuleSyntax(RuleSymbol* rule, vint32_t field);
StatePair BuildDiscardRuleSyntax(RuleSymbol* rule);
StatePair BuildUseSyntax(RuleSymbol* rule);
StatePair BuildLoopSyntax(const StateBuilder& loopBody, const StateBuilder& loopDelimiter, bool hasDelimiter);
StatePair BuildOptionalSyntax(bool preferTake, bool preferSkip, const StateBuilder& optionalBody);
StatePair BuildSequenceSyntax(collections::List<StateBuilder>& elements);
StatePair BuildAlternativeSyntax(collections::List<StateBuilder>& elements);
StatePair BuildClause(const StateBuilder& compileSyntax);
StatePair BuildAssignment(StatePair pair, vint32_t enumItem, vint32_t field, bool weakAssignment);
StatePair BuildCreateClause(vint32_t classId, const StateBuilder& compileSyntax);
StatePair BuildReuseClause(const StateBuilder& compileSyntax);
};
namespace syntax_writer
{
/***********************************************************************
Clause
***********************************************************************/
struct Token
{
vint32_t id;
vint32_t field;
WString display;
};
struct Rule
{
static const vint Discard = -1;
RuleSymbol* rule;
vint32_t field;
};
struct Use
{
RuleSymbol* rule;
};
template<typename T>
struct Loop
{
T body;
};
template<typename T, typename U>
struct LoopSep
{
T body;
U delimiter;
};
template<typename T>
struct Opt
{
T body;
};
template<typename T, typename U>
struct Seq
{
T first;
U second;
};
template<typename T, typename U>
struct Alt
{
T first;
U second;
};
struct WithConfig
{
vint32_t field;
vint32_t enumItem;
};
template<typename T>
struct With
{
T body;
vint32_t field;
vint32_t enumItem;
};
template<typename T>
struct Create
{
T body;
vint32_t type;
template<typename F, typename E>
Create<With<T>> with(F field, E enumItem)
{
return { { body,(vint32_t)field,(vint32_t)enumItem }, type };
}
};
template<typename T>
struct Reuse
{
T body;
template<typename F, typename E>
Reuse<With<T>> with(F field, E enumItem)
{
return { { body,(vint32_t)field,(vint32_t)enumItem } };
}
};
/***********************************************************************
Verification
***********************************************************************/
template<typename T>
struct IsClause_ { static constexpr bool Value = false; };
template<>
struct IsClause_<Token> { static constexpr bool Value = true; };
template<>
struct IsClause_<Rule> { static constexpr bool Value = true; };
template<>
struct IsClause_<Use> { static constexpr bool Value = true; };
template<typename T>
struct IsClause_<Loop<T>> { static constexpr bool Value = IsClause_<T>::Value; };
template<typename T, typename U>
struct IsClause_<LoopSep<T, U>> { static constexpr bool Value = IsClause_<T>::Value && IsClause_<U>::Value; };
template<typename T>
struct IsClause_<Opt<T>> { static constexpr bool Value = IsClause_<T>::Value; };
template<typename T, typename U>
struct IsClause_<Seq<T, U>> { static constexpr bool Value = IsClause_<T>::Value && IsClause_<U>::Value; };
template<typename T, typename U>
struct IsClause_<Alt<T, U>> { static constexpr bool Value = IsClause_<T>::Value && IsClause_<U>::Value; };
template<typename T>
struct IsClause_<With<T>> { static constexpr bool Value = IsClause_<T>::Value; };
template<typename T>
struct IsClause_<Create<T>> { static constexpr bool Value = IsClause_<T>::Value; };
template<typename T>
struct IsClause_<Reuse<T>> { static constexpr bool Value = IsClause_<T>::Value; };
template<typename T>
constexpr bool IsClause = IsClause_<T>::Value;
/***********************************************************************
Operators
***********************************************************************/
template<typename T>
inline Token tok(T id, const WString& display)
{
return { (vint32_t)id,-1,display };
}
template<typename T, typename F>
inline Token tok(T id, const WString& display, F field = -1)
{
return { (vint32_t)id,(vint32_t)field,display };
}
inline Rule drule(RuleSymbol* r)
{
CHECK_ERROR(!r->isPartial, L"vl::glr::parsergen::syntax_writer::drule(RuleSymbol*)#Rule should not be a partial rule.");
return { r,Rule::Discard };
}
template<typename F>
inline Rule rule(RuleSymbol* r, F field)
{
CHECK_ERROR(!r->isPartial, L"vl::glr::parsergen::syntax_writer::rule(RuleSymbol*, F)#Rule should not be a partial rule.");
return { r,(vint32_t)field };
}
inline Use use(RuleSymbol* r)
{
CHECK_ERROR(!r->isPartial, L"vl::glr::parsergen::syntax_writer::use(RuleSymbol*)#Rule should not be a partial rule.");
return { r };
}
template<typename C>
inline std::enable_if_t<IsClause<C>, Loop<C>> loop(const C& clause)
{
return { clause };
}
template<typename C1, typename C2>
inline std::enable_if_t<IsClause<C1> && IsClause<C2>, LoopSep<C1, C2>> loop(const C1& c1, const C2& c2)
{
return { c1,c2 };
}
template<typename C>
inline std::enable_if_t<IsClause<C>, Opt<C>> opt(const C& clause)
{
return { clause };
}
template<typename C1, typename C2>
inline std::enable_if_t<IsClause<C1> && IsClause<C2>, Seq<C1, C2>> operator+(const C1& c1, const C2& c2)
{
return { c1,c2 };
}
template<typename C1, typename C2>
inline std::enable_if_t<IsClause<C1>&& IsClause<C2>, Alt<C1, C2>> operator|(const C1& c1, const C2& c2)
{
return { c1,c2 };
}
template<typename F, typename E>
inline WithConfig with(F field, E enumItem)
{
return { (vint32_t)field,(vint32_t)enumItem };
}
template<typename C1>
inline std::enable_if_t<IsClause<C1>, With<C1>> operator&&(const C1& c1, const WithConfig& with)
{
return { c1,with.field,with.enumItem };
}
template<typename C, typename T>
inline std::enable_if_t<IsClause<C>, Create<C>> create(const C& clause, T type)
{
return { clause,(vint32_t)type };
}
template<typename C>
inline std::enable_if_t<IsClause<C>, Reuse<C>> reuse(const C& clause)
{
return { clause };
}
/***********************************************************************
Builder
***********************************************************************/
struct Clause
{
using StatePair = AutomatonBuilder::StatePair;
private:
AutomatonBuilder builder;
StatePair Build(const Token& clause)
{
return builder.BuildTokenSyntax(clause.id, clause.display, {}, clause.field);
}
StatePair Build(const Rule& clause)
{
if (clause.field == Rule::Discard)
{
return builder.BuildDiscardRuleSyntax(clause.rule);
}
else
{
return builder.BuildFieldRuleSyntax(clause.rule, clause.field);
}
}
StatePair Build(const Use& clause)
{
return builder.BuildUseSyntax(clause.rule);
}
template<typename C>
StatePair Build(const Loop<C>& clause)
{
return builder.BuildLoopSyntax(
[this, &clause]() { return Build(clause.body); },
{},
false
);
}
template<typename C1, typename C2>
StatePair Build(const LoopSep<C1, C2>& clause)
{
return builder.BuildLoopSyntax(
[this, &clause]() { return Build(clause.body); },
[this, &clause]() { return Build(clause.delimiter); },
true
);
}
template<typename C>
StatePair Build(const Opt<C>& clause)
{
return builder.BuildOptionalSyntax(
false,
false,
[this, &clause]() { return Build(clause.body); }
);
}
template<typename C>
void CollectSeq(const C& clause, collections::List<Func<StatePair()>>& elements)
{
elements.Add([this, &clause] { return Build(clause); });
}
template<typename C1, typename C2>
void CollectSeq(const Seq<C1, C2>& clause, collections::List<Func<StatePair()>>& elements)
{
CollectSeq(clause.first, elements);
CollectSeq(clause.second, elements);
}
template<typename C1, typename C2>
StatePair Build(const Seq<C1, C2>& clause)
{
collections::List<Func<StatePair()>> elements;
CollectSeq(clause, elements);
return builder.BuildSequenceSyntax(elements);
}
template<typename C>
void CollectAlt(const C& clause, collections::List<Func<StatePair()>>& elements)
{
elements.Add([this, &clause] { return Build(clause); });
}
template<typename C1, typename C2>
void CollectAlt(const Alt<C1, C2>& clause, collections::List<Func<StatePair()>>& elements)
{
CollectAlt(clause.first, elements);
CollectAlt(clause.second, elements);
}
template<typename C1, typename C2>
StatePair Build(const Alt<C1, C2>& clause)
{
collections::List<Func<StatePair()>> elements;
CollectAlt(clause, elements);
return builder.BuildAlternativeSyntax(elements);
}
template<typename C>
StatePair Build(const With<C>& clause)
{
return builder.BuildAssignment(Build(clause.body), clause.enumItem, clause.field, false);
}
template<typename C>
StatePair Build(const Create<C>& clause)
{
return builder.BuildCreateClause(
clause.type,
[this, &clause]() { return Build(clause.body); }
);
}
template<typename C>
StatePair Build(const Reuse<C>& clause)
{
return builder.BuildReuseClause(
[this, &clause]() { return Build(clause.body); }
);
}
template<typename C>
void Assign(const C& clause)
{
builder.BuildClause(
[this, &clause]() { return Build(clause); }
);
}
public:
Clause(RuleSymbol* _ruleSymbol) : builder(_ruleSymbol) {}
template<typename C>
Clause& operator=(const Create<C>& clause)
{
Assign(clause);
return *this;
}
template<typename C>
Clause& operator=(const Reuse<C>& clause)
{
Assign(clause);
return *this;
}
template<typename C>
Clause& operator=(const C& clause)
{
return operator=(reuse(clause));
}
};
}
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink