def p_body(self, p):
"""body : LBRACE CODE_BLOCK RBRACE
| instruction"""
if len(p) == 2:
p[0] = ast.Instruction(p[1])
else:
p[0] = ast.Instruction(p[2])
def p_range(self, p):
"""range : expression RANGE expression RANGE expression
| expression RANGE expression"""
if len(p) == 4:
p[0] = ast.Range(p[1], p[3])
else:
p[0] = ast.Range(p[1], p[3], p[5])
def create_arithmetric(self, op, left, right): operation = Ast.operation() operation.type = self.get_opertype(left, right) operation.op = self.get_op(op) operation.left = left.id operation.right = right.id return operation
def main():
global path, goal_node
# Obtain information from calling parameters
method = input("Enter your search type :#ast bfs dfs# ")
if method == "ast":
heuristics = input("Enter heuristics fun :#hattan Euclidean# ")
lst1 = [
int(item)
for item in input("Enter initialBoard :#1,2,3,4,5,6,7,8,0 ").split(',')
]
# Build initial board state
InitialState = list(convert(lst1))
for i in range(len(InitialState)):
for j in range(len(InitialState[i])):
if (InitialState[i][j] == 0):
x = i
y = j
break
# Start operation
start = timeit.default_timer()
if (method == "bfs"):
print("BFS >>>>>")
print(InitialState)
goal_node = BFS(InitialState, x, y)
if (method == "dfs"):
print("DFS >>>>>")
goal_node = DFS(InitialState, x, y)
if (method == "ast"):
print("AST >>>>>")
goal_node = Ast.A_star(InitialState, heuristics)
exit(0)
stop = timeit.default_timer()
time = stop - start
# Print path
print("Path :")
path = find_path(goal_node, path, False)
for node in path:
printNode(node.array)
print(node.direction)
#print
print()
print("Path Cost :", len(path))
print("Running time :", format(time, '.8f'))
print("Search Depth ", goal_node.depth)
print()
print("## Expanded Nodes ## : ", expandned_nodes)
for node in expanded:
printNode(node)
print(",")
def p_code_block_braces(self, p):
"""
CODE_BLOCK : CODE_BLOCK LBRACE CODE_BLOCK RBRACE
| LBRACE CODE_BLOCK RBRACE
"""
if len(p) == 5:
p[1].instructions.append(p[3])
p[0] = p[1]
else:
p[0] = ast.CodeBlock(p[2])
def p_sequence(self, p):
"""
sequence : sequence COMMA expression
| expression
"""
if len(p) == 4:
p[1].expressions.append(p[3])
p[0] = p[1]
else:
p[0] = ast.Sequence(p[1])
def p_code_block(self, p):
"""
CODE_BLOCK : CODE_BLOCK instruction
| instruction
"""
if len(p) == 3:
p[1].instructions.append(p[2])
p[0] = p[1]
else:
p[0] = ast.CodeBlock(p[1])
def p_rows(self, p):
"""
rows : rows SEMICOLON sequence
| sequence
"""
if len(p) == 2:
p[0] = ast.Rows(p[1])
else:
p[1].row_list.append(p[3])
p[0] = p[1]
def p_value(self, p):
"""
value : FLOAT
| INT
| STRING
| matrix
| variable_attribute
"""
p[0] = ast.Value(p[1])
def p_bin_expressions(self, p):
"""
expression : expression PLUS expression
| expression MINUS expression
| expression TIMES expression
| expression DIVIDE expression
| expression MPLUS expression
| expression MMINUS expression
| expression MTIMES expression
| expression MDIVIDE expression
"""
p[0] = ast.BinaryExpression(p[1], p[2], p[3])
def generateIR(self, ast: Ast):
# we should also generate declaration for standard library
for funcName, funcType in LLVMCodeGenerator.standardLibraryFunctions:
func = ir.Function(self.module, funcType, funcName)
self.symbolTable.put(funcName, func)
# declare extern NVector struct (empty it's defined in runtime library)
# start by generating main function
functionName = 'main'
functionType = ir.FunctionType(irIntType(), [], False)
func = ir.Function(self.module, functionType, functionName)
self.symbolTable.put(functionName, func)
entryBlock = func.append_basic_block('entry')
self.builder = ir.IRBuilder(entryBlock)
# traverse ast and generate code
ast.codegen(self)
retVal = ir.Constant(irIntType(), 0)
self.builder.ret(retVal)
return self.module
def p_if_else_statement(self, p):
"""
if_statement : IF LBRACKET relation RBRACKET body ELSE body
"""
p[0] = ast.If(p[3], p[5], p[7])
def p_while_statement(self, p):
"""while_statement : WHILE LBRACKET relation RBRACKET body"""
p[0] = ast.While(p[3], p[5])
def current_variable(self, node,datatype):
variable = Ast.id()
variable.id = "%{}.{}".format(node.id, self.allocated_objects[node.id])
variable.type = datatype
return variable
def p_if_statement(self, p):
"""
if_statement : IF LBRACKET relation RBRACKET body %prec IF
"""
p[0] = ast.If(p[3], p[5])
def p_keyword_return(self, p):
"""
keyword : RETURN expression
"""
p[0] = ast.Return(p[2])
def p_relation(self, p):
"""relation : expression logic_operator expression"""
p[0] = ast.BinaryExpression(p[1], p[2], p[3])
def create_temp(self, type):
self.allocated_temp += 1
temp = Ast.temp()
temp.id = "%{}".format(self.allocated_temp)
temp.type = type
return temp
def p_expression_negation(self, p):
"""
expression : MINUS expression %prec UMINUS
"""
p[0] = ast.Negation(p[2])
def p_assignment(self, p):
"""
assignment : variable assignment_operator expression
"""
p[0] = ast.Assignment(p[1], p[2], p[3])
def p_program(self, p):
"""PROGRAM : CODE_BLOCK"""
p[0] = ast.Program(p[1])
def p_matrix(self, p):
"""
matrix : LSQUARE rows RSQUARE
"""
p[0] = ast.Matrix(p[2])
def p_expression_transposition(self, p):
"""
expression : LBRACKET expression RBRACKET TRANSPOSITION
"""
p[0] = ast.Transposition(p[2])
def p_id_transposition(self, p):
"""
expression : ID TRANSPOSITION
"""
p[0] = ast.Transposition(ast.Variable(p[1]))
def p_for_statement(self, p):
"""for_statement : FOR ID ASSIGN range body"""
p[0] = ast.For(p[2], p[4], p[5])
def p_keyword_continue(self, p):
"""
keyword : CONTINUE
"""
p[0] = ast.Continue()
def p_variable_attribute(self, p):
"""
variable_attribute : ID LSQUARE sequence RSQUARE
"""
p[0] = ast.VariableAttribute(p[1], p[3])
def p_expression_id(self, p):
"""expression : ID"""
p[0] = ast.Variable(p[1])
class Parser(object):
# Constructeur
def __init__(self):
self.liste = Tokens()
self.ast = Ast()
self.indentation = 0
self.nb_errors = 0
# Destructeur
def terminer(self):
self.ast.terminer()
# Printeur
def __str__(self):
return "it's me, Mario"
# Tokenizer
def read_tokens(self, file_path):
fichier = open(file_path)
lecteur = fichier.readline
g = tokenize.generate_tokens(lecteur)
for _, token, coord, _, _ in g:
if token == "\n":
continue
self.liste.add(token, coord[0], coord[1])
print self.liste
# Commencer l'analyse
def analyse(self):
self.ast.add_brain(self.parse_brain())
print "Nombre d'erreurs de parsing :\t", self.nb_errors
self.ast.visiter()
# Verifier si le token courant est bien de ce type et passer au suivant
def expect(self, kind):
token = self.liste.get()
if re.search(kind, token):
sys.stdout.write(self.liste.pick())
sys.stdout.write(" ")
return token
else:
self.endl()
self.nb_errors += 1
x, y = self.liste.coord()
print "[Error] [" + str(x) + ";" + str(y) + "] Expected token : " + kind + ", get : " + token
# Tester si le token actuel est de ce type
def test(self, kind):
return re.search(kind, self.liste.get())
# Tester si le token suivant est de ce type
def test_plus_1(self, kind):
return re.search(kind, self.liste.get_plus_1())
# Ajouter une indentation
def indent(self):
self.indentation += 1
# Supprimer une indentation
def desindent(self):
self.indentation -= 1
# Nouvelle ligne
def endl(self):
sys.stdout.write("\n")
for i in range(self.indentation):
sys.stdout.write("\t")
######### Grammaire ...
# Bloc principal de cerveau
def parse_brain(self):
self.expect(d.brain)
token = self.expect(d.identifier)
brain = T_brain(self.ast, token)
self.expect(d.laccol)
self.indent()
self.endl()
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.var):
brain.add_b_var(self.parse_block_variables())
elif self.test(d.layers):
brain.add_b_layers(self.parse_block_layers())
elif self.test(d.inp):
brain.add_b_input(self.parse_block_input())
elif self.test(d.out):
brain.add_b_output(self.parse_block_output())
elif self.test(d.obj):
brain.add_b_goal(self.parse_block_goal())
elif self.test(d.struct):
brain.add_b_structure(self.parse_block_structure())
elif self.test(d.interf):
brain.add_b_interface(self.parse_block_interface())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return brain
# Bloc declaration de variables
def parse_block_variables(self):
self.expect(d.var)
self.expect(d.laccol)
self.indent()
self.endl()
b_var = T_block_vars(self.ast, "variables")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.integer):
b_var.add_int(self.parse_declaration_int())
elif self.test(d.scale):
b_var.add_scale(self.parse_declaration_scale())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_var
# Bloc declaration d'inputs
def parse_block_input(self):
self.expect(d.inp)
self.expect(d.laccol)
self.indent()
self.endl()
b_input = T_block_inputs(self.ast, "inputs")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.identifier):
b_input.add_input(self.parse_declaration_ioc())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_input
# Bloc declaration d'outputs
def parse_block_output(self):
self.expect(d.out)
self.expect(d.laccol)
self.indent()
self.endl()
b_output = T_block_outputs(self.ast, "outputs")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.identifier):
b_output.add_output(self.parse_declaration_ioc())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_output
# Bloc declaration d'objectifs
def parse_block_goal(self):
self.expect(d.obj)
self.expect(d.laccol)
self.indent()
self.endl()
b_goal = T_block_goal(self.ast, "objectifs")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.identifier):
b_goal.add_goal(self.parse_declaration_ioc())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_goal
# Bloc declaration de couches
def parse_block_layers(self):
self.expect(d.layers)
self.expect(d.laccol)
self.indent()
self.endl()
b_couche = T_block_couches(self.ast, "couches")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.identifier):
b_couche.add_couche(self.parse_declaration_ioc())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_couche
# Bloc declaration de structure
def parse_block_structure(self):
self.expect(d.struct)
self.expect(d.laccol)
self.indent()
self.endl()
b_struct = T_block_struct(self.ast, "structures")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.identifier):
b_struct.add_struct(self.parse_declaration_structure())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_struct
# Bloc declaration d'interface
def parse_block_interface(self):
self.expect(d.interf)
self.expect(d.laccol)
self.indent()
self.endl()
b_interface = T_block_interface(self.ast, "interfaces")
continuer = True
while continuer:
if self.test(d.raccol):
continuer = False
elif self.test(d.clock):
b_interface.add_clock(self.parse_declaration_clock())
elif self.test(d.reset):
b_interface.add_reset(self.parse_declaration_reset())
elif self.test(d.learn):
b_interface.add_learn(self.parse_declaration_learn())
else:
continuer = False
self.desindent()
self.expect(d.raccol)
self.endl()
return b_interface
# Declaration d'une constante
def parse_declaration_int(self):
self.expect(d.integer)
token = self.expect(d.identifier)
self.expect(d.equal)
number = self.expect(d.number)
self.expect(d.semicolon)
self.endl()
return T_int(self.ast, token, number)
# Appel d'un nombre ou d'une constante
def parse_const(self):
if self.test(d.number):
return self.expect(d.number)
else:
return T_const(self.ast, self.expect(d.identifier))
# Declaration d'une echelle
def parse_declaration_scale(self):
self.expect(d.scale)
token = self.expect(d.identifier)
self.expect(d.equal)
n1 = self.parse_const()
self.expect(d.comma)
n2 = self.parse_const()
self.expect(d.semicolon)
self.endl()
return T_scale(self.ast, token, n1, n2)
# Corps de declaration d'une input, output ou couche
def parse_declaration_ioc(self):
name = self.expect(d.identifier)
size_tab = 1
scale = T_scale(self.ast, "1_scale_unitaire", 0, 1)
if self.test(d.lbracket):
self.expect(d.lbracket)
size_tab = self.parse_const()
self.expect(d.rbracket)
if self.test(d.semicolon):
self.expect(d.semicolon)
self.endl()
else:
self.expect(d.scale)
if self.test_plus_1(d.comma):
n1 = self.parse_const()
self.expect(d.comma)
n2 = self.parse_const()
scale = T_scale(self.ast, "0_scale_perso", n1, n2)
self.expect(d.semicolon)
self.endl()
else:
scale = T_scale(self.ast, self.expect(d.identifier), 0, 0)
self.expect(d.semicolon)
self.endl()
return T_ioc(self.ast, name, size_tab, scale)
# Declaration d'une structure
def parse_declaration_structure(self):
liste_structures = []
id1 = self.expect(d.identifier)
id1_from = -1
id1_to = -1
if self.test(d.lbracket):
self.expect(d.lbracket)
id1_from = self.parse_const()
self.expect(d.to)
id1_to = self.parse_const()
self.expect(d.rbracket)
continuer = True
while continuer:
if self.test(d.semicolon):
self.expect(d.semicolon)
continuer = False
elif self.test(d.substract):
self.expect(d.substract)
self.expect(d.sup)
id2 = self.expect(d.identifier)
id2_from = -1
id2_to = -1
if self.test(d.lbracket):
self.expect(d.lbracket)
id2_from = self.parse_const()
self.expect(d.to)
id2_to = self.parse_const()
self.expect(d.rbracket)
liste_structures.append(T_structure(self.ast, id1, id1_from, id1_to, id2, id2_from, id2_to))
id1 = id2
id1_from = id2_from
id1_to = id2_to
else:
continuer = False
self.endl()
return liste_structures
# Declaration de l'horloge
def parse_declaration_clock(self):
self.expect(d.clock)
clock = T_clock(self.ast, self.expect(d.identifier))
self.expect(d.semicolon)
self.endl()
return clock
# Declaration du reset
def parse_declaration_reset(self):
self.expect(d.reset)
reset = T_reset(self.ast, self.expect(d.identifier))
self.expect(d.semicolon)
self.endl()
return reset
# Declaration de l'activateur d'apprentissage
def parse_declaration_learn(self):
self.expect(d.learn)
learn = T_learn(self.ast, self.expect(d.identifier))
self.expect(d.semicolon)
self.endl()
return learn
def visit_Num(self, node): num = Ast.id() num.id = node.n num.type = self.get_datatype(num.id) return num
def p_statement(self, p):
"""
statement : assignment
| keyword
"""
p[0] = ast.Instruction(p[1])
def p_expression_fun(self, p):
"""
expression : function LBRACKET expression RBRACKET
| function LBRACKET sequence RBRACKET
"""
p[0] = ast.Function(p[1], p[3])
def p_variable(self, p):
"""
variable : ID
| variable_attribute
"""
p[0] = ast.Variable(p[1])
def p_keyword_print(self, p):
"""
keyword : PRINT sequence
"""
p[0] = ast.Print(p[2])
def p_keyword_break(self, p):
"""
keyword : BREAK
"""
p[0] = ast.Break()
def __init__(self): self.liste = Tokens() self.ast = Ast() self.indentation = 0 self.nb_errors = 0
