ConceptProd/ConceptCore
1
0
Fork 0
mirror of https://github.com/IRBorisov/ConceptCore.git synced 2025-06-26 09:10:37 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactoring: sync names in Parser and AstVisitor

Browse Source
This commit is contained in:
IRBorisov 2024-05-10 02:23:57 +03:00
parent fd92ef6797
commit f991763bb7
15 changed files with 590 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ccl/rslang/header/GeneratorImplAST.h
View File

@ -18,19 +18,20 @@ public:
private: private:
bool VisitDefault(Cursor iter); bool VisitDefault(Cursor iter);
bool ViGlobalDefinition(Cursor iter); bool ViGlobalDeclaration(Cursor iter);
bool ViFunctionDefinition(Cursor iter); bool ViFunctionDefinition(Cursor iter);
bool ViFunctionCall(Cursor iter); bool ViFunctionCall(Cursor iter);
// bool ViGlobal(Cursor iter); // bool ViGlobal(Cursor iter);
// bool ViRadical(Cursor iter);
// bool ViLocal(Cursor iter); // bool ViLocal(Cursor iter);
// bool ViInteger(Cursor /*iter*/); // bool ViInteger(Cursor /*iter*/);
// bool ViIntegerSet(Cursor iter) // bool ViIntegerSet(Cursor iter)
// bool ViEmptySet(Cursor iter); // bool ViEmptySet(Cursor iter);
bool ViLocalBind(Cursor iter); bool ViTupleDeclaration(Cursor iter);
bool ViLocalEnum(Cursor iter); bool ViEnumDeclaration(Cursor iter);
bool ViArgumentsEnum(Cursor iter); bool ViArgumentsEnum(Cursor iter);
bool ViArgument(Cursor iter); bool ViArgument(Cursor iter);
@ -41,8 +42,8 @@ private:
bool ViNegation(Cursor iter); bool ViNegation(Cursor iter);
bool ViLogicBinary(Cursor iter); bool ViLogicBinary(Cursor iter);
bool ViEquals(Cursor iter); bool ViEquals(Cursor iter);
bool ViOrdering(Cursor iter) { return ViEquals(iter); } bool ViIntegerPredicate(Cursor iter) { return ViEquals(iter); }
bool ViTypedPredicate(Cursor iter) { return ViEquals(iter); } bool ViSetexprPredicate(Cursor iter) { return ViEquals(iter); }
bool ViDeclarative(Cursor iter); bool ViDeclarative(Cursor iter);
bool ViImperative(Cursor iter); bool ViImperative(Cursor iter);
@ -55,11 +56,11 @@ private:
bool ViBoolean(Cursor iter); bool ViBoolean(Cursor iter);
bool ViTuple(Cursor iter); bool ViTuple(Cursor iter);
bool ViSetEnum(Cursor iter); bool ViEnumeration(Cursor iter);
bool ViBool(Cursor iter) { return ViCard(iter); } bool ViBool(Cursor iter) { return ViCard(iter); }
bool ViDebool(Cursor iter) { return ViCard(iter); } bool ViDebool(Cursor iter) { return ViCard(iter); }
bool ViTypedBinary(Cursor iter) { return ViArithmetic(iter); } bool ViSetexprBinary(Cursor iter) { return ViArithmetic(iter); }
bool ViProjectSet(Cursor iter) { return ViCard(iter); } bool ViProjectSet(Cursor iter) { return ViCard(iter); }
bool ViProjectTuple(Cursor iter) { return ViCard(iter); } bool ViProjectTuple(Cursor iter) { return ViCard(iter); }
bool ViFilter(Cursor iter); bool ViFilter(Cursor iter);

3
ccl/rslang/header/NameCollector.h
View File

@ -22,9 +22,10 @@ public:
protected: protected:
bool VisitDefault(Cursor iter) { return MergeChildren(iter); } bool VisitDefault(Cursor iter) { return MergeChildren(iter); }
bool ViGlobalDefinition(Cursor iter); bool ViGlobalDeclaration(Cursor iter);
bool ViGlobal(Cursor iter); bool ViGlobal(Cursor iter);
// bool ViRadical(Cursor iter);
bool ViLocal(Cursor iter); bool ViLocal(Cursor iter);
bool ViQuantifier(Cursor iter); bool ViQuantifier(Cursor iter);

83
ccl/rslang/header/RSParserImpl.h
View File

@ -446,44 +446,43 @@ namespace ccl { namespace rslang { namespace detail {
S_YYACCEPT = 61, // $accept S_YYACCEPT = 61, // $accept
S_expression = 62, // expression S_expression = 62, // expression
S_global_declaration = 63, // global_declaration S_global_declaration = 63, // global_declaration
S_function_name = 64, // function_name S_logic_or_setexpr = 64, // logic_or_setexpr
S_logic_or_setexpr = 65, // logic_or_setexpr S_function_definition = 65, // function_definition
S_function_decl = 66, // function_decl S_arguments = 66, // arguments
S_arguments = 67, // arguments S_declaration = 67, // declaration
S_declaration = 68, // declaration S_variable = 68, // variable
S_variable = 69, // variable S_var_enum = 69, // var_enum
S_var_enum = 70, // var_enum S_var_all = 70, // var_all
S_var_all = 71, // var_all S_logic = 71, // logic
S_logic = 72, // logic S_logic_all = 72, // logic_all
S_logic_all = 73, // logic_all S_logic_par = 73, // logic_par
S_logic_par = 74, // logic_par S_logic_predicates = 74, // logic_predicates
S_logic_predicates = 75, // logic_predicates S_binary_predicate = 75, // binary_predicate
S_binary_predicate = 76, // binary_predicate S_logic_unary = 76, // logic_unary
S_logic_unary = 77, // logic_unary S_logic_no_binary = 77, // logic_no_binary
S_logic_no_binary = 78, // logic_no_binary S_quantifier = 78, // quantifier
S_quantifier = 79, // quantifier S_quant_var = 79, // quant_var
S_quant_var = 80, // quant_var S_quant_var_enum = 80, // quant_var_enum
S_quant_var_enum = 81, // quant_var_enum S_logic_binary = 81, // logic_binary
S_logic_binary = 82, // logic_binary S_setexpr = 82, // setexpr
S_setexpr = 83, // setexpr S_text_function = 83, // text_function
S_operation_name = 84, // operation_name S_setexpr_enum = 84, // setexpr_enum
S_setexpr_enum = 85, // setexpr_enum S_setexpr_enum_min2 = 85, // setexpr_enum_min2
S_setexpr_enum_min2 = 86, // setexpr_enum_min2 S_literal = 86, // literal
S_literal = 87, // literal S_identifier = 87, // identifier
S_identifier = 88, // identifier S_setexpr_binary = 88, // setexpr_binary
S_setexpr_binary = 89, // setexpr_binary S_setexpr_generators = 89, // setexpr_generators
S_setexpr_generators = 90, // setexpr_generators S_enumeration = 90, // enumeration
S_enumeration = 91, // enumeration S_tuple = 91, // tuple
S_tuple = 92, // tuple S_boolean = 92, // boolean
S_boolean = 93, // boolean S_filter_expression = 93, // filter_expression
S_filter_expression = 94, // filter_expression S_declarative = 94, // declarative
S_declarative = 95, // declarative S_recursion = 95, // recursion
S_recursion = 96, // recursion S_imperative = 96, // imperative
S_imperative = 97, // imperative S_imp_blocks = 97, // imp_blocks
S_imp_blocks = 98, // imp_blocks S_imp_block = 98, // imp_block
S_imp_block = 99, // imp_block S_RPE = 99, // RPE
S_RPE = 100, // RPE S_RCE = 100 // RCE
S_RCE = 101 // RCE
}; };
}; };
@ -981,9 +980,9 @@ namespace ccl { namespace rslang { namespace detail {
/// Constants. /// Constants.
enum enum
{ {
yylast_ = 589, ///< Last index in yytable_. yylast_ = 640, ///< Last index in yytable_.
yynnts_ = 41, ///< Number of nonterminal symbols. yynnts_ = 40, ///< Number of nonterminal symbols.
yyfinal_ = 85 ///< Termination state number. yyfinal_ = 87 ///< Termination state number.
}; };
@ -995,7 +994,7 @@ namespace ccl { namespace rslang { namespace detail {
#line 15 "RSParserImpl.y" #line 15 "RSParserImpl.y"
} } } // ccl::rslang::detail } } } // ccl::rslang::detail
#line 999 "../header/RSParserImpl.h" #line 998 "../header/RSParserImpl.h"

15
ccl/rslang/include/ccl/rslang/ASTInterpreter.h
View File

@ -50,19 +50,20 @@ public:
protected: protected:
bool VisitDefault(Cursor /*iter*/) noexcept { return false; } // NOLINT(readability-convert-member-functions-to-static) bool VisitDefault(Cursor /*iter*/) noexcept { return false; } // NOLINT(readability-convert-member-functions-to-static)
bool ViGlobalDefinition(Cursor iter); bool ViGlobalDeclaration(Cursor iter);
// bool ViFunctionDefinition(Cursor iter) // bool ViFunctionDefinition(Cursor iter)
// bool ViFunctionCall(Cursor iter); // bool ViFunctionCall(Cursor iter);
bool ViGlobal(Cursor iter) { return ViLocal(iter); } bool ViGlobal(Cursor iter) { return ViLocal(iter); }
// bool ViRadical(Cursor iter);
bool ViLocal(Cursor iter); bool ViLocal(Cursor iter);
bool ViInteger(Cursor /*iter*/); bool ViInteger(Cursor /*iter*/);
bool ViIntegerSet(Cursor /*iter*/); bool ViIntegerSet(Cursor /*iter*/);
bool ViEmptySet(Cursor iter); bool ViEmptySet(Cursor iter);
//bool ViLocalBind(Cursor iter); //bool ViTupleDeclaration(Cursor iter);
//bool ViLocalEnum(Cursor iter); //bool ViEnumDeclaration(Cursor iter);
//bool ViArgumentsEnum(Cursor iter); //bool ViArgumentsEnum(Cursor iter);
//bool ViArgument(Cursor iter); //bool ViArgument(Cursor iter);
@ -73,8 +74,8 @@ protected:
bool ViNegation(Cursor iter); bool ViNegation(Cursor iter);
bool ViLogicBinary(Cursor iter); bool ViLogicBinary(Cursor iter);
bool ViEquals(Cursor iter); bool ViEquals(Cursor iter);
bool ViOrdering(Cursor iter); bool ViIntegerPredicate(Cursor iter);
bool ViTypedPredicate(Cursor iter) { return ViTypedBinary(iter); } bool ViSetexprPredicate(Cursor iter) { return ViSetexprBinary(iter); }
bool ViDecart(Cursor iter); bool ViDecart(Cursor iter);
bool ViBoolean(Cursor iter); bool ViBoolean(Cursor iter);
@ -87,11 +88,11 @@ protected:
bool ViRecursion(Cursor iter); bool ViRecursion(Cursor iter);
bool ViTuple(Cursor iter); bool ViTuple(Cursor iter);
bool ViSetEnum(Cursor iter); bool ViEnumeration(Cursor iter);
bool ViBool(Cursor iter); bool ViBool(Cursor iter);
bool ViDebool(Cursor iter); bool ViDebool(Cursor iter);
bool ViTypedBinary(Cursor iter); bool ViSetexprBinary(Cursor iter);
bool ViProjectSet(Cursor iter); bool ViProjectSet(Cursor iter);
bool ViProjectTuple(Cursor iter); bool ViProjectTuple(Cursor iter);
bool ViFilter(Cursor iter); bool ViFilter(Cursor iter);

75
ccl/rslang/include/ccl/rslang/SyntaxTree.h
View File

@ -143,15 +143,22 @@ public:
case TokenID::PUNC_DEFINE: case TokenID::PUNC_DEFINE:
case TokenID::PUNC_STRUCT: case TokenID::PUNC_STRUCT:
assert(ChildrenCount() != 0); assert(ChildrenCount() != 0);
return visitor.ViGlobalDefinition(*this); return visitor.ViGlobalDeclaration(*this);
case TokenID::ID_GLOBAL: case TokenID::ID_GLOBAL:
case TokenID::ID_FUNCTION: case TokenID::ID_FUNCTION:
case TokenID::ID_PREDICATE: case TokenID::ID_PREDICATE:
case TokenID::ID_RADICAL:
assert(ChildrenCount() == 0); assert(ChildrenCount() == 0);
return visitor.ViGlobal(*this); return visitor.ViGlobal(*this);
case TokenID::ID_LOCAL:
assert(ChildrenCount() == 0);
return visitor.ViLocal(*this);
case TokenID::ID_RADICAL:
assert(ChildrenCount() == 0);
return visitor.ViRadical(*this);
case TokenID::NT_FUNC_DEFINITION: case TokenID::NT_FUNC_DEFINITION:
assert(ChildrenCount() == 2); assert(ChildrenCount() == 2);
return visitor.ViFunctionDefinition(*this); return visitor.ViFunctionDefinition(*this);
@ -159,14 +166,9 @@ public:
assert(ChildrenCount() > 1); assert(ChildrenCount() > 1);
return visitor.ViFunctionCall(*this); return visitor.ViFunctionCall(*this);
case TokenID::ID_LOCAL:
assert(ChildrenCount() == 0);
return visitor.ViLocal(*this);
case TokenID::LIT_INTSET: case TokenID::LIT_INTSET:
assert(ChildrenCount() == 0); assert(ChildrenCount() == 0);
return visitor.ViIntegerSet(*this); return visitor.ViIntegerSet(*this);
case TokenID::LIT_INTEGER: case TokenID::LIT_INTEGER:
assert(ChildrenCount() == 0); assert(ChildrenCount() == 0);
return visitor.ViInteger(*this); return visitor.ViInteger(*this);
@ -176,9 +178,9 @@ public:
case TokenID::NT_TUPLE_DECL: case TokenID::NT_TUPLE_DECL:
assert(ChildrenCount() > 1); assert(ChildrenCount() > 1);
return visitor.ViLocalBind(*this); return visitor.ViTupleDeclaration(*this);
case TokenID::NT_ENUM_DECL: case TokenID::NT_ENUM_DECL:
return visitor.ViLocalEnum(*this); return visitor.ViEnumDeclaration(*this);
case TokenID::NT_ARGUMENTS: case TokenID::NT_ARGUMENTS:
assert(ChildrenCount() > 0); assert(ChildrenCount() > 0);
return visitor.ViArgumentsEnum(*this); return visitor.ViArgumentsEnum(*this);
@ -186,22 +188,6 @@ public:
assert(ChildrenCount() == 2); assert(ChildrenCount() == 2);
return visitor.ViArgument(*this); return visitor.ViArgument(*this);
case TokenID::NT_DECLARATIVE_EXPR:
assert(ChildrenCount() == 3);
return visitor.ViDeclarative(*this);
case TokenID::NT_IMPERATIVE_EXPR:
assert(ChildrenCount() > 1);
return visitor.ViImperative(*this);
case TokenID::NT_IMP_DECLARE:
assert(ChildrenCount() == 2);
return visitor.ViImpDeclare(*this);
case TokenID::NT_IMP_ASSIGN:
assert(ChildrenCount() == 2);
return visitor.ViImpAssign(*this);
case TokenID::NT_IMP_LOGIC:
assert(ChildrenCount() == 1);
return visitor.ViImpCheck(*this);
case TokenID::PLUS: case TokenID::PLUS:
case TokenID::MINUS: case TokenID::MINUS:
case TokenID::MULTIPLY: case TokenID::MULTIPLY:
@ -236,7 +222,7 @@ public:
case TokenID::GREATER_OR_EQ: case TokenID::GREATER_OR_EQ:
case TokenID::LESSER_OR_EQ: case TokenID::LESSER_OR_EQ:
assert(ChildrenCount() == 2); assert(ChildrenCount() == 2);
return visitor.ViOrdering(*this); return visitor.ViIntegerPredicate(*this);
case TokenID::IN: case TokenID::IN:
case TokenID::NOTIN: case TokenID::NOTIN:
@ -244,7 +230,23 @@ public:
case TokenID::SUBSET_OR_EQ: case TokenID::SUBSET_OR_EQ:
case TokenID::NOTSUBSET: case TokenID::NOTSUBSET:
assert(ChildrenCount() == 2); assert(ChildrenCount() == 2);
return visitor.ViTypedPredicate(*this); return visitor.ViSetexprPredicate(*this);
case TokenID::NT_DECLARATIVE_EXPR:
assert(ChildrenCount() == 3);
return visitor.ViDeclarative(*this);
case TokenID::NT_IMPERATIVE_EXPR:
assert(ChildrenCount() > 1);
return visitor.ViImperative(*this);
case TokenID::NT_IMP_DECLARE:
assert(ChildrenCount() == 2);
return visitor.ViImpDeclare(*this);
case TokenID::NT_IMP_ASSIGN:
assert(ChildrenCount() == 2);
return visitor.ViImpAssign(*this);
case TokenID::NT_IMP_LOGIC:
assert(ChildrenCount() == 1);
return visitor.ViImpCheck(*this);
case TokenID::DECART: case TokenID::DECART:
assert(ChildrenCount() > 1); assert(ChildrenCount() > 1);
@ -264,7 +266,7 @@ public:
assert(ChildrenCount() > 1); assert(ChildrenCount() > 1);
return visitor.ViTuple(*this); return visitor.ViTuple(*this);
case TokenID::NT_ENUMERATION: case TokenID::NT_ENUMERATION:
return visitor.ViSetEnum(*this); return visitor.ViEnumeration(*this);
case TokenID::BOOL: case TokenID::BOOL:
assert(ChildrenCount() == 1); assert(ChildrenCount() == 1);
return visitor.ViBool(*this); return visitor.ViBool(*this);
@ -277,7 +279,7 @@ public:
case TokenID::SET_MINUS: case TokenID::SET_MINUS:
case TokenID::SYMMINUS: case TokenID::SYMMINUS:
assert(ChildrenCount() == 2); assert(ChildrenCount() == 2);
return visitor.ViTypedBinary(*this); return visitor.ViSetexprBinary(*this);
case TokenID::BIGPR: case TokenID::BIGPR:
assert(ChildrenCount() == 1); assert(ChildrenCount() == 1);
@ -319,19 +321,20 @@ protected:
} }
private: private:
bool ViGlobalDefinition(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViGlobalDeclaration(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViFunctionDefinition(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViFunctionDefinition(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViFunctionCall(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViFunctionCall(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViGlobal(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViGlobal(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViRadical(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViLocal(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViLocal(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViInteger(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViInteger(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViIntegerSet(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViIntegerSet(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViEmptySet(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViEmptySet(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViLocalBind(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViTupleDeclaration(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViLocalEnum(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViEnumDeclaration(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViArgumentsEnum(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViArgumentsEnum(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViArgument(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViArgument(Cursor iter) { return this->BaseT().VisitDefault(iter); }
@ -342,8 +345,8 @@ private:
bool ViNegation(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViNegation(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViLogicBinary(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViLogicBinary(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViEquals(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViEquals(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViOrdering(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViIntegerPredicate(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViTypedPredicate(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViSetexprPredicate(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViDeclarative(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViDeclarative(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViImperative(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViImperative(Cursor iter) { return this->BaseT().VisitDefault(iter); }
@ -356,11 +359,11 @@ private:
bool ViBoolean(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViBoolean(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViTuple(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViTuple(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViSetEnum(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViEnumeration(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViBool(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViBool(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViDebool(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViDebool(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViTypedBinary(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViSetexprBinary(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViProjectSet(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViProjectSet(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViProjectTuple(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViProjectTuple(Cursor iter) { return this->BaseT().VisitDefault(iter); }
bool ViFilter(Cursor iter) { return this->BaseT().VisitDefault(iter); } bool ViFilter(Cursor iter) { return this->BaseT().VisitDefault(iter); }

17
ccl/rslang/include/ccl/rslang/TypeAuditor.h
View File

@ -73,19 +73,20 @@ public:
void SetExepectTypification(const bool value = true) noexcept; void SetExepectTypification(const bool value = true) noexcept;
protected: protected:
bool ViGlobalDefinition(Cursor iter); bool ViGlobalDeclaration(Cursor iter);
bool ViFunctionDefinition(Cursor iter); bool ViFunctionDefinition(Cursor iter);
bool ViFunctionCall(Cursor iter); bool ViFunctionCall(Cursor iter);
bool ViGlobal(Cursor iter); bool ViGlobal(Cursor iter);
bool ViRadical(Cursor iter);
bool ViLocal(Cursor iter); bool ViLocal(Cursor iter);
bool ViInteger(Cursor /*iter*/) { return SetCurrent(Typification::Integer()); } bool ViInteger(Cursor /*iter*/) { return SetCurrent(Typification::Integer()); }
bool ViIntegerSet(Cursor /*iter*/) { return SetCurrent(Typification::Integer().Bool()); } bool ViIntegerSet(Cursor /*iter*/) { return SetCurrent(Typification::Integer().Bool()); }
bool ViEmptySet(Cursor /*iter*/); bool ViEmptySet(Cursor /*iter*/);
bool ViLocalBind(Cursor iter); bool ViTupleDeclaration(Cursor iter);
bool ViLocalEnum(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); } bool ViEnumDeclaration(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); }
bool ViArgumentsEnum(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); } bool ViArgumentsEnum(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); }
bool ViArgument(Cursor iter); bool ViArgument(Cursor iter);
@ -96,8 +97,8 @@ protected:
bool ViNegation(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); } bool ViNegation(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); }
bool ViLogicBinary(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); } bool ViLogicBinary(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); }
bool ViEquals(Cursor iter); bool ViEquals(Cursor iter);
bool ViOrdering(Cursor iter); bool ViIntegerPredicate(Cursor iter);
bool ViTypedPredicate(Cursor iter); bool ViSetexprPredicate(Cursor iter);
bool ViDecart(Cursor iter); bool ViDecart(Cursor iter);
bool ViBoolean(Cursor iter); bool ViBoolean(Cursor iter);
@ -110,11 +111,11 @@ protected:
bool ViRecursion(Cursor iter); bool ViRecursion(Cursor iter);
bool ViTuple(Cursor iter); bool ViTuple(Cursor iter);
bool ViSetEnum(Cursor iter); bool ViEnumeration(Cursor iter);
bool ViBool(Cursor iter) { return ViSetEnum(iter); } bool ViBool(Cursor iter) { return ViEnumeration(iter); }
bool ViDebool(Cursor iter); bool ViDebool(Cursor iter);
bool ViTypedBinary(Cursor iter); bool ViSetexprBinary(Cursor iter);
bool ViProjectSet(Cursor iter); bool ViProjectSet(Cursor iter);
bool ViProjectTuple(Cursor iter); bool ViProjectTuple(Cursor iter);
bool ViFilter(Cursor iter); bool ViFilter(Cursor iter);

15
ccl/rslang/include/ccl/rslang/ValueAuditor.h
View File

@ -33,19 +33,20 @@ public:
[[nodiscard]] ValueClass VType() const noexcept { return current; } [[nodiscard]] ValueClass VType() const noexcept { return current; }
protected: protected:
bool ViGlobalDefinition(Cursor iter); bool ViGlobalDeclaration(Cursor iter);
bool ViFunctionDefinition(Cursor iter) { return VisitAllChildren(iter); } bool ViFunctionDefinition(Cursor iter) { return VisitAllChildren(iter); }
bool ViFunctionCall(Cursor iter); bool ViFunctionCall(Cursor iter);
bool ViGlobal(Cursor iter); bool ViGlobal(Cursor iter);
bool ViRadical(Cursor /*iter*/);
bool ViLocal(Cursor iter); bool ViLocal(Cursor iter);
bool ViInteger(Cursor /*iter*/) noexcept { return SetCurrent(ValueClass::value); } bool ViInteger(Cursor /*iter*/) noexcept { return SetCurrent(ValueClass::value); }
bool ViIntegerSet(Cursor /*iter*/) noexcept { return SetCurrent(ValueClass::props); } bool ViIntegerSet(Cursor /*iter*/) noexcept { return SetCurrent(ValueClass::props); }
bool ViEmptySet(Cursor /*iter*/) noexcept { return SetCurrent(ValueClass::value); } bool ViEmptySet(Cursor /*iter*/) noexcept { return SetCurrent(ValueClass::value); }
bool ViLocalBind(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); } bool ViTupleDeclaration(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); }
bool ViLocalEnum(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); } bool ViEnumDeclaration(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); }
bool ViArgumentsEnum(Cursor iter) { return VisitAllChildren(iter); } bool ViArgumentsEnum(Cursor iter) { return VisitAllChildren(iter); }
bool ViArgument(Cursor iter) { return VisitAllChildren(iter); } bool ViArgument(Cursor iter) { return VisitAllChildren(iter); }
@ -56,8 +57,8 @@ protected:
bool ViNegation(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); } bool ViNegation(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); }
bool ViLogicBinary(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); } bool ViLogicBinary(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); }
bool ViEquals(Cursor iter) { return AssertAllValues(iter); } bool ViEquals(Cursor iter) { return AssertAllValues(iter); }
bool ViOrdering(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); } bool ViIntegerPredicate(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); }
bool ViTypedPredicate(Cursor iter); bool ViSetexprPredicate(Cursor iter);
bool ViDecart(Cursor iter); bool ViDecart(Cursor iter);
bool ViBoolean(Cursor iter); bool ViBoolean(Cursor iter);
@ -70,11 +71,11 @@ protected:
bool ViRecursion(Cursor iter) { return AssertAllValues(iter); } bool ViRecursion(Cursor iter) { return AssertAllValues(iter); }
bool ViTuple(Cursor iter) { return AssertAllValues(iter); } bool ViTuple(Cursor iter) { return AssertAllValues(iter); }
bool ViSetEnum(Cursor iter) { return AssertAllValues(iter); } bool ViEnumeration(Cursor iter) { return AssertAllValues(iter); }
bool ViBool(Cursor iter) { return AssertChildIsValue(iter, 0); } bool ViBool(Cursor iter) { return AssertChildIsValue(iter, 0); }
bool ViDebool(Cursor iter) { return AssertChildIsValue(iter, 0); } bool ViDebool(Cursor iter) { return AssertChildIsValue(iter, 0); }
bool ViTypedBinary(Cursor iter); bool ViSetexprBinary(Cursor iter);
bool ViProjectSet(Cursor iter) { return AssertChildIsValue(iter, 0); } bool ViProjectSet(Cursor iter) { return AssertChildIsValue(iter, 0); }
bool ViProjectTuple(Cursor iter) { return AssertChildIsValue(iter, 0); } bool ViProjectTuple(Cursor iter) { return AssertChildIsValue(iter, 0); }
bool ViFilter(Cursor iter) { return VisitAllChildren(iter); } bool ViFilter(Cursor iter) { return VisitAllChildren(iter); }

8
ccl/rslang/src/ASTInterpreter.cpp
View File

@ -225,7 +225,7 @@ bool ASTInterpreter::SetCurrent(const ExpressionValue& value) noexcept {
return true; return true;
} }
bool ASTInterpreter::ViGlobalDefinition(Cursor iter) { bool ASTInterpreter::ViGlobalDeclaration(Cursor iter) {
return VisitChild(iter, 1); return VisitChild(iter, 1);
} }
@ -367,7 +367,7 @@ bool ASTInterpreter::ViEquals(Cursor iter) {
return SetCurrent((val1 == val2) != (iter->id == TokenID::NOTEQUAL)); return SetCurrent((val1 == val2) != (iter->id == TokenID::NOTEQUAL));
} }
bool ASTInterpreter::ViOrdering(Cursor iter) { bool ASTInterpreter::ViIntegerPredicate(Cursor iter) {
const auto val1 = EvaluateChild(iter, 0); const auto val1 = EvaluateChild(iter, 0);
if (!val1.has_value()) { if (!val1.has_value()) {
return false; return false;
@ -501,7 +501,7 @@ bool ASTInterpreter::ViTuple(Cursor iter) {
return SetCurrent(Factory::Tuple(args)); return SetCurrent(Factory::Tuple(args));
} }
bool ASTInterpreter::ViSetEnum(Cursor iter) { bool ASTInterpreter::ViEnumeration(Cursor iter) {
std::vector<StructuredData> args{}; std::vector<StructuredData> args{};
for (Index child = 0; child < iter.ChildrenCount(); ++child) { for (Index child = 0; child < iter.ChildrenCount(); ++child) {
const auto childValue = EvaluateChild(iter, child); const auto childValue = EvaluateChild(iter, child);
@ -521,7 +521,7 @@ bool ASTInterpreter::ViBool(Cursor iter) {
return SetCurrent(Factory::Singleton(std::get<StructuredData>(childValue.value()))); return SetCurrent(Factory::Singleton(std::get<StructuredData>(childValue.value())));
} }
bool ASTInterpreter::ViTypedBinary(Cursor iter) { bool ASTInterpreter::ViSetexprBinary(Cursor iter) {
const auto val1 = EvaluateChild(iter, 0); const auto val1 = EvaluateChild(iter, 0);
if (!val1.has_value()) { if (!val1.has_value()) {
return false; return false;

8
ccl/rslang/src/GeneratorImplAST.cpp
View File

@ -19,7 +19,7 @@ bool GeneratorImplAST::VisitDefault(Cursor iter) {
return true; return true;
} }
bool GeneratorImplAST::ViGlobalDefinition(Cursor iter) { bool GeneratorImplAST::ViGlobalDeclaration(Cursor iter) {
OutputChild(iter, 0); OutputChild(iter, 0);
rsText += iter->ToString(syntax); rsText += iter->ToString(syntax);
if (iter.ChildrenCount() > 1) { if (iter.ChildrenCount() > 1) {
@ -48,12 +48,12 @@ bool GeneratorImplAST::ViFunctionCall(Cursor iter) {
return true; return true;
} }
bool GeneratorImplAST::ViLocalBind(Cursor iter) { bool GeneratorImplAST::ViTupleDeclaration(Cursor iter) {
EnumChildren(iter, '(', ')', std::string(R"(, )")); EnumChildren(iter, '(', ')', std::string(R"(, )"));
return true; return true;
} }
bool GeneratorImplAST::ViLocalEnum(Cursor iter) { bool GeneratorImplAST::ViEnumDeclaration(Cursor iter) {
EnumChildren(iter, R"(, )"); EnumChildren(iter, R"(, )");
return true; return true;
} }
@ -237,7 +237,7 @@ bool GeneratorImplAST::ViTuple(Cursor iter) {
return true; return true;
} }
bool GeneratorImplAST::ViSetEnum(Cursor iter) { bool GeneratorImplAST::ViEnumeration(Cursor iter) {
EnumChildren(iter, '{', '}', R"(, )"); EnumChildren(iter, '{', '}', R"(, )");
return true; return true;
} }

2
ccl/rslang/src/NameCollector.cpp
View File

@ -24,7 +24,7 @@ bool ASTInterpreter::NameCollector::MergeChildren(Cursor iter) {
return true; return true;
} }
bool ASTInterpreter::NameCollector::ViGlobalDefinition(Cursor iter) { bool ASTInterpreter::NameCollector::ViGlobalDeclaration(Cursor iter) {
if (iter->id == TokenID::PUNC_STRUCT) { if (iter->id == TokenID::PUNC_STRUCT) {
return false; // TODO: specify error return false; // TODO: specify error
} }

2
ccl/rslang/src/Parser.cpp
View File

@ -1,5 +1,3 @@
#pragma once
#include "ccl/rslang/Parser.h" #include "ccl/rslang/Parser.h"
namespace ccl::rslang { namespace ccl::rslang {

786
ccl/rslang/src/RSParserImpl.cpp
View File

File diff suppressed because it is too large Load Diff

16
ccl/rslang/src/RSParserImpl.y
View File

@ -261,18 +261,15 @@ RawNode Imperative(
expression expression
: global_declaration : global_declaration
| logic_or_setexpr { state->FinalizeExpression($1); } | logic_or_setexpr { state->FinalizeExpression($1); }
| function_decl { state->FinalizeExpression($1); } | function_definition { state->FinalizeExpression($1); }
; ;
global_declaration global_declaration
: GLOBAL DEFINE { state->FinalizeCstEmpty($1, $2); } : GLOBAL DEFINE { state->FinalizeCstEmpty($1, $2); }
| GLOBAL STRUCT setexpr { state->FinalizeCstExpression($1, $2, $3); } | GLOBAL STRUCT setexpr { state->FinalizeCstExpression($1, $2, $3); }
| GLOBAL DEFINE logic_or_setexpr { state->FinalizeCstExpression($1, $2, $3); } | GLOBAL DEFINE logic_or_setexpr { state->FinalizeCstExpression($1, $2, $3); }
| function_name DEFINE function_decl { state->FinalizeCstExpression($1, $2, $3); } | FUNCTION DEFINE function_definition { state->FinalizeCstExpression($1, $2, $3); }
; | PREDICATE DEFINE function_definition { state->FinalizeCstExpression($1, $2, $3); }
function_name
: FUNCTION
| PREDICATE
; ;
logic_or_setexpr logic_or_setexpr
@ -280,7 +277,7 @@ logic_or_setexpr
| setexpr | setexpr
; ;
function_decl function_definition
: LS arguments RS logic_or_setexpr { $$ = FunctionDeclaration($1, $2, $4); } : LS arguments RS logic_or_setexpr { $$ = FunctionDeclaration($1, $2, $4); }
| LS error { state->OnError(ParseEID::expectedDeclaration); YYABORT; } | LS error { state->OnError(ParseEID::expectedDeclaration); YYABORT; }
; ;
@ -407,9 +404,10 @@ literal
identifier identifier
: GLOBAL : GLOBAL
| function_name | FUNCTION
| PREDICATE
| LOCAL
| RADICAL | RADICAL
| LOCAL
; ;
setexpr_binary setexpr_binary

79
ccl/rslang/src/TypeAuditor.cpp
View File

@ -49,8 +49,8 @@ bool IsEchelon(SyntaxTree::Cursor iter, const Index index) {
return IsEchelon(iter); return IsEchelon(iter);
} }
bool IsRadical(const std::string& globalName) { bool IsRadical(const std::string& alias) {
return !empty(globalName) && globalName.at(0) == 'R' && globalName.at(1) != '0'; return !empty(alias) && alias.at(0) == 'R' && alias.at(1) != '0';
} }
void MangleRadicals(const std::string& funcName, Typification& type) { void MangleRadicals(const std::string& funcName, Typification& type) {
@ -301,7 +301,7 @@ void TypeAuditor::Clear() noexcept {
currentType = {}; currentType = {};
} }
bool TypeAuditor::ViGlobalDefinition(Cursor iter) { bool TypeAuditor::ViGlobalDeclaration(Cursor iter) {
const auto childrenCount = iter.ChildrenCount(); const auto childrenCount = iter.ChildrenCount();
if (iter->id == TokenID::PUNC_STRUCT) { if (iter->id == TokenID::PUNC_STRUCT) {
if (childrenCount != 2 || !IsEchelon(iter, 1)) { if (childrenCount != 2 || !IsEchelon(iter, 1)) {
@ -420,37 +420,38 @@ std::optional<Typification::Substitutes> TypeAuditor::CheckFuncArguments(Cursor
} }
bool TypeAuditor::ViGlobal(Cursor iter) { bool TypeAuditor::ViGlobal(Cursor iter) {
const auto& globalName = iter->data.ToText(); const auto& alias = iter->data.ToText();
if (iter->id == TokenID::ID_RADICAL) { if (env.context.FunctionArgsFor(alias) != nullptr) {
if (!isFuncDeclaration && !isTypification) { OnError(
OnError( SemanticEID::globalFuncWithoutArgs,
SemanticEID::radicalUsage, iter->pos.start,
iter->pos.start, alias
globalName );
); return false;
return false;
}
return SetCurrent(Typification(globalName).ApplyBool());
} else {
if (env.context.FunctionArgsFor(globalName) != nullptr) {
OnError(
SemanticEID::globalFuncWithoutArgs,
iter->pos.start,
globalName
);
return false;
}
const auto* type = env.context.TypeFor(globalName);
if (type == nullptr) {
OnError(
SemanticEID::globalNotTyped,
iter->pos.start,
globalName
);
return false;
}
return SetCurrent(*type);
} }
const auto* type = env.context.TypeFor(alias);
if (type == nullptr) {
OnError(
SemanticEID::globalNotTyped,
iter->pos.start,
alias
);
return false;
}
return SetCurrent(*type);
}
bool TypeAuditor::ViRadical(Cursor iter) {
const auto& alias = iter->data.ToText();
if (!isFuncDeclaration && !isTypification) {
OnError(
SemanticEID::radicalUsage,
iter->pos.start,
alias
);
return false;
}
return SetCurrent(Typification(alias).ApplyBool());
} }
bool TypeAuditor::ViLocal(Cursor iter) { bool TypeAuditor::ViLocal(Cursor iter) {
@ -470,7 +471,7 @@ bool TypeAuditor::ViEmptySet(Cursor /*iter*/) {
return SetCurrent(Typification::EmptySet()); return SetCurrent(Typification::EmptySet());
} }
bool TypeAuditor::ViLocalBind(Cursor iter) { bool TypeAuditor::ViTupleDeclaration(Cursor iter) {
assert(isLocalDeclaration || isFuncDeclaration); assert(isLocalDeclaration || isFuncDeclaration);
const Typification type = std::get<Typification>(currentType); const Typification type = std::get<Typification>(currentType);
if (!type.IsTuple() || type.T().Arity() != iter.ChildrenCount()) { if (!type.IsTuple() || type.T().Arity() != iter.ChildrenCount()) {
@ -545,7 +546,7 @@ bool TypeAuditor::ViArithmetic(Cursor iter) {
return SetCurrent(result.value()); return SetCurrent(result.value());
} }
bool TypeAuditor::ViOrdering(Cursor iter) { bool TypeAuditor::ViIntegerPredicate(Cursor iter) {
const auto test1 = ChildType(iter, 0); const auto test1 = ChildType(iter, 0);
if(!test1.has_value()) { if(!test1.has_value()) {
return false; return false;
@ -629,7 +630,7 @@ bool TypeAuditor::ViEquals(Cursor iter) {
return SetCurrent(LogicT{}); return SetCurrent(LogicT{});
} }
bool TypeAuditor::ViTypedPredicate(Cursor iter) { bool TypeAuditor::ViSetexprPredicate(Cursor iter) {
auto type2 = ChildTypeDebool(iter, 1, SemanticEID::invalidTypeOperation); auto type2 = ChildTypeDebool(iter, 1, SemanticEID::invalidTypeOperation);
if (!type2.has_value()) { if (!type2.has_value()) {
return false; return false;
@ -721,7 +722,7 @@ bool TypeAuditor::ViRecursion(Cursor iter) {
} }
const bool isFull = iter->id == TokenID::NT_RECURSIVE_FULL; const bool isFull = iter->id == TokenID::NT_RECURSIVE_FULL;
Index iterationIndex{ isFull ? 3 : 2 }; const auto iterationIndex = static_cast<Index>(isFull ? 3 : 2);
const auto iterationType = ChildType(iter, iterationIndex); const auto iterationType = ChildType(iter, iterationIndex);
if (!iterationType.has_value()) { if (!iterationType.has_value()) {
@ -791,7 +792,7 @@ bool TypeAuditor::ViTuple(Cursor iter) {
return SetCurrent(Typification::Tuple(components)); return SetCurrent(Typification::Tuple(components));
} }
bool TypeAuditor::ViSetEnum(Cursor iter) { bool TypeAuditor::ViEnumeration(Cursor iter) {
auto test = ChildType(iter, 0); auto test = ChildType(iter, 0);
if (!test.has_value()) { if (!test.has_value()) {
return false; return false;
@ -826,7 +827,7 @@ bool TypeAuditor::ViDebool(Cursor iter) {
return SetCurrent(type.value()); return SetCurrent(type.value());
} }
bool TypeAuditor::ViTypedBinary(Cursor iter) { bool TypeAuditor::ViSetexprBinary(Cursor iter) {
auto type1 = ChildTypeDebool(iter, 0, SemanticEID::invalidTypeOperation); auto type1 = ChildTypeDebool(iter, 0, SemanticEID::invalidTypeOperation);
if (!type1.has_value()) { if (!type1.has_value()) {
return false; return false;

36
ccl/rslang/src/ValueAuditor.cpp
View File

@ -66,7 +66,7 @@ bool ValueAuditor::AssertAllValues(Cursor iter) {
return true; return true;
} }
bool ValueAuditor::ViGlobalDefinition(Cursor iter) { bool ValueAuditor::ViGlobalDeclaration(Cursor iter) {
if (iter->id == TokenID::PUNC_STRUCT) { if (iter->id == TokenID::PUNC_STRUCT) {
return VisitChild(iter, 1) && SetCurrent(ValueClass::value); return VisitChild(iter, 1) && SetCurrent(ValueClass::value);
} else if (iter.ChildrenCount() == 1) { } else if (iter.ChildrenCount() == 1) {
@ -77,10 +77,10 @@ bool ValueAuditor::ViGlobalDefinition(Cursor iter) {
} }
bool ValueAuditor::ViFunctionCall(Cursor iter) { bool ValueAuditor::ViFunctionCall(Cursor iter) {
const auto& globalName = iter(0).data.ToText(); const auto& alias = iter(0).data.ToText();
const auto funcType = globalClass(globalName); const auto funcType = globalClass(alias);
if (funcType == ValueClass::invalid) { if (funcType == ValueClass::invalid) {
OnError(SemanticEID::globalNoValue, iter->pos.start, globalName); OnError(SemanticEID::globalNoValue, iter->pos.start, alias);
return false; return false;
} }
@ -98,7 +98,7 @@ bool ValueAuditor::ViFunctionCall(Cursor iter) {
current = funcType; current = funcType;
return true; return true;
} else { } else {
return RunCheckOnFunc(iter, globalName, args); return RunCheckOnFunc(iter, alias, args);
} }
} }
@ -131,18 +131,18 @@ bool ValueAuditor::RunCheckOnFunc(
} }
bool ValueAuditor::ViGlobal(Cursor iter) { bool ValueAuditor::ViGlobal(Cursor iter) {
const auto& globalName = iter->data.ToText(); const auto& alias = iter->data.ToText();
if (iter->id == TokenID::ID_RADICAL) { const auto type = globalClass(alias);
return SetCurrent(ValueClass::value); if (type == ValueClass::invalid) {
} else { OnError(SemanticEID::globalNoValue, iter->pos.start, alias);
const auto type = globalClass(globalName); return false;
if (type == ValueClass::invalid) {
OnError(SemanticEID::globalNoValue, iter->pos.start, globalName);
return false;
}
current = type;
return true;
} }
current = type;
return true;
}
bool ValueAuditor::ViRadical(Cursor /*iter*/) {
return SetCurrent(ValueClass::value);
} }
bool ValueAuditor::ViLocal(Cursor iter) { bool ValueAuditor::ViLocal(Cursor iter) {
@ -158,7 +158,7 @@ bool ValueAuditor::ViQuantifier(Cursor iter) {
return AssertChildIsValue(iter, 1) && VisitChild(iter, 2); return AssertChildIsValue(iter, 1) && VisitChild(iter, 2);
} }
bool ValueAuditor::ViTypedPredicate(Cursor iter) { bool ValueAuditor::ViSetexprPredicate(Cursor iter) {
switch (iter->id) { switch (iter->id) {
default: default:
case TokenID::IN: case TokenID::IN:
@ -202,7 +202,7 @@ bool ValueAuditor::ViBoolean(Cursor iter) {
return VisitChild(iter, 0) && SetCurrent(ValueClass::props); return VisitChild(iter, 0) && SetCurrent(ValueClass::props);
} }
bool ValueAuditor::ViTypedBinary(Cursor iter) { bool ValueAuditor::ViSetexprBinary(Cursor iter) {
if (!VisitChild(iter, 0)) { if (!VisitChild(iter, 0)) {
return false; return false;
} }