Improved parsing
This commit is contained in:
Sven Heidemann
@@ -14,22 +14,19 @@ class Interpreter:
|
||||
self.__parser = Parser(repo, utils)
|
||||
self.__validator = Validator(repo, utils)
|
||||
|
||||
def interpret(self, line_int: int, line_str: str) -> bool:
|
||||
toks = []
|
||||
ast = []
|
||||
def interpret(self, line_str: str) -> None:
|
||||
"""
|
||||
Interprets code line
|
||||
:param line_str:
|
||||
:return:
|
||||
"""
|
||||
tokens = []
|
||||
|
||||
self.__utils.line_number = line_int
|
||||
if self.__repo.error is None:
|
||||
toks = self.__lexer.tokenize(line_str)
|
||||
if self.__repo.is_error is None:
|
||||
tokens = self.__lexer.tokenize(line_str)
|
||||
|
||||
self.__repo.output_tokens(toks)
|
||||
if self.__repo.is_error is None:
|
||||
self.__parser.parse(tokens)
|
||||
|
||||
if self.__repo.error is None:
|
||||
ast = self.__parser.parse(toks)
|
||||
|
||||
# self.__repo.output_ast(ast)
|
||||
|
||||
if self.__repo.error is None:
|
||||
self.__validator.validate(ast)
|
||||
|
||||
return self.__repo.error is None
|
||||
# if self.__repo.is_error is None:
|
||||
# self.__validator.validate(self.__repo.AST)
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
from typing import List
|
||||
|
||||
from Interpreter.Repo import Repo
|
||||
from Interpreter.Utils import Utils
|
||||
from Models.Interpreter.Token import Token
|
||||
from Models.Interpreter.TokenTypes import TokenTypes
|
||||
from Models.Interpreter.UnresolvedTokenTypes import UnresolvedTokenTypes
|
||||
|
||||
|
||||
class Lexer:
|
||||
@@ -9,31 +13,58 @@ class Lexer:
|
||||
self.__repo = repo
|
||||
self.__utils = utils
|
||||
|
||||
self.__ml_comment = False
|
||||
self.__toks = []
|
||||
self.__is_ml_comment = False
|
||||
|
||||
def __add_tok(self, tokens: List[Token], value: str, input_token_type: UnresolvedTokenTypes) -> None:
|
||||
"""
|
||||
Creates token object
|
||||
:param value:
|
||||
:param token_type:
|
||||
:return:
|
||||
"""
|
||||
token_type: TokenTypes = TokenTypes.Empty
|
||||
|
||||
def __add_tok(self, value: str, type: str) -> None:
|
||||
if value != '':
|
||||
if type == 'word':
|
||||
if input_token_type == UnresolvedTokenTypes.Word:
|
||||
if value in self.__repo.keywords:
|
||||
type = 'keyword'
|
||||
token_type = TokenTypes.Keyword
|
||||
|
||||
elif value in self.__repo.types:
|
||||
type = 'type'
|
||||
token_type = TokenTypes.Type
|
||||
|
||||
elif value in self.__repo.bool_values:
|
||||
type = 'bool'
|
||||
token_type = TokenTypes.Bool
|
||||
|
||||
elif value == 'empty':
|
||||
type = 'emptyType'
|
||||
elif value == UnresolvedTokenTypes.Empty:
|
||||
token_type = TokenTypes.Empty
|
||||
|
||||
else:
|
||||
type = 'name'
|
||||
token_type = TokenTypes.Name
|
||||
|
||||
self.__toks.append(Token(type, value))
|
||||
elif input_token_type == UnresolvedTokenTypes.Number:
|
||||
token_type = TokenTypes.Number
|
||||
|
||||
def tokenize(self, line: str) -> list:
|
||||
self.__toks = []
|
||||
elif input_token_type == UnresolvedTokenTypes.String:
|
||||
token_type = TokenTypes.String
|
||||
|
||||
elif input_token_type == UnresolvedTokenTypes.Expression_Character:
|
||||
token_type = TokenTypes.Expression_Character
|
||||
|
||||
elif input_token_type == UnresolvedTokenTypes.Bool_Expression_Character:
|
||||
token_type = TokenTypes.Bool_Expression_Character
|
||||
|
||||
elif input_token_type == UnresolvedTokenTypes.Format_Character:
|
||||
token_type = TokenTypes.Format_Character
|
||||
|
||||
tokens.append(Token(token_type, value))
|
||||
|
||||
def tokenize(self, line: str) -> List[Token]:
|
||||
"""
|
||||
Creates token list from code line
|
||||
:param line:
|
||||
:return:
|
||||
"""
|
||||
tokens: List[Token] = []
|
||||
word = ''
|
||||
ol_comment = False
|
||||
is_string1 = False # 'hello'
|
||||
@@ -44,27 +75,27 @@ class Lexer:
|
||||
for i in range(0, len(line)):
|
||||
c = line[i]
|
||||
# ignore comments and spaces
|
||||
if not ol_comment and not self.__ml_comment:
|
||||
if not ol_comment and not self.__is_ml_comment:
|
||||
# comment filtering
|
||||
if c == '#' and not is_string1 and not is_string2:
|
||||
ol_comment = True
|
||||
|
||||
elif line[i-1] == '/' and c == '/':
|
||||
elif line[i - 1] == '/' and c == '/':
|
||||
ol_comment = True
|
||||
|
||||
elif line[i-1] == '/' and c == '*':
|
||||
self.__ml_comment = True
|
||||
elif line[i - 1] == '/' and c == '*':
|
||||
self.__is_ml_comment = True
|
||||
i += 2
|
||||
|
||||
# end of number
|
||||
elif not c.isdigit() and c != '.' and is_number:
|
||||
self.__add_tok(word, 'number')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Number)
|
||||
word = ''
|
||||
is_number = False
|
||||
|
||||
# end of expression char
|
||||
elif c not in self.__repo.expr_chars and is_expr_char:
|
||||
self.__add_tok(word, 'expr_char')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Expression_Character)
|
||||
word = ''
|
||||
is_expr_char = False
|
||||
|
||||
@@ -76,7 +107,7 @@ class Lexer:
|
||||
# end of is_string1
|
||||
elif c == '\'' and is_string1:
|
||||
is_string1 = False
|
||||
self.__add_tok(word, 'string')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.String)
|
||||
word = ''
|
||||
|
||||
# begin of is_string2
|
||||
@@ -87,13 +118,13 @@ class Lexer:
|
||||
# end of is_string2
|
||||
elif c == '\"' and is_string2:
|
||||
is_string2 = False
|
||||
self.__add_tok(word, 'string')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.String)
|
||||
word = ''
|
||||
|
||||
# format char
|
||||
elif c in self.__repo.format_chars:
|
||||
self.__add_tok(word, 'word')
|
||||
self.__add_tok(c, 'format_char')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
|
||||
self.__add_tok(tokens, c, UnresolvedTokenTypes.Format_Character)
|
||||
word = ''
|
||||
|
||||
# begin of number
|
||||
@@ -116,13 +147,13 @@ class Lexer:
|
||||
|
||||
# bool expression char
|
||||
elif c in self.__repo.bool_expr_chars:
|
||||
self.__add_tok(word, 'word')
|
||||
self.__add_tok(c, 'bool_expr_char')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
|
||||
self.__add_tok(tokens, c, UnresolvedTokenTypes.Bool_Expression_Character)
|
||||
word = ''
|
||||
|
||||
# end of word
|
||||
elif c == ' ' and not is_string1 and not is_string2 or c == '\n':
|
||||
self.__add_tok(word, 'word')
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
|
||||
word = ''
|
||||
|
||||
else:
|
||||
@@ -132,6 +163,6 @@ class Lexer:
|
||||
ol_comment = False
|
||||
|
||||
if line[i - 1] == '*' and c == '/':
|
||||
self.__ml_comment = False
|
||||
self.__is_ml_comment = False
|
||||
|
||||
return self.__toks
|
||||
return tokens
|
||||
|
||||
@@ -1,10 +1,20 @@
|
||||
from typing import List, Optional
|
||||
|
||||
from termcolor import colored
|
||||
|
||||
from Interpreter.Repo import Repo
|
||||
from Interpreter.Utils import Utils
|
||||
from Models.Interpreter.Error import Error
|
||||
from Models.AbstractSyntaxTree.Class import Class
|
||||
from Models.AbstractSyntaxTree.Function import Function
|
||||
from Models.AbstractSyntaxTree.Library import Library
|
||||
from Models.AbstractSyntaxTree.Variable import Variable
|
||||
from Models.Interpreter.Error import Error, ErrorCode
|
||||
from Models.Interpreter.ExpressionCharacters import ExpressionCharacters
|
||||
from Models.Interpreter.FormatCharacters import FormatCharacters
|
||||
from Models.Interpreter.Keywords import Keywords
|
||||
from Models.Interpreter.Token import Token
|
||||
from Models.Nodes.Class import Class
|
||||
from Models.Nodes.Func import Func
|
||||
from Models.Nodes.Lib import Lib
|
||||
from Models.Interpreter.TokenTypes import TokenTypes
|
||||
from Models.Interpreter.Types import Types
|
||||
|
||||
|
||||
class Parser:
|
||||
@@ -13,37 +23,295 @@ class Parser:
|
||||
self.__repo = repo
|
||||
self.__utils = utils
|
||||
|
||||
self.__ast = []
|
||||
# library status
|
||||
self.__is_creating_library = False
|
||||
self.__is_saving_library = False
|
||||
self.__library: Optional[Library] = None
|
||||
|
||||
def parse(self, toks: list) -> []:
|
||||
self.__tokens = toks
|
||||
self.__ast = []
|
||||
# class status
|
||||
self.__is_creating_class = False
|
||||
self.__is_saving_class = False
|
||||
self.__class: Optional[Class] = None
|
||||
|
||||
# function status
|
||||
self.__is_creating_function = False
|
||||
self.__is_creating_function_parameters = False
|
||||
self.__is_saving_function = False
|
||||
self.__function: Optional[Function] = None
|
||||
|
||||
# variable status
|
||||
self.__is_creating_variable = False
|
||||
self.__is_saving_variable = False
|
||||
self.__variable: Optional[Variable] = None
|
||||
|
||||
# type status
|
||||
self.__is_creating_type = False
|
||||
self.__type: Optional[Types] = None
|
||||
|
||||
# common
|
||||
self.__next_is_public = True
|
||||
|
||||
def parse(self, tokens: List[Token]) -> None:
|
||||
"""
|
||||
Creates abstract syntax tree from token list
|
||||
:param tokens:
|
||||
:return:
|
||||
"""
|
||||
# output
|
||||
if len(toks) > 0:
|
||||
tokens = []
|
||||
for t in toks:
|
||||
tokens.append({t.value: t.type})
|
||||
if len(tokens) == 0:
|
||||
return None
|
||||
|
||||
# print(tokens)
|
||||
output_tokens = []
|
||||
for t in tokens:
|
||||
output_tokens.append({t.value: t.type})
|
||||
# print(output_tokens)
|
||||
|
||||
self.__check()
|
||||
for i in range(0, len(tokens)):
|
||||
token = tokens[i]
|
||||
print(colored(f'>> {self.__utils.line_number}: {token.type} {token.value}', 'blue'))
|
||||
|
||||
# output
|
||||
if len(self.__repo.ast) > 1:
|
||||
print('___')
|
||||
for a_lib in self.__repo.ast:
|
||||
print(a_lib.name)
|
||||
for a_class in a_lib.ast:
|
||||
print(a_class.name, a_class.access)
|
||||
for a_funcs in a_class.ast:
|
||||
print(a_funcs.name, a_funcs.return_type, a_funcs.access)
|
||||
""" error status checks """
|
||||
# check if var name is valid
|
||||
if i-1 >= 0 and self.__is_creating_variable and tokens[i-1].value == Keywords.Variable:
|
||||
if token.type != TokenTypes.Name:
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, f'{token.type.name}: {token.value}'))
|
||||
|
||||
print('___')
|
||||
# print(self.__repo.ast, '\n')
|
||||
""" normal status checks """
|
||||
# token is member of variable value
|
||||
if self.__is_saving_variable and token.value != FormatCharacters.chars.value[FormatCharacters.Semicolon.value] and self.__variable is not None:
|
||||
print(6, 'save variable value')
|
||||
self.__variable.value.append(token)
|
||||
|
||||
return self.__ast
|
||||
# token type keyword
|
||||
if token.type == TokenTypes.Keyword:
|
||||
self.__check_token_keyword(tokens, i, token)
|
||||
|
||||
def __check(self) -> None:
|
||||
for i in range(0, len(self.__tokens)):
|
||||
tok = self.__tokens[i]
|
||||
# print(tok.value, tok.type)
|
||||
# token type format character
|
||||
elif token.type == TokenTypes.Format_Character:
|
||||
self.__check_token_format_character(token)
|
||||
|
||||
# token type expression character
|
||||
elif token.type == TokenTypes.Expression_Character:
|
||||
self.__check_token_expression_character(token)
|
||||
|
||||
# token type name
|
||||
elif token.type == TokenTypes.Name:
|
||||
self.__check_token_name(token)
|
||||
|
||||
# token type type
|
||||
elif token.type == TokenTypes.Type:
|
||||
self.__check_token_type(token)
|
||||
|
||||
""" validation function """
|
||||
def __check_token_keyword(self, tokens: List[Token], i: int, token: Token) -> None:
|
||||
if token.value == Keywords.Library:
|
||||
# create library
|
||||
self.__is_creating_library = True
|
||||
self.__library = Library()
|
||||
self.__set_is_public(self.__library)
|
||||
print(1, 'create lib')
|
||||
|
||||
elif token.value == Keywords.Class:
|
||||
# create class
|
||||
self.__is_creating_class = True
|
||||
self.__class = Class()
|
||||
self.__set_is_public(self.__class)
|
||||
print(2, 'create class')
|
||||
|
||||
elif token.value == Keywords.Function:
|
||||
# create function
|
||||
self.__is_creating_function = True
|
||||
self.__function = Function()
|
||||
self.__set_is_public(self.__function)
|
||||
print(3, 'create function')
|
||||
|
||||
elif token.value == Keywords.Variable:
|
||||
self.__is_creating_variable = True
|
||||
self.__variable = Variable()
|
||||
print(6, 'create variable')
|
||||
|
||||
elif token.value == Keywords.Public:
|
||||
if self.__is_saving_function:
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, f'{token.type.name}: {token.value}'))
|
||||
return
|
||||
|
||||
self.__next_is_public = True
|
||||
print(0, 'Next is public')
|
||||
|
||||
elif self.__next_is_public:
|
||||
if i - 1 > 0:
|
||||
error_msg = f'{token.type.name}: {tokens[i - 1].value}'
|
||||
else:
|
||||
error_msg = 'keyword: public'
|
||||
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, error_msg))
|
||||
|
||||
def __check_token_format_character(self, token: Token) -> None:
|
||||
if token.value == FormatCharacters.chars.value[FormatCharacters.Left_Brace.value]:
|
||||
|
||||
if self.__is_creating_library:
|
||||
# set status to save vars and funcs to library
|
||||
self.__is_creating_library = False
|
||||
self.__is_saving_library = True
|
||||
print(1, 'status save lib')
|
||||
|
||||
elif self.__is_creating_class:
|
||||
# set status to save vars and funcs to class
|
||||
self.__is_creating_class = False
|
||||
self.__is_saving_class = True
|
||||
print(2, 'status save class')
|
||||
|
||||
elif self.__is_creating_function:
|
||||
# set status to save vars and commands to function
|
||||
self.__is_creating_function = False
|
||||
self.__is_saving_function = True
|
||||
print(3, 'status save function')
|
||||
|
||||
# check for type end
|
||||
if self.__is_creating_type:
|
||||
self.__check_for_type_end()
|
||||
|
||||
elif token.value == FormatCharacters.chars.value[FormatCharacters.Right_Brace.value]:
|
||||
if self.__is_saving_function:
|
||||
# save function to class
|
||||
self.__is_saving_function = False
|
||||
|
||||
if self.__class is not None:
|
||||
self.__class.functions.append(self.__function)
|
||||
print(3, f'saved function {self.__function.name}')
|
||||
else:
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, f'function: {self.__function.name}'))
|
||||
|
||||
self.__function = None
|
||||
|
||||
elif self.__is_saving_class:
|
||||
# save class to library
|
||||
self.__is_saving_class = False
|
||||
|
||||
if self.__library is not None:
|
||||
self.__library.classes.append(self.__class)
|
||||
print(2, f'saved class {self.__class.name}')
|
||||
else:
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, f'class: {self.__class.name}'))
|
||||
|
||||
self.__class = None
|
||||
|
||||
elif self.__is_saving_library:
|
||||
# save library to ast
|
||||
self.__is_saving_library = False
|
||||
|
||||
self.__repo.AST.libs.append(self.__library)
|
||||
print(1, f'saved lib {self.__library.name}')
|
||||
self.__library = None
|
||||
|
||||
elif token.value == FormatCharacters.chars.value[FormatCharacters.Left_Parenthesis.value]:
|
||||
if self.__is_creating_function:
|
||||
self.__is_creating_function_parameters = True
|
||||
print(4, 'create function parameters')
|
||||
|
||||
elif token.value == FormatCharacters.chars.value[FormatCharacters.Right_Parenthesis.value]:
|
||||
if self.__is_creating_function:
|
||||
self.__is_creating_function_parameters = False
|
||||
self.__type = None
|
||||
print(4, 'save function parameters')
|
||||
|
||||
# check for type end
|
||||
if self.__is_creating_type:
|
||||
self.__check_for_type_end()
|
||||
|
||||
elif token.value == FormatCharacters.chars.value[FormatCharacters.Colon.value]:
|
||||
self.__check_create_type(token)
|
||||
|
||||
elif token.value == FormatCharacters.chars.value[FormatCharacters.Semicolon.value]:
|
||||
if self.__is_creating_type:
|
||||
self.__check_for_type_end()
|
||||
|
||||
if self.__is_saving_variable:
|
||||
self.__is_saving_variable = False
|
||||
self.__add_variable()
|
||||
self.__variable = None
|
||||
print(6, 'status saved variable')
|
||||
|
||||
elif self.__is_creating_variable:
|
||||
self.__is_creating_variable = False
|
||||
self.__is_saving_variable = True
|
||||
self.__add_variable()
|
||||
self.__variable = None
|
||||
print(6, 'status saved variable')
|
||||
|
||||
def __check_token_expression_character(self, token: Token) -> None:
|
||||
if token.value == ExpressionCharacters.chars.value[ExpressionCharacters.Equal.value]:
|
||||
# check for type end
|
||||
if self.__is_creating_type:
|
||||
self.__is_creating_variable = False
|
||||
self.__is_saving_variable = True
|
||||
self.__check_for_type_end()
|
||||
|
||||
def __check_token_name(self, token: Token) -> None:
|
||||
if self.__is_creating_type and self.__type is not None:
|
||||
self.__type = token.value
|
||||
print(5, 'save type')
|
||||
|
||||
elif self.__is_creating_variable and self.__variable is not None:
|
||||
self.__variable.name = token.value
|
||||
print(6, 'save variable name')
|
||||
|
||||
elif self.__is_creating_library:
|
||||
# save library name
|
||||
self.__library.name = token.value
|
||||
print(1, 'lib name')
|
||||
|
||||
elif self.__is_creating_class:
|
||||
# save class name
|
||||
self.__class.name = token.value
|
||||
print(2, 'class name')
|
||||
|
||||
elif self.__is_creating_function and not self.__is_creating_function_parameters:
|
||||
# save function name
|
||||
self.__function.name = token.value
|
||||
print(3, 'function name')
|
||||
|
||||
def __check_token_type(self, token: Token) -> None:
|
||||
if self.__is_creating_function and self.__function is not None and not self.__is_creating_function_parameters:
|
||||
self.__function.return_type = Types(Types.strings.value.index(token.value))
|
||||
print(3, 'save function type')
|
||||
|
||||
elif self.__is_creating_type:
|
||||
self.__type = Types(Types.strings.value.index(token.value))
|
||||
print(5, 'save type')
|
||||
|
||||
""" util functions """
|
||||
def __set_is_public(self, ast_element):
|
||||
if ast_element is not None and self.__next_is_public:
|
||||
ast_element.is_public = True
|
||||
self.__next_is_public = False
|
||||
|
||||
def __check_for_type_end(self):
|
||||
# end status creating type
|
||||
self.__is_creating_type = False
|
||||
print(5, 'status saved type')
|
||||
|
||||
def __check_create_type(self, token: Token):
|
||||
if self.__is_creating_function or self.__is_creating_function_parameters or self.__is_creating_variable:
|
||||
self.__is_creating_type = True
|
||||
print(5, 'create type')
|
||||
else:
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, f'{token.type.name}: {token.value}'))
|
||||
|
||||
def __add_variable(self):
|
||||
if len(self.__variable.value) == 0:
|
||||
self.__variable.value.append(Token(TokenTypes.Empty, Types.strings.value[Types.Empty.value]))
|
||||
|
||||
if self.__type is not None:
|
||||
self.__variable.type = self.__type
|
||||
else:
|
||||
self.__utils.error(Error(ErrorCode.Expected, f'type'))
|
||||
|
||||
if self.__is_saving_function and self.__function is not None:
|
||||
self.__function.variables.append(self.__variable)
|
||||
|
||||
elif self.__is_saving_class and self.__class is not None:
|
||||
self.__class.variables.append(self.__variable)
|
||||
|
||||
else:
|
||||
self.__utils.error(Error(ErrorCode.Unexpected, f'variable: {self.__variable.name}'))
|
||||
|
||||
@@ -1,3 +1,10 @@
|
||||
from Models.AbstractSyntaxTree.RuntimeAbstractSyntaxTree import RuntimeAbstractSyntaxTree
|
||||
from Models.Interpreter.Booleans import Booleans
|
||||
from Models.Interpreter.FormatCharacters import FormatCharacters
|
||||
from Models.Interpreter.Keywords import Keywords
|
||||
from Models.Interpreter.Types import Types
|
||||
|
||||
|
||||
class Repo:
|
||||
|
||||
def __init__(self) -> None:
|
||||
@@ -5,56 +12,58 @@ class Repo:
|
||||
|
||||
# interpreter
|
||||
self.keywords = [
|
||||
# define keys
|
||||
'lib',
|
||||
'class',
|
||||
'func',
|
||||
'var',
|
||||
'use',
|
||||
'from',
|
||||
# define keywords
|
||||
Keywords.Library,
|
||||
Keywords.Class,
|
||||
Keywords.Function,
|
||||
Keywords.Variable,
|
||||
Keywords.Use,
|
||||
Keywords.From,
|
||||
# builtin functions
|
||||
'output',
|
||||
'input',
|
||||
'length',
|
||||
'range',
|
||||
'exit',
|
||||
Keywords.Output,
|
||||
Keywords.Input,
|
||||
Keywords.Length,
|
||||
Keywords.Range,
|
||||
Keywords.Exit,
|
||||
# normal keywords
|
||||
'if',
|
||||
'elseif',
|
||||
'else',
|
||||
'pass',
|
||||
'in',
|
||||
Keywords.If,
|
||||
Keywords.ElseIf,
|
||||
Keywords.Else,
|
||||
Keywords.Pass,
|
||||
Keywords.If,
|
||||
Keywords.Return,
|
||||
# loops
|
||||
'while',
|
||||
'for',
|
||||
Keywords.While,
|
||||
Keywords.For,
|
||||
# access
|
||||
'public'
|
||||
Keywords.Public
|
||||
]
|
||||
self.types = [
|
||||
'any',
|
||||
'number',
|
||||
'string',
|
||||
'bool',
|
||||
'list',
|
||||
'dict',
|
||||
'emptyType',
|
||||
'void'
|
||||
Types.strings.value[Types.Any.value],
|
||||
Types.strings.value[Types.Number.value],
|
||||
Types.strings.value[Types.String.value],
|
||||
Types.strings.value[Types.Bool.value],
|
||||
Types.strings.value[Types.List.value],
|
||||
Types.strings.value[Types.Dict.value],
|
||||
Types.strings.value[Types.Empty.value],
|
||||
Types.strings.value[Types.Void.value]
|
||||
]
|
||||
self.format_chars = [
|
||||
FormatCharacters.chars.value[FormatCharacters.Left_Brace.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Right_Brace.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Left_Parenthesis.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Right_Parenthesis.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Left_Bracket.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Right_Bracket.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Semicolon.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Colon.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Comma.value],
|
||||
FormatCharacters.chars.value[FormatCharacters.Point.value]
|
||||
]
|
||||
self.format_chars = ['{', '}', '(', ')', ';', ':', ',', '.']
|
||||
self.expr_chars = ['+', '-', '*', '/', '=', '^']
|
||||
self.bool_expr_chars = ['<', '>', '!', '!=', '==', '>=', '<=', '&&', '||']
|
||||
self.bool_values = ['true', 'false']
|
||||
self.bool_values = [Booleans.Right, Booleans.Wrong]
|
||||
|
||||
# runtime
|
||||
self.error = None
|
||||
self.ast = []
|
||||
|
||||
def output_tokens(self, toks: list) -> None:
|
||||
if self.debug and len(toks) > 0:
|
||||
outp_toks = []
|
||||
for tok in toks:
|
||||
outp_toks.append({tok.value: tok.type})
|
||||
# print({tok.value: tok.type})
|
||||
|
||||
print(outp_toks)
|
||||
# print('\n')
|
||||
self.is_error = None
|
||||
self.AST: RuntimeAbstractSyntaxTree = RuntimeAbstractSyntaxTree()
|
||||
|
||||
@@ -17,6 +17,6 @@ class Utils:
|
||||
print(f'-> {text}')
|
||||
|
||||
def error(self, error: Error) -> None:
|
||||
self.__repo.error = error
|
||||
print(colored(f'Error in line {self.line_number}\n{self.__repo.error.code}: {self.__repo.error.msg}', 'red'))
|
||||
self.__repo.is_error = error
|
||||
print(colored(f'Error in line {self.line_number}\n{self.__repo.is_error.msg}', 'red'))
|
||||
# exit()
|
||||
|
||||
Reference in New Issue
Block a user