mirror of
https://codeberg.org/ProgramSnail/lang.git
synced 2025-12-06 15:08:48 +00:00
311 lines
8.5 KiB
C++
311 lines
8.5 KiB
C++
#pragma once
|
|
|
|
#include <string>
|
|
|
|
namespace tokens {
|
|
|
|
enum class Type {
|
|
|
|
// --- sources
|
|
|
|
SOURCE_FILE,
|
|
IMPORT,
|
|
CONSTRAINT,
|
|
|
|
// --- definitions
|
|
|
|
FUNCTION_DEFINITION,
|
|
TYPE_DEFINITION, // datatype or typeclass
|
|
|
|
// --- flow control
|
|
|
|
CASE,
|
|
MATCH,
|
|
CONDITION,
|
|
LOOP,
|
|
|
|
// --- operators
|
|
|
|
COMMA_EXPRESSION,
|
|
OPERATOR_EXPRESSION,
|
|
|
|
// --- continers
|
|
|
|
BLOCK,
|
|
ARRAY,
|
|
|
|
// --- modifiers
|
|
|
|
RETURN,
|
|
NAME_DEFINITION,
|
|
ARRAY_ACCESS,
|
|
TUPLE_ACCESS,
|
|
LOOP_CONTROL,
|
|
REFERENCE_EXPRESSION,
|
|
SUFFIX_EXPRESSION,
|
|
|
|
// --- other
|
|
|
|
NAME_EXPRESSION,
|
|
CONSTRUCTOR,
|
|
LAMBDA,
|
|
|
|
// --- type
|
|
|
|
VARIANT_TYPE,
|
|
TUPLE_TYPE,
|
|
ARRAY_TYPE,
|
|
REFERENCE_TYPE,
|
|
MODIFIED_TYPE,
|
|
SIMPLE_TYPE,
|
|
|
|
// --- comments
|
|
|
|
DEFINITION_INFO,
|
|
ANNOTATION_INFO,
|
|
|
|
EXTRA,
|
|
|
|
EMPTY_LINES,
|
|
|
|
// --- tokens
|
|
|
|
PLACEHOLDER,
|
|
SIMPLE_NAME_IDENTIFIER,
|
|
SIMPLE_TYPE_IDENTIFIER,
|
|
TYPECLASS_IDENTIFIER,
|
|
ARGUMENT_NAME_IDENTIFIER,
|
|
ARGUMENT_TYPE_IDENTIFIER,
|
|
ANNOTATION_IDENTIFIER,
|
|
|
|
OPERATOR,
|
|
OPERATOR_TAIL1,
|
|
OPERATOR_TAIL2,
|
|
OPERATOR_TAIL3,
|
|
|
|
FLOAT_LITERAL,
|
|
DOUBLE_LITERAL,
|
|
INT_LITERAL,
|
|
LONG_LITERAL,
|
|
INDEX_LITERAL,
|
|
STRING_LITERAL,
|
|
UNICODE_STRING_LITERAL,
|
|
CHAR_LITERAL,
|
|
UNICODE_LITERAL,
|
|
BOOL_LITERAL,
|
|
UNIT_LITERAL,
|
|
NULL_LITERAL,
|
|
|
|
// ---
|
|
|
|
UNDEFINED,
|
|
};
|
|
|
|
// --- sources
|
|
|
|
const static std::string SOURCE_FILE = "source_file";
|
|
const static std::string IMPORT = "import";
|
|
const static std::string CONSTRAINT = "constraint";
|
|
|
|
// --- definitions
|
|
|
|
const static std::string FUNCTION_DEFINITION = "function_definition";
|
|
const static std::string TYPE_DEFINITION = "type_definition";
|
|
|
|
// --- flow control
|
|
|
|
const static std::string CASE = "case";
|
|
const static std::string MATCH = "match";
|
|
const static std::string CONDITION = "condition";
|
|
const static std::string LOOP = "loop";
|
|
|
|
// --- operators
|
|
|
|
const static std::string COMMA_EXPRESSION = "comma_expression";
|
|
const static std::string OPERATOR_EXPRESSION = "operator_expression";
|
|
|
|
// --- continers
|
|
|
|
const static std::string BLOCK = "block";
|
|
const static std::string ARRAY = "array";
|
|
|
|
// --- modifiers
|
|
|
|
const static std::string RETURN = "return";
|
|
const static std::string NAME_DEFINITION = "name_definition";
|
|
const static std::string ARRAY_ACCESS = "array_access";
|
|
const static std::string TUPLE_ACCESS = "tuple_access";
|
|
const static std::string LOOP_CONTROL = "loop_control";
|
|
const static std::string REFERENCE_EXPRESSION = "reference_expression";
|
|
const static std::string SUFFIX_EXPRESSION = "suffix_expression";
|
|
|
|
// --- other
|
|
|
|
const static std::string NAME_EXPRESSION = "name_expression";
|
|
const static std::string CONSTRUCTOR = "constructor";
|
|
const static std::string LAMBDA = "lambda";
|
|
|
|
// --- type
|
|
|
|
const static std::string VARIANT_TYPE = "variant_type";
|
|
const static std::string TUPLE_TYPE = "tuple_type";
|
|
const static std::string ARRAY_TYPE = "array_type";
|
|
const static std::string REFERENCE_TYPE = "reference_type";
|
|
const static std::string MODIFIED_TYPE = "modified_type";
|
|
const static std::string SIMPLE_TYPE = "simple_type";
|
|
|
|
// --- comments
|
|
|
|
const static std::string DEFINITION_INFO = "definition_info";
|
|
const static std::string ANNOTATION_INFO = "annotation_info";
|
|
|
|
const static std::string EXTRA = "extra";
|
|
|
|
const static std::string EMPTY_LINES = "empty_lines";
|
|
|
|
// --- tokens
|
|
|
|
const static std::string PLACEHOLDER = "placeholder";
|
|
const static std::string SIMPLE_NAME_IDENTIFIER = "simple_name_identifier";
|
|
const static std::string SIMPLE_TYPE_IDENTIFIER = "simple_type_identifier";
|
|
const static std::string TYPECLASS_IDENTIFIER = "typeclass_identifier";
|
|
const static std::string ARGUMENT_NAME_IDENTIFIER = "argument_name_identifier";
|
|
const static std::string ARGUMENT_TYPE_IDENTIFIER = "argument_type_identifier";
|
|
const static std::string ANNOTATION_IDENTIFIER = "annotation_identifier";
|
|
|
|
const static std::string OPERATOR = "operator";
|
|
const static std::string OPERATOR_TAIL1 = "operator_tail1";
|
|
const static std::string OPERATOR_TAIL2 = "operator_tail2";
|
|
const static std::string OPERATOR_TAIL3 = "operator_tail3";
|
|
|
|
const static std::string FLOAT_LITERAL = "float_literal";
|
|
const static std::string DOUBLE_LITERAL = "double_literal";
|
|
const static std::string INT_LITERAL = "int_literal";
|
|
const static std::string LONG_LITERAL = "long_literal";
|
|
const static std::string INDEX_LITERAL = "index_literal";
|
|
const static std::string STRING_LITERAL = "string_literal";
|
|
const static std::string UNICODE_STRING_LITERAL = "unicode_string_literal";
|
|
const static std::string CHAR_LITERAL = "char_literal";
|
|
const static std::string UNICODE_LITERAL = "unicode_literal";
|
|
const static std::string BOOL_LITERAL = "bool_literal";
|
|
const static std::string UNIT_LITERAL = "unit_literal";
|
|
const static std::string NULL_LITERAL = "null_literal";
|
|
|
|
inline Type string_to_type(const std::string &str) {
|
|
if (str == SOURCE_FILE) {
|
|
return Type::SOURCE_FILE;
|
|
} else if (str == IMPORT) {
|
|
return Type::IMPORT;
|
|
} else if (str == CONSTRAINT) {
|
|
return Type::CONSTRAINT;
|
|
} else if (str == FUNCTION_DEFINITION) {
|
|
return Type::FUNCTION_DEFINITION;
|
|
} else if (str == TYPE_DEFINITION) {
|
|
return Type::TYPE_DEFINITION;
|
|
} else if (str == CASE) {
|
|
return Type::CASE;
|
|
} else if (str == MATCH) {
|
|
return Type::MATCH;
|
|
} else if (str == CONDITION) {
|
|
return Type::CONDITION;
|
|
} else if (str == LOOP) {
|
|
return Type::LOOP;
|
|
} else if (str == COMMA_EXPRESSION) {
|
|
return Type::COMMA_EXPRESSION;
|
|
} else if (str == OPERATOR_EXPRESSION) {
|
|
return Type::OPERATOR_EXPRESSION;
|
|
} else if (str == BLOCK) {
|
|
return Type::BLOCK;
|
|
} else if (str == ARRAY) {
|
|
return Type::ARRAY;
|
|
} else if (str == RETURN) {
|
|
return Type::RETURN;
|
|
} else if (str == NAME_DEFINITION) {
|
|
return Type::NAME_DEFINITION;
|
|
} else if (str == ARRAY_ACCESS) {
|
|
return Type::ARRAY_ACCESS;
|
|
} else if (str == TUPLE_ACCESS) {
|
|
return Type::TUPLE_ACCESS;
|
|
} else if (str == LOOP_CONTROL) {
|
|
return Type::LOOP_CONTROL;
|
|
} else if (str == REFERENCE_EXPRESSION) {
|
|
return Type::REFERENCE_EXPRESSION;
|
|
} else if (str == SUFFIX_EXPRESSION) {
|
|
return Type::SUFFIX_EXPRESSION;
|
|
} else if (str == NAME_EXPRESSION) {
|
|
return Type::NAME_EXPRESSION;
|
|
} else if (str == CONSTRUCTOR) {
|
|
return Type::CONSTRUCTOR;
|
|
} else if (str == LAMBDA) {
|
|
return Type::LAMBDA;
|
|
} else if (str == VARIANT_TYPE) {
|
|
return Type::VARIANT_TYPE;
|
|
} else if (str == TUPLE_TYPE) {
|
|
return Type::TUPLE_TYPE;
|
|
} else if (str == ARRAY_TYPE) {
|
|
return Type::ARRAY_TYPE;
|
|
} else if (str == REFERENCE_TYPE) {
|
|
return Type::REFERENCE_TYPE;
|
|
} else if (str == MODIFIED_TYPE) {
|
|
return Type::MODIFIED_TYPE;
|
|
} else if (str == SIMPLE_TYPE) {
|
|
return Type::SIMPLE_TYPE;
|
|
} else if (str == DEFINITION_INFO) {
|
|
return Type::DEFINITION_INFO;
|
|
} else if (str == ANNOTATION_INFO) {
|
|
return Type::ANNOTATION_INFO;
|
|
} else if (str == EXTRA) {
|
|
return Type::EXTRA;
|
|
} else if (str == EMPTY_LINES) {
|
|
return Type::EMPTY_LINES;
|
|
} else if (str == PLACEHOLDER) {
|
|
return Type::PLACEHOLDER;
|
|
} else if (str == SIMPLE_NAME_IDENTIFIER) {
|
|
return Type::SIMPLE_NAME_IDENTIFIER;
|
|
} else if (str == SIMPLE_TYPE_IDENTIFIER) {
|
|
return Type::SIMPLE_TYPE_IDENTIFIER;
|
|
} else if (str == TYPECLASS_IDENTIFIER) {
|
|
return Type::TYPECLASS_IDENTIFIER;
|
|
} else if (str == ARGUMENT_NAME_IDENTIFIER) {
|
|
return Type::ARGUMENT_NAME_IDENTIFIER;
|
|
} else if (str == ARGUMENT_TYPE_IDENTIFIER) {
|
|
return Type::ARGUMENT_TYPE_IDENTIFIER;
|
|
} else if (str == ANNOTATION_IDENTIFIER) {
|
|
return Type::ANNOTATION_IDENTIFIER;
|
|
} else if (str == OPERATOR) {
|
|
return Type::OPERATOR;
|
|
} else if (str == OPERATOR_TAIL1) {
|
|
return Type::OPERATOR_TAIL1;
|
|
} else if (str == OPERATOR_TAIL2) {
|
|
return Type::OPERATOR_TAIL2;
|
|
} else if (str == OPERATOR_TAIL3) {
|
|
return Type::OPERATOR_TAIL3;
|
|
} else if (str == FLOAT_LITERAL) {
|
|
return Type::FLOAT_LITERAL;
|
|
} else if (str == DOUBLE_LITERAL) {
|
|
return Type::DOUBLE_LITERAL;
|
|
} else if (str == INT_LITERAL) {
|
|
return Type::INT_LITERAL;
|
|
} else if (str == LONG_LITERAL) {
|
|
return Type::LONG_LITERAL;
|
|
} else if (str == INDEX_LITERAL) {
|
|
return Type::INDEX_LITERAL;
|
|
} else if (str == STRING_LITERAL) {
|
|
return Type::STRING_LITERAL;
|
|
} else if (str == UNICODE_STRING_LITERAL) {
|
|
return Type::UNICODE_STRING_LITERAL;
|
|
} else if (str == CHAR_LITERAL) {
|
|
return Type::CHAR_LITERAL;
|
|
} else if (str == UNICODE_LITERAL) {
|
|
return Type::UNICODE_LITERAL;
|
|
} else if (str == BOOL_LITERAL) {
|
|
return Type::BOOL_LITERAL;
|
|
} else if (str == UNIT_LITERAL) {
|
|
return Type::UNIT_LITERAL;
|
|
} else if (str == NULL_LITERAL) {
|
|
return Type::NULL_LITERAL;
|
|
}
|
|
return Type::UNDEFINED;
|
|
}
|
|
|
|
} // namespace tokens
|