def program(self):
"""
Program -> int main '(' ')' '{' Declarations Statements '}'
:return: An ast.Program object
:raise CliteSyntaxError if an unexpected token is seen
"""
# Indicates the level of indentation
level = 1
self.match_main()
self.decls = self.declarations()
# Create a program object with declarations and a level
program = ast.Program(self.decls, level)
# Process statements and add them to the program object
self.stmts = self.statements(level)
program.add_statements(self.stmts)
# Match final closing brace
if self.curr_tok[self.CODE] != tokens.SINGLE_TOKENS[tokens.RBRACE][self.CODE]:
raise errors.CliteSyntaxError("Missing final closing brace '}'!",
self.curr_tok[self.LINE])
# Consume closing brace
self.curr_tok = self.lex.__next__()
return program
def parse(self, source):
self.source = source
tree = ast.Program([])
while True:
tree.append(self.parse_expr())
self.skip_indent()
return tree
def p_program(p):
'''program : program vardecl ';'
| program funcdecl
| vardecl ';'
| funcdecl '''
if len(p) == 2:
p[0] = ast.Program().addloc(p.lineno(1))
p[0].addfunc(p[1])
elif len(p) == 3 and not isinstance(p[1], ast.Program):
p[0] = ast.Program().addloc(p.lineno(1))
p[0].addvar(p[1])
elif len(p) == 3 and isinstance(p[1], ast.Program):
p[0] = p[1]
p[0].addfunc(p[2])
elif len(p) == 4:
p[0] = p[1]
p[0].addvar(p[2])
def program(self):
"""
Program ⇒ int main ( ) { Declarations Statements }
:return:
"""
# Check if the current token is a keyword Int
if self.currtok[0] == lexer.Lexer.KWDINT:
self.currtok = next(self.tokens)
# Check if the current token is "main"
if self.currtok[0] == lexer.Lexer.MAIN:
self.currtok = next(self.tokens)
# Check if the current token is an open parenthesis
if self.currtok[0] == lexer.Lexer.OPENP:
self.currtok = next(self.tokens)
# Check if the current token is a closed parenthesis
if self.currtok[0] == lexer.Lexer.CLOSEDP:
self.currtok = next(self.tokens)
# Check if the current token is an open bracket
if self.currtok[0] == lexer.Lexer.OPENB:
self.currtok = next(self.tokens)
# Run the declation and statements methods on
# the entire program
decls = self.declarations()
stmts = self.statements()
# Check if the current token is a closed bracket
if self.currtok[0] == lexer.Lexer.CLOSEDB:
return ast.Program(decls, stmts)
# Closed bracket not found, throw syntax error
else:
raise CliteSyntaxError("Expected curly bracket on line " + self.currtok[2])
# Open bracket not found, throw syntax error
else:
raise CliteSyntaxError("Expected curly bracket on line " + self.currtok[2])
# Closed parenthesis not found, throw syntax error
else:
raise CliteSyntaxError("Expected Parenthesis on line " + self.currtok[2])
# Open parenthesis not found, throw syntax error
else:
raise CliteSyntaxError("Expected Parenthesis on line " + self.currtok[2])
# "main" not found, throw syntax error
else:
raise CliteSyntaxError("Expected main on line " + self.currtok[2])
# keyword int not found, throw syntax error
else:
raise CliteSyntaxError("Expected int on line " + self.currtok[2])
def ParseProgram(self):
program = ast.Program(None)
program.Statements = list()
while self.curToken.Type != tokens.EOF:
stmt = self.parseStatement()
if stmt:
program.Statements.append(stmt)
self.nextToken()
return program
def parse_program(self):
prog = ast.Program([])
while not self.cur_is(token.EOF):
stmt = self.parse_stmt()
if stmt != None:
prog.statements.append(stmt)
self.next()
return prog
def TestString(self):
program = ast.Program()
program.Statements = [
ast.LetStatement(
tkn.Token(tkn.LET, "let"),
ast.Identifier(tkn.Token(tkn.IDENT, "myVar"), "myVar"),
ast.Identifier(tkn.Token(tkn.IDENT, "anotherVar"),
"anotherVar"))
]
if program.String() != "let myVar = anotherVar":
raise Exception(f'program.String() wrong got={program.String()}')
def ParseProgram(self):
program = ast.Program()
program.Statements = []
while self.currToken.TokenType != tkn.EOF:
statement = self.ParseStatement()
if statement is not None:
program.Statements.append(statement)
self.nextToken()
return program
def __init__(self, filename):
# Create a lexer object.
lex = lexer.Lexer()
# Create a token generator from the Lexer object.
self.tokens = lex.token_generator(filename)
# Initialize the current token.
# This is the first token of the program.
self.currToken = next(self.tokens)
# Create a Program object into which we add declarations and statements.
self.parseTree = ast.Program()
def TestString():
program = ast.Program(Statements=[
ast.LetStatement(
Token=_token.Token(Type=_token.tokens.LET, Literal="let"),
Name=ast.Identifier(Token=_token.Token(Type=_token.tokens.IDENT,
Literal="myVar"),
Value="myVar"),
Value=ast.Identifier(Token=_token.Token(Type=_token.tokens.IDENT,
Literal="anotherVar"),
Value="anotherVar"))
])
if program.String() == "let myVar = anotherVar;":
print("TestString test is success")
def program(self):
"""program : PROGRAM variable SEMI block DOT
"""
self.eat(TokenType.PROGRAM)
# get the program name
var_node = self.variable()
program_name = var_node.value
# ;
self.eat(TokenType.SEMI)
# block
block_node = self.block()
program_node = ast.Program(program_name, block_node)
# .
self.eat(TokenType.DOT)
return program_node
def checkprogram_uncaught(self,
main_unit: ast.TranslationUnit) -> ast.Program:
# DEBUG
#print("Global symbols:", main_unit.symbols_global)
#print(main_unit.symbol_tree)
#print(main_unit)
# Theoretically, everything is accessible via this chain:
# self.program.main_unit.symbols_global
# Anyways, for convenience, we make everything accessible here.
self.main_unit = main_unit
self.symbols_global = main_unit.symbols_global
program = ast.Program(self.modules, main_unit)
# Resolve module imports first
self.parse_imports(main_unit)
# Then resolve types
self.resolve_types(main_unit)
for unit in self.modules.values():
self.symbols_global = unit.symbols_global
self.resolve_types(unit)
# Resolve function interfaces
self.symbols_global = main_unit.symbols_global
self.resolve_function_interfaces(main_unit)
for unit in self.modules.values():
self.symbols_global = unit.symbols_global
self.resolve_function_interfaces(unit)
# Typecheck the rest (also assigning variable types)
# Functions in modules
for unit in self.modules.values():
self.symbols_global = unit.symbols_global
for func in unit.function_definitions.values():
res, turn = self.check(func)
# Functions in main_module / main_unit
self.symbols_global = main_unit.symbols_global
for func in main_unit.function_definitions.values():
res, turn = self.check(func)
# Statements in main_module / main_unit
for stmt in main_unit.statements:
res, turn = self.check(stmt)
# If there is a possible return value,
if turn != Return.NO:
# ensure it is an int
expect = bongtypes.TypeList([bongtypes.Integer()])
if not res.sametype(expect):
raise TypecheckException(
"Return type of program does not evaluate to int.",
stmt)
return program
def parse_program(self):
self.indentator.indent('Parsing Program')
declarations = self.parse_declarations()
self.expect('MAIN')
stats = self.parse_statements()
self.indentator.dedent()
AST_Root = ast.Program(declarations, stats)
if (self.errors == 1):
print('WARNING: 1 error found!')
elif (self.errors > 1):
print('WARNING: ' + str(self.errors) + ' errors found!')
else:
print('parser: syntax analysis successful!')
return AST_Root
def ParseProgram(self):
program = ast.Program()
program.Statements = []
#self.curToken.printout()
print("ParseProgram()1: ", self.curToken.Type)
while self.curToken.Type != token.EOF:
stmt = self.parseStatement()
print("ParseProgram()2: ", stmt)
if stmt != None:
program.Statements.append(stmt)
self.nextToken()
print("ParseProgram()3: ", program)
return program
def program(self):
# match int main ( ) {
if self.curr_tok[0] != lexer.Lexer.INT:
print("'int' expected: found", self.curr_tok[1], "on line",
self.curr_tok[2])
sys.exit(1)
self.curr_tok = next(self.lex)
if self.curr_tok[0] != lexer.Lexer.MAIN:
print("'main' expected: found", self.curr_tok[1], "on line",
self.curr_tok[2])
sys.exit(1)
self.curr_tok = next(self.lex)
if self.curr_tok[0] != lexer.Lexer.LPAREN:
print("'(' expected: found", self.curr_tok[1], "on line",
self.curr_tok[2])
sys.exit(1)
self.curr_tok = next(self.lex)
if self.curr_tok[0] != lexer.Lexer.RPAREN:
print("')' expected: found", self.curr_tok[1], "on line",
self.curr_tok[2])
sys.exit(1)
self.curr_tok = next(self.lex)
if self.curr_tok[0] != lexer.Lexer.LCBRACK:
print("'{' expected: found", self.curr_tok[1], "on line",
self.curr_tok[2])
sys.exit(1)
self.curr_tok = next(self.lex)
self.decls = self.declarations()
self.stmts = self.statements()
if self.curr_tok[0] != lexer.Lexer.RCBRACK:
print("'}' expected: found", self.curr_tok[1], "on line",
self.curr_tok[2])
sys.exit(1)
self.curr_tok = next(self.lex)
return ast.Program(self.decls, self.stmts)
def parse_program(self):
statements = []
while not isinstance(self.current, tokens.EOF):
if isinstance(self.current, tokens.SEMICOLON):
self.step()
continue
if isinstance(self.current, tokens.LET):
stmt = self.parse_let()
elif isinstance(self.current, tokens.FUNC):
stmt = self.parse_function_literal()
elif isinstance(self.current, tokens.RETURN):
stmt = self.parse_return()
elif isinstance(self.current, tokens.IF):
stmt = self.parse_conditional()
elif isinstance(self.current, tokens.LBRACE):
stmt = self.parse_block()
else:
stmt = self.parse_expr()
statements.append(stmt)
return ast.Program(statements)
def parse_program(self) -> ast.Program:
stmts = []
while not self._current_token_is(TokenType.EOF):
stmt = self._parse_statement()
# Many _parse_x() return null which bubbles up the call stack to
# here where null enables continued parsing on error. The
# alternative would be for _parse_x() to immediately stop parsing
# and signal a parser error. But that wouldn't allow collecting
# multiple errors to improve the user experience. Instead parsing
# would halt on the first error. As an example, _expect_peek()
# returns null if the expected token isn't found _and_ adds an error
# message to the _errors list. That null bubbles up to
# _parse_statement() which skips adding the statement to the AST and
# moves on the next statement. Evaluation of the AST shouldn't be
# attempted in case of parser errors as the faulting parts of the
# program is missing from the AST, likely resulting in evaluation
# errors.
if stmt is not None:
stmts.append(stmt)
self._next_token()
return ast.Program(stmts)
def program(self):
'''
Program -> int main ( ) { Declarations Statements }
:return: Program object
'''
# match int main ( ) open brace
if self.curr_tok[0] != values.INT:
raise CliteSyntaxError("Keyword 'int' expected")
self.curr_tok = self.lex_gen.__next__()
if self.curr_tok[0] != values.MAIN:
raise CliteSyntaxError("Keyword 'main' expected")
self.curr_tok = self.lex_gen.__next__()
if self.curr_tok[0] != values.PARENL:
raise CliteSyntaxError(" ( expected")
self.curr_tok = self.lex_gen.__next__()
if self.curr_tok[0] != values.PARENR:
raise CliteSyntaxError(" ) expected")
self.curr_tok = self.lex_gen.__next__()
if self.curr_tok[0] != values.LBRACE:
raise CliteSyntaxError(" { expected")
self.curr_tok = self.lex_gen.__next__()
self.decls = self.declarations()
self.stmts = self.statements()
prog = ast.Program(self.decls, self.stmts, self.declList)
if self.curr_tok[0] != values.RBRACE:
raise CliteSyntaxError(" } expected")
self.curr_tok = self.lex_gen.__next__()
return prog
def program(self):
if self.currtok[0] == "KWDINT":
self.currtok = next(self.tokens)
if self.currtok[0] == "KWDMAIN":
self.currtok = next(self.tokens)
if self.currtok[0] == "PCTLPAR":
self.currtok = next(self.tokens)
if self.currtok[0] == "PCTRPAR":
self.currtok = next(self.tokens)
if self.currtok[0] == "PCTLBRA":
self.currtok = next(self.tokens)
# follow grammatically correct syntax (declarations and statements)
d = self.decls()
s = self.statements()
# run the declarations and statements in the abstract syntax tree for program
if self.currtok[0] == "PCTRBRA":
return ast.Program(d, s)
else:
raise CLiteSyntaxError("Right brace expected",
self.currtok[1])
else:
raise CLiteSyntaxError("Left brace expected",
self.currtok[1])
else:
raise CLiteSyntaxError("Right parenthesis expected",
self.currtok[1])
else:
raise CLiteSyntaxError("Left parenthesis expected",
self.currtok[1])
else:
raise CLiteSyntaxError("keyword main expected",
self.currtok[1])
else:
raise CLiteSyntaxError("keyword int expected", self.currtok[1])
def parse_program(self):
""" Program ::= Command EOT """
command = self.parse_command()
self.token_accept(scanner.TK_EOT)
return ast.Program(command)
indent_level = 0
is_undent = False
rets = {
'System print': 'void',
'Float -': 'Float',
'Float *': 'Float',
'Float +': 'Float',
'Float /': 'Float',
'Int -': 'Int',
'Int *': 'Int',
'Int +': 'Int',
'Int /': 'Int',
'$z 0': 'void'
}
index = {'$z': ast.Call('System', 'print', [])}
tree = ast.Program(
[ast.Definition('$main', ast.Function(ast.Args([]), [], ret='int'), True)])
anon_actor_num = 0
buff = '' # For names and values
def parse(source):
while True:
try:
q = parse_top_level(source)
#raise_error(source)
tree.append(q)
except ValueError:
break
for i in tree:
if isinstance(i, ast.Actor):
tree[-1].value.append(ast.Call('$z', str(anon_actor_num), []))
def p_program(self, p):
"""program : source_elements"""
p[0] = ast.Program(p[1])
def p_program(self, p):
"""
program : cells
"""
p[0] = ast.Program(p[1])
def p_program(p):
'''program : declarations'''
p[0] = ast.Program(p[1]).at(loc(p))
def program(p):
head, decpart, bodypart, tail = p
assert head.getstr() == tail.getstr()
return ast.Program(head.getstr(), decpart, bodypart)
def p_program(self, p):
""" program : global_declaration_list
"""
p[0] = ast.Program(p[1])
def p_program_01(t):
'''program : program_part'''
t[0] = ast.Program(t[1])
def parse_program(self):
""" Program :== Command """
e1 = self.parse_command()
return ast.Program(e1)
def p_program(self, parse):
'''
program : class_list
'''
parse[0] = AST.Program(classes=parse[1])
def p_program(self, p):
""" program : global_declaration_list
"""
p[0] = ast.Program(p[1], coord=self._token_coord(p, 1))
