Removed old src
This commit is contained in:
parent
8f01e49479
commit
ff025bdc7f
223
old/src/Basic.py
223
old/src/Basic.py
@ -1,223 +0,0 @@
|
||||
from sly import Lexer
|
||||
from sly import Parser
|
||||
|
||||
|
||||
class BasicLexer(Lexer):
|
||||
tokens = {NAME, NUMBER, STRING, IF, THEN, ELSE, FOR, FUN, TO, ARROW, EQEQ}
|
||||
ignore = '\t '
|
||||
|
||||
literals = {'=', '+', '-', '/', '*', '(', ')', ',', ';'}
|
||||
|
||||
# Define tokens
|
||||
IF = r'IF'
|
||||
THEN = r'THEN'
|
||||
ELSE = r'ELSE'
|
||||
FOR = r'FOR'
|
||||
FUN = r'FUN'
|
||||
TO = r'TO'
|
||||
ARROW = r'->'
|
||||
NAME = r'[a-zA-Z_][a-zA-Z0-9_]*'
|
||||
STRING = r'\".*?\"'
|
||||
|
||||
EQEQ = r'=='
|
||||
|
||||
@_(r'\d+')
|
||||
def NUMBER(self, t):
|
||||
t.value = int(t.value)
|
||||
return t
|
||||
|
||||
@_(r'#.*')
|
||||
def COMMENT(self, t):
|
||||
pass
|
||||
|
||||
@_(r'\n+')
|
||||
def newline(self, t):
|
||||
self.lineno = t.value.count('\n')
|
||||
|
||||
|
||||
class BasicParser(Parser):
|
||||
tokens = BasicLexer.tokens
|
||||
|
||||
precedence = (
|
||||
('left', '+', '-'),
|
||||
('left', '*', '/'),
|
||||
('right', 'UMINUS'),
|
||||
)
|
||||
|
||||
def __init__(self):
|
||||
self.env = {}
|
||||
|
||||
@_('')
|
||||
def statement(self, p):
|
||||
pass
|
||||
|
||||
@_('FOR var_assign TO expr THEN statement')
|
||||
def statement(self, p):
|
||||
return ('for_loop', ('for_loop_setup', p.var_assign, p.expr), p.statement)
|
||||
|
||||
@_('IF condition THEN statement ELSE statement')
|
||||
def statement(self, p):
|
||||
return ('if_stmt', p.condition, ('branch', p.statement0, p.statement1))
|
||||
|
||||
@_('FUN NAME "(" ")" ARROW statement')
|
||||
def statement(self, p):
|
||||
return ('fun_def', p.NAME, p.statement)
|
||||
|
||||
@_('NAME "(" ")"')
|
||||
def statement(self, p):
|
||||
return ('fun_call', p.NAME)
|
||||
|
||||
@_('expr EQEQ expr')
|
||||
def condition(self, p):
|
||||
return ('condition_eqeq', p.expr0, p.expr1)
|
||||
|
||||
@_('var_assign')
|
||||
def statement(self, p):
|
||||
return p.var_assign
|
||||
|
||||
@_('NAME "=" expr')
|
||||
def var_assign(self, p):
|
||||
return ('var_assign', p.NAME, p.expr)
|
||||
|
||||
@_('NAME "=" STRING')
|
||||
def var_assign(self, p):
|
||||
return ('var_assign', p.NAME, p.STRING)
|
||||
|
||||
@_('expr')
|
||||
def statement(self, p):
|
||||
return (p.expr)
|
||||
|
||||
@_('expr "+" expr')
|
||||
def expr(self, p):
|
||||
return ('add', p.expr0, p.expr1)
|
||||
|
||||
@_('expr "-" expr')
|
||||
def expr(self, p):
|
||||
return ('sub', p.expr0, p.expr1)
|
||||
|
||||
@_('expr "*" expr')
|
||||
def expr(self, p):
|
||||
return ('mul', p.expr0, p.expr1)
|
||||
|
||||
@_('expr "/" expr')
|
||||
def expr(self, p):
|
||||
return ('div', p.expr0, p.expr1)
|
||||
|
||||
@_('"-" expr %prec UMINUS')
|
||||
def expr(self, p):
|
||||
return p.expr
|
||||
|
||||
@_('NAME')
|
||||
def expr(self, p):
|
||||
return ('var', p.NAME)
|
||||
|
||||
@_('NUMBER')
|
||||
def expr(self, p):
|
||||
return ('num', p.NUMBER)
|
||||
|
||||
|
||||
class BasicExecute:
|
||||
|
||||
def __init__(self, tree, env):
|
||||
self.env = env
|
||||
result = self.walkTree(tree)
|
||||
if result is not None and isinstance(result, int):
|
||||
print(result)
|
||||
if isinstance(result, str) and result[0] == '"':
|
||||
print(result)
|
||||
|
||||
def walkTree(self, node):
|
||||
|
||||
if isinstance(node, int):
|
||||
return node
|
||||
if isinstance(node, str):
|
||||
return node
|
||||
|
||||
if node is None:
|
||||
return None
|
||||
|
||||
if node[0] == 'program':
|
||||
if node[1] == None:
|
||||
self.walkTree(node[2])
|
||||
else:
|
||||
self.walkTree(node[1])
|
||||
self.walkTree(node[2])
|
||||
|
||||
if node[0] == 'num':
|
||||
return node[1]
|
||||
|
||||
if node[0] == 'str':
|
||||
return node[1]
|
||||
|
||||
if node[0] == 'if_stmt':
|
||||
result = self.walkTree(node[1])
|
||||
if result:
|
||||
return self.walkTree(node[2][1])
|
||||
return self.walkTree(node[2][2])
|
||||
|
||||
if node[0] == 'condition_eqeq':
|
||||
return self.walkTree(node[1]) == self.walkTree(node[2])
|
||||
|
||||
if node[0] == 'fun_def':
|
||||
self.env[node[1]] = node[2]
|
||||
|
||||
if node[0] == 'fun_call':
|
||||
try:
|
||||
return self.walkTree(self.env[node[1]])
|
||||
except LookupError:
|
||||
print("Undefined function '%s'" % node[1])
|
||||
return 0
|
||||
|
||||
if node[0] == 'add':
|
||||
return self.walkTree(node[1]) + self.walkTree(node[2])
|
||||
elif node[0] == 'sub':
|
||||
return self.walkTree(node[1]) - self.walkTree(node[2])
|
||||
elif node[0] == 'mul':
|
||||
return self.walkTree(node[1]) * self.walkTree(node[2])
|
||||
elif node[0] == 'div':
|
||||
return self.walkTree(node[1]) / self.walkTree(node[2])
|
||||
|
||||
if node[0] == 'var_assign':
|
||||
self.env[node[1]] = self.walkTree(node[2])
|
||||
return node[1]
|
||||
|
||||
if node[0] == 'var':
|
||||
try:
|
||||
return self.env[node[1]]
|
||||
except LookupError:
|
||||
print("Undefined variable '" + node[1] + "' found!")
|
||||
return 0
|
||||
|
||||
if node[0] == 'for_loop':
|
||||
if node[1][0] == 'for_loop_setup':
|
||||
loop_setup = self.walkTree(node[1])
|
||||
|
||||
loop_count = self.env[loop_setup[0]]
|
||||
loop_limit = loop_setup[1]
|
||||
|
||||
for i in range(loop_count + 1, loop_limit + 1):
|
||||
res = self.walkTree(node[2])
|
||||
if res is not None:
|
||||
print(res)
|
||||
self.env[loop_setup[0]] = i
|
||||
del self.env[loop_setup[0]]
|
||||
|
||||
if node[0] == 'for_loop_setup':
|
||||
return (self.walkTree(node[1]), self.walkTree(node[2]))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
lexer = BasicLexer()
|
||||
parser = BasicParser()
|
||||
env = {}
|
||||
while True:
|
||||
try:
|
||||
text = input('basic > ')
|
||||
except EOFError:
|
||||
break
|
||||
if text:
|
||||
tokens = lexer.tokenize(text)
|
||||
tree = parser.parse(tokens)
|
||||
for t in tree:
|
||||
print(t)
|
||||
# BasicExecute(tree, env)
|
||||
@ -1,22 +0,0 @@
|
||||
# hi1
|
||||
// hi2
|
||||
|
||||
public lib Main {
|
||||
class Program {
|
||||
var test: bool = false;
|
||||
var test2: Program2 = empty;
|
||||
var test3: Program2 = Test(34);
|
||||
|
||||
func Main(): empty {
|
||||
#func Main {
|
||||
var hallo: any;
|
||||
#output('Hello');
|
||||
#output(this.isTrue(false));
|
||||
}
|
||||
|
||||
func isTrue(value: bool): bool {
|
||||
#func isTrue {
|
||||
#return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,57 +0,0 @@
|
||||
from typing import Optional
|
||||
|
||||
from Interpreter.Validator import Validator
|
||||
from Interpreter.Lexer import Lexer
|
||||
from Interpreter.Parser import Parser
|
||||
from Interpreter.Repo import Repo
|
||||
from Interpreter.Utils import Utils
|
||||
from Models.AbstractSyntaxTree.AbstractSyntaxTree import AbstractSyntaxTree
|
||||
|
||||
|
||||
class Interpreter:
|
||||
|
||||
def __init__(self, repo: Repo, utils: Utils) -> None:
|
||||
self.__repo = repo
|
||||
self.__utils = utils
|
||||
self.__lexer = Lexer(repo, utils)
|
||||
self.__parser = Parser(repo, utils)
|
||||
self.__validator = Validator(repo, utils)
|
||||
|
||||
def interpret(self, line_str: str) -> None:
|
||||
"""
|
||||
Interprets code line
|
||||
:param line_str:
|
||||
:return:
|
||||
"""
|
||||
tokens = []
|
||||
ast: Optional[AbstractSyntaxTree] = None
|
||||
|
||||
if self.__repo.error is None:
|
||||
tokens = self.__lexer.tokenize(line_str)
|
||||
|
||||
if self.__repo.error is None:
|
||||
ast = self.__parser.parse(tokens)
|
||||
|
||||
""" print('#####\n')
|
||||
if ast is not None:
|
||||
for lib in ast.libraries:
|
||||
print('lib', lib.name)
|
||||
for cl in lib.classes:
|
||||
print('class', cl.name)
|
||||
for var in cl.variables:
|
||||
print('cl var', var.name)
|
||||
|
||||
for func in cl.functions:
|
||||
print('func', func.name)
|
||||
for arg in func.args:
|
||||
print('func arg', arg.name)
|
||||
|
||||
for var in func.variables:
|
||||
print('func var', var.name)
|
||||
|
||||
for ins in func.instructions:
|
||||
print('ins', ins)
|
||||
"""
|
||||
|
||||
# if self.__repo.is_error is None:
|
||||
# self.__validator.validate(self.__repo.AST)
|
||||
@ -1,171 +0,0 @@
|
||||
from typing import List
|
||||
|
||||
from Interpreter.Repo import Repo
|
||||
from Interpreter.Utils import Utils
|
||||
from Models.Token.Token import Token
|
||||
from Models.Token.TokenTypes import TokenTypes, UnresolvedTokenTypes
|
||||
|
||||
|
||||
class Lexer:
|
||||
|
||||
def __init__(self, repo: Repo, utils: Utils) -> None:
|
||||
self.__repo = repo
|
||||
self.__utils = utils
|
||||
|
||||
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 input_token_type:
|
||||
:return:
|
||||
"""
|
||||
token_type: TokenTypes = TokenTypes.Empty
|
||||
|
||||
if value != '':
|
||||
if input_token_type == UnresolvedTokenTypes.Word:
|
||||
if value in self.__repo.keywords:
|
||||
token_type = TokenTypes.Keyword
|
||||
|
||||
elif value in self.__repo.datatypes:
|
||||
token_type = TokenTypes.Type
|
||||
|
||||
elif value in self.__repo.bool_values:
|
||||
token_type = TokenTypes.Bool
|
||||
|
||||
elif value == UnresolvedTokenTypes.Empty:
|
||||
token_type = TokenTypes.Empty
|
||||
|
||||
else:
|
||||
token_type = TokenTypes.Name
|
||||
|
||||
elif input_token_type == UnresolvedTokenTypes.Number:
|
||||
token_type = TokenTypes.Number
|
||||
|
||||
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'
|
||||
is_string2 = False # "hello"
|
||||
is_number = False
|
||||
is_expr_char = False
|
||||
|
||||
for i in range(0, len(line)):
|
||||
c = line[i]
|
||||
# ignore comments and spaces
|
||||
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 == '/':
|
||||
ol_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(tokens, word, UnresolvedTokenTypes.Number)
|
||||
local_tokens = self.tokenize(c)
|
||||
for local_token in local_tokens:
|
||||
tokens.append(local_token)
|
||||
|
||||
word = ''
|
||||
is_number = False
|
||||
|
||||
# end of expression char
|
||||
elif c not in self.__repo.expr_chars and is_expr_char:
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Expression_Character)
|
||||
word = ''
|
||||
is_expr_char = False
|
||||
|
||||
# begin of is_string1
|
||||
elif c == '\'' and not is_string1:
|
||||
is_string1 = True
|
||||
word = ''
|
||||
|
||||
# end of is_string1
|
||||
elif c == '\'' and is_string1:
|
||||
is_string1 = False
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.String)
|
||||
word = ''
|
||||
|
||||
# begin of is_string2
|
||||
elif c == '\"' and not is_string2:
|
||||
is_string2 = True
|
||||
word = ''
|
||||
|
||||
# end of is_string2
|
||||
elif c == '\"' and is_string2:
|
||||
is_string2 = False
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.String)
|
||||
word = ''
|
||||
|
||||
# format char
|
||||
elif c in self.__repo.format_chars:
|
||||
self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
|
||||
self.__add_tok(tokens, c, UnresolvedTokenTypes.Format_Character)
|
||||
word = ''
|
||||
|
||||
# begin of number
|
||||
elif c.isdigit() and not is_number and word == '':
|
||||
word += c
|
||||
is_number = True
|
||||
|
||||
# continue number
|
||||
elif (c.isdigit() or c == '.') and is_number:
|
||||
word += c
|
||||
|
||||
# begin expression char
|
||||
elif c in self.__repo.expr_chars and not is_expr_char:
|
||||
word += c
|
||||
is_expr_char = True
|
||||
|
||||
# continue expression char
|
||||
elif c in self.__repo.expr_chars and is_expr_char:
|
||||
word += c
|
||||
|
||||
# bool expression char
|
||||
elif c in self.__repo.bool_expr_chars:
|
||||
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(tokens, word, UnresolvedTokenTypes.Word)
|
||||
word = ''
|
||||
|
||||
else:
|
||||
word += c
|
||||
|
||||
if c == '\n' and ol_comment:
|
||||
ol_comment = False
|
||||
|
||||
if line[i - 1] == '*' and c == '/':
|
||||
self.__is_ml_comment = False
|
||||
|
||||
return tokens
|
||||
@ -1,415 +0,0 @@
|
||||
from typing import List, Optional, Union
|
||||
|
||||
from Interpreter.Repo import Repo
|
||||
from Interpreter.Utils import Utils
|
||||
from Models.AbstractSyntaxTree.AbstractSyntaxTree import LibraryDefinitionNode, ClassDefinitionNode, AbstractSyntaxTree, \
|
||||
FunctionDefinitionNode, VariableDefinitionNode, CallDefinitionNode, ValueNode, ASTElement
|
||||
from Models.Interpreter.Datatypes import Datatypes
|
||||
from Models.Interpreter.Error import Error, ErrorCodes
|
||||
from Models.Token.Token import Token
|
||||
from Models.Token.TokenTypes import TokenTypes
|
||||
from Models.Token.TokenValueTypes import Keywords, FormatCharacters, ExpressionCharacters
|
||||
|
||||
|
||||
class Parser:
|
||||
|
||||
def __init__(self, repo: Repo, utils: Utils) -> None:
|
||||
self.__repo = repo
|
||||
self.__utils = utils
|
||||
|
||||
self.__ast: AbstractSyntaxTree = AbstractSyntaxTree()
|
||||
self.__saved_tokens: List[Token] = []
|
||||
self.__expected_tokens: List[Token] = []
|
||||
|
||||
# for validation if type is created
|
||||
self.__is_saving_type = False
|
||||
self.__is_saving_value = False
|
||||
self.__is_saving_call = False
|
||||
self.__is_end = False
|
||||
|
||||
self.__saved_ast_elements: List[ASTElement] = []
|
||||
|
||||
def parse(self, tokens: List[Token]) -> AbstractSyntaxTree:
|
||||
self.__is_end = False
|
||||
|
||||
if len(tokens) > 0:
|
||||
toks = []
|
||||
for tok in tokens:
|
||||
toks.append({tok.type.name, tok.value})
|
||||
|
||||
print(self.__repo.line_number, toks)
|
||||
|
||||
for i in range(0, len(tokens)):
|
||||
token = tokens[i]
|
||||
|
||||
self.__check_for_expected_tokens(token)
|
||||
|
||||
# keywords
|
||||
if token.type == TokenTypes.Keyword:
|
||||
if token.value == Keywords.Public.value:
|
||||
self.__saved_tokens.append(token)
|
||||
print('save public')
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Library.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Class.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Function.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Variable.value)
|
||||
|
||||
elif token.value == Keywords.Library.value:
|
||||
self.__saved_tokens.append(token)
|
||||
print('save lib')
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
|
||||
elif token.value == Keywords.Class.value:
|
||||
self.__saved_tokens.append(token)
|
||||
print('save class')
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
|
||||
elif token.value == Keywords.Function.value:
|
||||
self.__saved_tokens.append(token)
|
||||
print('save function')
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
|
||||
elif token.value == Keywords.Variable.value:
|
||||
self.__saved_tokens.append(token)
|
||||
print('save var')
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
|
||||
# names
|
||||
elif token.type == TokenTypes.Name:
|
||||
if self.__is_saving_variable() and self.__is_saving_value:
|
||||
self.__save_name(token)
|
||||
if self.__is_saving_variable():
|
||||
self.__is_saving_call = True
|
||||
|
||||
# names could be variable types, validation check in evaluator
|
||||
elif self.__is_saving_variable() and self.__is_saving_type:
|
||||
self.__save_type(token)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
|
||||
|
||||
elif self.__is_saving_variable():
|
||||
self.__save_name(token)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Colon.value)
|
||||
|
||||
elif self.__is_saving_function():
|
||||
self.__save_name(token)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
|
||||
|
||||
elif self.__is_saving_library() or self.__is_saving_class():
|
||||
self.__save_name(token)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Brace.value)
|
||||
|
||||
# format chars
|
||||
elif token.type == TokenTypes.Format_Character:
|
||||
if token.value == FormatCharacters.Left_Brace.value:
|
||||
if self.__is_saving_library():
|
||||
self.__save_library()
|
||||
|
||||
elif self.__is_saving_class():
|
||||
self.__save_class()
|
||||
|
||||
elif token.value == FormatCharacters.Colon.value:
|
||||
if self.__is_saving_variable():
|
||||
self.__is_saving_type = True
|
||||
self.__add_expected_token(TokenTypes.Type)
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
|
||||
elif token.value == FormatCharacters.Semicolon.value:
|
||||
self.__end_line()
|
||||
|
||||
elif token.value == FormatCharacters.Left_Parenthesis.value:
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Right_Parenthesis.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.This.value)
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
self.__add_expected_token(TokenTypes.Empty)
|
||||
self.__add_expected_token(TokenTypes.Number)
|
||||
self.__add_expected_token(TokenTypes.String)
|
||||
self.__add_expected_token(TokenTypes.Bool)
|
||||
|
||||
if self.__is_saving_call:
|
||||
self.__saved_tokens.append(token)
|
||||
|
||||
elif token.value == FormatCharacters.Right_Parenthesis.value:
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Colon.value)
|
||||
|
||||
if self.__is_saving_call:
|
||||
self.__saved_tokens.append(token)
|
||||
self.__save_call()
|
||||
self.__is_saving_call = False
|
||||
|
||||
# expr chars
|
||||
elif token.type == TokenTypes.Expression_Character:
|
||||
if token.value == ExpressionCharacters.Equal.value:
|
||||
self.__is_saving_value = True
|
||||
self.__add_expected_token(TokenTypes.Bool)
|
||||
self.__add_expected_token(TokenTypes.Number)
|
||||
self.__add_expected_token(TokenTypes.String)
|
||||
self.__add_expected_token(TokenTypes.Empty)
|
||||
self.__add_expected_token(TokenTypes.Name)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.This.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Input.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Range.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Length.value)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
|
||||
self.__add_expected_token(TokenTypes.Type, Datatypes.Empty.value)
|
||||
|
||||
# types
|
||||
elif token.type == TokenTypes.Type:
|
||||
if self.__is_saving_variable() and self.__is_saving_value:
|
||||
self.__save_value(token)
|
||||
|
||||
elif self.__is_saving_variable():
|
||||
self.__save_type(token)
|
||||
|
||||
# values
|
||||
elif token.type == TokenTypes.Bool or token.type == TokenTypes.Number or token.type == TokenTypes.String:
|
||||
if self.__is_saving_call:
|
||||
self.__saved_tokens.append(token)
|
||||
|
||||
elif self.__is_saving_value:
|
||||
self.__save_value(token)
|
||||
|
||||
return self.__ast
|
||||
|
||||
"""
|
||||
Utils
|
||||
"""
|
||||
|
||||
def __save_name(self, token: Token):
|
||||
self.__saved_tokens.append(token)
|
||||
print('save name')
|
||||
|
||||
def __add_expected_token(self, token_type: TokenTypes, value: str = ''):
|
||||
self.__expected_tokens.append(Token(token_type, value))
|
||||
|
||||
def __check_for_expected_tokens(self, token: Token):
|
||||
error_token: Optional[Token] = None
|
||||
is_error = True
|
||||
|
||||
for expected_token in self.__expected_tokens:
|
||||
if self.__is_end or token.type != expected_token.type or expected_token.value != '' and token.value != expected_token.value:
|
||||
error_token = token
|
||||
else:
|
||||
is_error = False
|
||||
|
||||
if error_token is not None and is_error:
|
||||
self.__utils.error(Error(ErrorCodes.Unexpected, f'{error_token.type.name} {error_token.value}'))
|
||||
|
||||
self.__expected_tokens = []
|
||||
|
||||
def __end_line(self):
|
||||
if self.__is_saving_variable():
|
||||
self.__save_variable()
|
||||
|
||||
self.__is_end = True
|
||||
self.__expected_tokens = []
|
||||
self.__is_saving_type = False
|
||||
self.__is_saving_value = False
|
||||
|
||||
"""
|
||||
Library
|
||||
"""
|
||||
|
||||
def __is_saving_library(self) -> bool:
|
||||
found = False
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Keyword and token.value == Keywords.Library.value:
|
||||
found = True
|
||||
|
||||
return found
|
||||
|
||||
def __save_library(self) -> None:
|
||||
is_public = False
|
||||
name_token: Optional[Token] = None
|
||||
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Name:
|
||||
name_token = token
|
||||
elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
|
||||
is_public = True
|
||||
|
||||
if name_token is not None:
|
||||
self.__ast.libraries.append(LibraryDefinitionNode(is_public, name_token.value))
|
||||
self.__saved_tokens = []
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Public.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Class.value)
|
||||
print('saved library')
|
||||
|
||||
"""
|
||||
Class
|
||||
"""
|
||||
|
||||
def __is_saving_class(self) -> bool:
|
||||
found = False
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Keyword and token.value == Keywords.Class.value:
|
||||
found = True
|
||||
|
||||
return found
|
||||
|
||||
def __save_class(self) -> None:
|
||||
is_public = False
|
||||
name_token: Optional[Token] = None
|
||||
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Name:
|
||||
name_token = token
|
||||
elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
|
||||
is_public = True
|
||||
|
||||
if name_token is not None:
|
||||
self.__ast.libraries[len(self.__ast.libraries) - 1].classes.append(ClassDefinitionNode(is_public, name_token.value))
|
||||
self.__saved_tokens = []
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Public.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Variable.value)
|
||||
self.__add_expected_token(TokenTypes.Keyword, Keywords.Function.value)
|
||||
print('saved class')
|
||||
|
||||
"""
|
||||
Call
|
||||
"""
|
||||
def __save_call(self) -> None:
|
||||
name_token: Optional[Token] = None
|
||||
args: List[ValueNode] = []
|
||||
remove_tokens = []
|
||||
is_call = False
|
||||
|
||||
for i in range(0, len(self.__saved_tokens)):
|
||||
token = self.__saved_tokens[i]
|
||||
last_token: Optional[Token] = None
|
||||
if i-1 > 0:
|
||||
last_token = self.__saved_tokens[i-1]
|
||||
|
||||
if token.type == TokenTypes.Name and last_token is not None and last_token.type == TokenTypes.Format_Character and last_token.value == FormatCharacters.Left_Parenthesis.value:
|
||||
pass
|
||||
|
||||
if token.type == TokenTypes.Format_Character and token.value == FormatCharacters.Left_Parenthesis.value and last_token is not None and last_token.type == TokenTypes.Name:
|
||||
name_token = last_token
|
||||
remove_tokens.append(last_token)
|
||||
remove_tokens.append(token)
|
||||
is_call = True
|
||||
elif is_call and token.type == TokenTypes.Format_Character and token.value == FormatCharacters.Right_Parenthesis.value:
|
||||
remove_tokens.append(token)
|
||||
elif is_call and token.type == TokenTypes.Bool or token.type == TokenTypes.Number or token.type == TokenTypes.String:
|
||||
args.append(ValueNode(token.value, Datatypes[token.type.name]))
|
||||
remove_tokens.append(token)
|
||||
|
||||
if name_token is not None:
|
||||
call = CallDefinitionNode(name_token.value)
|
||||
call.args = args
|
||||
self.__saved_ast_elements.append(call)
|
||||
|
||||
for token in remove_tokens:
|
||||
self.__saved_tokens.remove(token)
|
||||
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
|
||||
print('saved call')
|
||||
|
||||
"""
|
||||
Function
|
||||
"""
|
||||
|
||||
def __is_saving_function(self) -> bool:
|
||||
found = False
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Keyword and token.value == Keywords.Function.value:
|
||||
found = True
|
||||
|
||||
return found
|
||||
|
||||
def __save_function(self) -> None:
|
||||
is_public = False
|
||||
name_token: Optional[Token] = None
|
||||
return_type: Optional[Token] = None
|
||||
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Name:
|
||||
name_token = token
|
||||
elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
|
||||
is_public = True
|
||||
elif token.type == TokenTypes.Type:
|
||||
return_type = token
|
||||
|
||||
if name_token is not None and return_type is not None:
|
||||
self.__ast.libraries[len(self.__ast.libraries) - 1].classes[len(self.__ast.libraries) - 1].functions.append(
|
||||
FunctionDefinitionNode(is_public, name_token.value, Datatypes[return_type.value]))
|
||||
self.__saved_tokens = []
|
||||
print('saved function')
|
||||
|
||||
"""
|
||||
Variable
|
||||
"""
|
||||
|
||||
def __is_saving_variable(self) -> bool:
|
||||
found = False
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Keyword and token.value == Keywords.Variable.value:
|
||||
found = True
|
||||
|
||||
return found
|
||||
|
||||
def __save_type(self, token: Token) -> None:
|
||||
self.__saved_tokens.append(token)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
|
||||
self.__add_expected_token(TokenTypes.Expression_Character, ExpressionCharacters.Equal.value)
|
||||
self.__is_saving_type = False
|
||||
print('save type')
|
||||
|
||||
def __save_variable(self):
|
||||
is_public = False
|
||||
name_token: Optional[Token] = None
|
||||
datatype: Optional[Token] = None
|
||||
value: Optional[Union[str, Token, CallDefinitionNode]] = None
|
||||
|
||||
reset_saved_ast = False
|
||||
|
||||
for token in self.__saved_tokens:
|
||||
if token.type == TokenTypes.Name and name_token is None:
|
||||
name_token = token
|
||||
elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
|
||||
is_public = True
|
||||
elif token.type == TokenTypes.Type or name_token is not None and token.type == TokenTypes.Name:
|
||||
datatype = token
|
||||
|
||||
value = Token(TokenTypes.Empty, TokenTypes.Empty.value)
|
||||
|
||||
for saved_ast_element in self.__saved_ast_elements:
|
||||
if isinstance(saved_ast_element, CallDefinitionNode):
|
||||
value = saved_ast_element
|
||||
reset_saved_ast = True
|
||||
|
||||
if reset_saved_ast:
|
||||
self.__saved_ast_elements = []
|
||||
|
||||
if name_token is not None and datatype is not None and value is not None:
|
||||
if not isinstance(value, CallDefinitionNode):
|
||||
value = value.value
|
||||
|
||||
if datatype.type == TokenTypes.Name:
|
||||
variable = VariableDefinitionNode(is_public, name_token.value, datatype.value, value)
|
||||
else:
|
||||
variable = VariableDefinitionNode(is_public, name_token.value, Datatypes[str(datatype.value).capitalize()], value)
|
||||
|
||||
if len(self.__ast.libraries) > 0:
|
||||
lib = self.__ast.libraries[len(self.__ast.libraries) - 1]
|
||||
if len(lib.classes) > 0:
|
||||
cl = lib.classes[len(lib.classes) - 1]
|
||||
if len(cl.functions) == 0:
|
||||
cl.variables.append(variable)
|
||||
else:
|
||||
cl.functions[len(cl.functions) - 1].variables.append(variable)
|
||||
|
||||
self.__saved_tokens = []
|
||||
print('saved variable')
|
||||
|
||||
"""
|
||||
Value
|
||||
"""
|
||||
|
||||
def __save_value(self, token: Token):
|
||||
self.__saved_tokens.append(token)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
|
||||
self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
|
||||
self.__is_saving_value = False
|
||||
print('save value')
|
||||
@ -1,73 +0,0 @@
|
||||
from Models.Interpreter.Datatypes import Datatypes
|
||||
from Models.Token.TokenValueTypes import FormatCharacters, Booleans, Keywords, ExpressionCharacters
|
||||
|
||||
|
||||
class Repo:
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.debug = True
|
||||
self.line_number: int = 0
|
||||
|
||||
# interpreter
|
||||
self.keywords = [
|
||||
# define keywords
|
||||
Keywords.Library.value,
|
||||
Keywords.Class.value,
|
||||
Keywords.Function.value,
|
||||
Keywords.Variable.value,
|
||||
Keywords.Use.value,
|
||||
Keywords.From.value,
|
||||
# builtin functions
|
||||
Keywords.Output.value,
|
||||
Keywords.Input.value,
|
||||
Keywords.Length.value,
|
||||
Keywords.Range.value,
|
||||
Keywords.Exit.value,
|
||||
# normal keywords
|
||||
Keywords.If.value,
|
||||
Keywords.ElseIf.value,
|
||||
Keywords.Else.value,
|
||||
Keywords.Continue.value,
|
||||
Keywords.If.value,
|
||||
Keywords.Return.value,
|
||||
# loops
|
||||
Keywords.While.value,
|
||||
Keywords.For.value,
|
||||
# access
|
||||
Keywords.Public.value,
|
||||
Keywords.This.value
|
||||
]
|
||||
self.datatypes = [
|
||||
Datatypes.Empty.value,
|
||||
Datatypes.Any.value,
|
||||
Datatypes.Number.value,
|
||||
Datatypes.String.value,
|
||||
Datatypes.Bool.value,
|
||||
Datatypes.List.value,
|
||||
Datatypes.Dict.value
|
||||
]
|
||||
self.format_chars = [
|
||||
FormatCharacters.Left_Brace.value,
|
||||
FormatCharacters.Right_Brace.value,
|
||||
FormatCharacters.Left_Parenthesis.value,
|
||||
FormatCharacters.Right_Parenthesis.value,
|
||||
FormatCharacters.Left_Bracket.value,
|
||||
FormatCharacters.Right_Bracket.value,
|
||||
FormatCharacters.Semicolon.value,
|
||||
FormatCharacters.Colon.value,
|
||||
FormatCharacters.Comma.value,
|
||||
FormatCharacters.Point.value
|
||||
]
|
||||
self.expr_chars = [
|
||||
ExpressionCharacters.Plus.value,
|
||||
ExpressionCharacters.Minus.value,
|
||||
ExpressionCharacters.Asterisk.value,
|
||||
ExpressionCharacters.Slash.value,
|
||||
ExpressionCharacters.Equal.value,
|
||||
ExpressionCharacters.Caret.value
|
||||
]
|
||||
self.bool_expr_chars = ['<', '>', '!', '!=', '==', '>=', '<=', '&&', '||']
|
||||
self.bool_values = [Booleans.Right.value, Booleans.Wrong.value]
|
||||
|
||||
# runtime
|
||||
self.error = None
|
||||
@ -1,26 +0,0 @@
|
||||
from termcolor import colored
|
||||
|
||||
from Interpreter.Repo import Repo
|
||||
from Models.Interpreter.Error import Error
|
||||
|
||||
|
||||
class Utils:
|
||||
|
||||
def __init__(self, repo: Repo) -> None:
|
||||
self.__repo = repo
|
||||
|
||||
def input(self, prefix: str) -> str:
|
||||
return input(prefix)
|
||||
|
||||
def output(self, text: str) -> None:
|
||||
print(f'-> {text}')
|
||||
|
||||
def error(self, error: Error) -> None:
|
||||
self.__repo.error = error
|
||||
print(colored(f'Error in line {self.__repo.line_number}\n{self.__repo.error.msg}', 'red'))
|
||||
# exit()
|
||||
|
||||
def runtime_error(self, error: Error) -> None:
|
||||
self.__repo.error = error
|
||||
print(colored(f'{self.__repo.error.msg}', 'red'))
|
||||
# exit()
|
||||
@ -1,12 +0,0 @@
|
||||
from Interpreter.Repo import Repo
|
||||
from Interpreter.Utils import Utils
|
||||
|
||||
|
||||
class Validator:
|
||||
|
||||
def __init__(self, repo: Repo, utils: Utils) -> None:
|
||||
self.__repo = repo
|
||||
self.__utils = utils
|
||||
|
||||
def validate(self, ast: []) -> None:
|
||||
pass
|
||||
@ -1,92 +0,0 @@
|
||||
from typing import List, Union
|
||||
|
||||
from Models.Interpreter.Datatypes import Datatypes
|
||||
from Models.Token.TokenValueTypes import ExpressionCharacters
|
||||
|
||||
|
||||
class AbstractSyntaxTree:
|
||||
|
||||
def __init__(self):
|
||||
self.libraries: List[LibraryDefinitionNode] = []
|
||||
|
||||
|
||||
class ASTElement:
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
|
||||
class ValueNode(ASTElement):
|
||||
def __init__(self, value: str, datatype: Datatypes):
|
||||
super().__init__()
|
||||
self.value = value
|
||||
self.type = datatype
|
||||
|
||||
|
||||
class BinaryOperationNode(ASTElement):
|
||||
def __init__(self, left: str, op_token: str, right: str):
|
||||
super().__init__()
|
||||
self.left = left
|
||||
self.op_token = op_token
|
||||
self.right = right
|
||||
|
||||
self.operation_chars = [
|
||||
ExpressionCharacters.Plus.value,
|
||||
ExpressionCharacters.Minus.value,
|
||||
ExpressionCharacters.Asterisk.value,
|
||||
ExpressionCharacters.Slash.value,
|
||||
ExpressionCharacters.Caret.value
|
||||
]
|
||||
|
||||
def eval(self):
|
||||
if self.op_token in self.operation_chars:
|
||||
return eval(f'{self.left} {self.op_token} {self.right}')
|
||||
|
||||
|
||||
class LibraryDefinitionNode(ASTElement):
|
||||
|
||||
def __init__(self, is_public: bool, name: str):
|
||||
super().__init__()
|
||||
self.is_public = is_public
|
||||
self.name = name
|
||||
self.classes: List[ClassDefinitionNode] = []
|
||||
|
||||
|
||||
class ClassDefinitionNode(ASTElement):
|
||||
|
||||
def __init__(self, is_public: bool, name: str):
|
||||
super().__init__()
|
||||
self.is_public = is_public
|
||||
self.name = name
|
||||
self.variables: [VariableDefinitionNode] = []
|
||||
self.functions: List[FunctionDefinitionNode] = []
|
||||
|
||||
|
||||
class CallDefinitionNode(ASTElement):
|
||||
|
||||
def __init__(self, name: str):
|
||||
super().__init__()
|
||||
self.name = name
|
||||
self.args: List[ValueNode] = []
|
||||
|
||||
|
||||
class FunctionDefinitionNode(ASTElement):
|
||||
|
||||
def __init__(self, is_public: bool, name: str, return_type: Datatypes):
|
||||
super().__init__()
|
||||
self.is_public = is_public
|
||||
self.name = name
|
||||
self.args: List[VariableDefinitionNode] = []
|
||||
self.return_type = return_type
|
||||
self.variables: [VariableDefinitionNode] = []
|
||||
self.instructions: List[ASTElement] = []
|
||||
|
||||
|
||||
class VariableDefinitionNode(ASTElement):
|
||||
|
||||
def __init__(self, is_public: bool, name: str, datatype: Union[str, Datatypes], value: Union[str, CallDefinitionNode]):
|
||||
super().__init__()
|
||||
self.is_public = is_public
|
||||
self.name = name
|
||||
self.datatype = datatype
|
||||
self.value = value
|
||||
@ -1,77 +0,0 @@
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class TokenDefinition(Enum):
|
||||
""" Keywords """
|
||||
# define keywords
|
||||
Library = r'lib'
|
||||
Class = r'class'
|
||||
Function = r'func'
|
||||
Variable = r'var'
|
||||
Use = r'use'
|
||||
From = r'from'
|
||||
As = r'as'
|
||||
|
||||
# builtin functions
|
||||
Output = r'output'
|
||||
Input = r'input'
|
||||
Length = r'length'
|
||||
Range = r'range'
|
||||
Round = r'round'
|
||||
Exit = r'exit'
|
||||
|
||||
# normal keywords
|
||||
If = r'if'
|
||||
ElseIf = r'elseif'
|
||||
Else = r'else'
|
||||
Continue = r'continue'
|
||||
Return = r'return'
|
||||
|
||||
# loops
|
||||
While = r'while'
|
||||
For = r'for'
|
||||
In = r'in'
|
||||
|
||||
# access
|
||||
Public = r'public'
|
||||
This = r'this'
|
||||
|
||||
""" Chars """
|
||||
# format
|
||||
LeftBrace = r'\{'
|
||||
RightBrace = r'\}'
|
||||
LeftParenthesis = r'\('
|
||||
RightParenthesis = r'\)'
|
||||
LeftBracket = r'\['
|
||||
RightBracket = r'\]'
|
||||
Semicolon = r'\;'
|
||||
Colon = r'\:'
|
||||
Comma = r'\,'
|
||||
Point = r'\.'
|
||||
# expr
|
||||
Plus = r'\+'
|
||||
Minus = r'\-'
|
||||
Asterisk = r'\*'
|
||||
Slash = r'\/'
|
||||
Equal = r'\='
|
||||
Caret = r'\^'
|
||||
|
||||
""" Values """
|
||||
ValueString = r'\".*?\"'
|
||||
ValueNumber = r'\d+'
|
||||
|
||||
# bool
|
||||
BoolTrue = r'true'
|
||||
BoolFalse = r'false'
|
||||
|
||||
""" Datatypes """
|
||||
Empty = r'empty'
|
||||
Number = r'Number'
|
||||
String = r'string'
|
||||
Bool = r'bool'
|
||||
List = r'list'
|
||||
Dict = r'dict'
|
||||
Void = r'void'
|
||||
|
||||
""" other """
|
||||
Name = r'[a-zA-Z_][a-zA-Z0-9_]*'
|
||||
@ -1,12 +0,0 @@
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class Datatypes(Enum):
|
||||
|
||||
Empty = 'empty'
|
||||
Any = 'any'
|
||||
Number = 'number'
|
||||
String = 'string'
|
||||
Bool = 'bool'
|
||||
List = 'list'
|
||||
Dict = 'dict'
|
||||
@ -1,28 +0,0 @@
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class ErrorCodes(Enum):
|
||||
StartFailed = 'Start failed'
|
||||
FileNotFound = 'File not found'
|
||||
WrongFileType = 'Wrong file type'
|
||||
|
||||
Unknown = 'Unknown {}'
|
||||
Inaccessible = '{} inaccessible'
|
||||
Unexpected = 'Unexpected {}'
|
||||
Expected = 'Expected {}'
|
||||
|
||||
LibInLib = 'Lib in lib'
|
||||
LibInClass = 'Lib in class'
|
||||
LibInFunc = 'Lib in func'
|
||||
ClassInClass = 'Class in class'
|
||||
ClassInFunc = 'Class in func'
|
||||
FuncInLib = 'Func in lib'
|
||||
FuncInFunc = 'Func in func'
|
||||
|
||||
|
||||
class Error:
|
||||
|
||||
def __init__(self, code: ErrorCodes, msg: str = '') -> None:
|
||||
self.code = code
|
||||
|
||||
self.msg = code.value.format(msg)
|
||||
@ -1,8 +0,0 @@
|
||||
from Models.Token import TokenTypes
|
||||
|
||||
|
||||
class Token:
|
||||
|
||||
def __init__(self, token_type: TokenTypes, value: str) -> None:
|
||||
self.type: TokenTypes = token_type
|
||||
self.value: str = value
|
||||
@ -1,24 +0,0 @@
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class TokenTypes(Enum):
|
||||
Empty = 0
|
||||
Keyword = 1
|
||||
Type = 2
|
||||
Name = 3
|
||||
Bool = 4
|
||||
String = 5
|
||||
Number = 6
|
||||
Expression_Character = 7
|
||||
Bool_Expression_Character = 8
|
||||
Format_Character = 9
|
||||
|
||||
|
||||
class UnresolvedTokenTypes(Enum):
|
||||
Empty = 0
|
||||
Word = 1
|
||||
Number = 2
|
||||
String = 3
|
||||
Expression_Character = 4
|
||||
Bool_Expression_Character = 5
|
||||
Format_Character = 6
|
||||
@ -1,62 +0,0 @@
|
||||
from enum import Enum
|
||||
|
||||
|
||||
class Keywords(Enum):
|
||||
# define keywords
|
||||
Library = 'lib'
|
||||
Class = 'class'
|
||||
Function = 'func'
|
||||
Variable = 'var'
|
||||
Use = 'use'
|
||||
From = 'from'
|
||||
|
||||
# builtin functions
|
||||
Output = 'output'
|
||||
Input = 'input'
|
||||
Length = 'length'
|
||||
Range = 'range'
|
||||
Exit = 'exit'
|
||||
|
||||
# normal keywords
|
||||
If = 'if'
|
||||
ElseIf = 'elseif'
|
||||
Else = 'else'
|
||||
Continue = 'continue'
|
||||
In = 'in'
|
||||
Return = 'return'
|
||||
|
||||
# loops
|
||||
While = 'while'
|
||||
For = 'for'
|
||||
|
||||
# access
|
||||
Public = 'public'
|
||||
This = 'this'
|
||||
|
||||
|
||||
class Booleans(Enum):
|
||||
Right = 'true'
|
||||
Wrong = 'false'
|
||||
|
||||
|
||||
class ExpressionCharacters(Enum):
|
||||
Plus = '+'
|
||||
Minus = '-'
|
||||
Asterisk = '*'
|
||||
Slash = '/'
|
||||
Equal = '='
|
||||
Caret = '^'
|
||||
|
||||
|
||||
class FormatCharacters(Enum):
|
||||
Left_Brace = '{'
|
||||
Right_Brace = '}'
|
||||
Left_Parenthesis = '('
|
||||
Right_Parenthesis = ')'
|
||||
Left_Bracket = '['
|
||||
Right_Bracket = ']'
|
||||
Semicolon = ';'
|
||||
Colon = ':'
|
||||
Comma = ','
|
||||
Point = '.'
|
||||
|
||||
@ -1,13 +0,0 @@
|
||||
from Interpreter.Interpreter import Interpreter
|
||||
# from CCLang_sly.Interpreter import Interpreter as SlyCCLangInterpreter
|
||||
from Interpreter.Utils import Utils
|
||||
from Interpreter.Repo import Repo
|
||||
|
||||
|
||||
class ServiceInitializer:
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.repo = Repo()
|
||||
self.utils = Utils(self.repo)
|
||||
self.interpreter = Interpreter(self.repo, self.utils)
|
||||
# self.sly_cclang_interpreter = SlyCCLangInterpreter(self.repo, self.utils)
|
||||
@ -1,53 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
|
||||
from Models.Interpreter.Error import Error, ErrorCodes
|
||||
from ServiceInitializer import ServiceInitializer
|
||||
|
||||
|
||||
class Main:
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.__services = ServiceInitializer()
|
||||
self.__utils = self.__services.utils
|
||||
self.__repo = self.__services.repo
|
||||
self.__interpreter = self.__services.interpreter
|
||||
|
||||
def console(self) -> None:
|
||||
"""
|
||||
Getting code from console input
|
||||
:return:
|
||||
"""
|
||||
i = 0
|
||||
while self.__repo.error is None:
|
||||
self.__repo.line_number = i + 1
|
||||
self.__interpreter.interpret(input('> '))
|
||||
i += 1
|
||||
|
||||
def files(self, file: str) -> None:
|
||||
"""
|
||||
Getting input from file
|
||||
:param file:
|
||||
:return:
|
||||
"""
|
||||
if not os.path.isfile(file):
|
||||
self.__utils.runtime_error(Error(ErrorCodes.FileNotFound))
|
||||
return
|
||||
|
||||
if not file.endswith('.ccl'):
|
||||
self.__utils.runtime_error(Error(ErrorCodes.WrongFileType))
|
||||
return
|
||||
|
||||
f = open(file, 'r', encoding='utf-8').readlines()
|
||||
for i in range(0, len(f)):
|
||||
self.__repo.line_number = i + 1
|
||||
self.__interpreter.interpret(f[i])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main = Main()
|
||||
print(sys.argv)
|
||||
if len(sys.argv) == 2:
|
||||
main.files(sys.argv[1])
|
||||
else:
|
||||
main.console()
|
||||
@ -1,27 +0,0 @@
|
||||
# olc test 1
|
||||
// olc test 2
|
||||
/* mlc Test 1 */
|
||||
/*
|
||||
mlc Test 2
|
||||
*/
|
||||
|
||||
|
||||
public lib Main {
|
||||
class Program {
|
||||
var test: bool = false;
|
||||
var test2: Program2 = empty;
|
||||
var test3: Program2 = Test(34);
|
||||
|
||||
func Main(): void {
|
||||
#func Main {
|
||||
var hallo: any;
|
||||
#output('Hello');
|
||||
#output(this.isTrue(false));
|
||||
}
|
||||
|
||||
func isTrue(value: bool): bool {
|
||||
#func isTrue {
|
||||
#return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,3 +0,0 @@
|
||||
test = 3 ** 2
|
||||
print(test)
|
||||
print(eval('3**2'))
|
||||
Loading…
Reference in New Issue
Block a user