First commit

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+
+*.pyc

brainfuck.py

@@ -0,0 +1,201 @@
+"""interpreter of brainfuck written in python"""
+import sys
+import os
+
+from termcolor import cprint
+
+os.system('color')
+
+class BFError(RuntimeError):
+	pass
+
+def pair_bracket(prog):
+	result = []
+	brackets = []
+	for index, instr in enumerate(prog):
+		if instr == '[':
+			brackets.append(index)
+		if instr == ']':
+			open_brackets = brackets.pop()
+			result.append((open_brackets,index))
+	return dict(result)
+
+
+def interpret(prog):
+	ar = [0]
+	ptr = 0
+	index = 0
+	blocks = []
+	bracket_info = pair_bracket(prog)
+	while index < len(prog):
+		instr = prog[index]
+
+		if instr == '+':
+			ar[ptr] += 1
+		elif instr == '-':
+			ar[ptr] -= 1
+		elif instr == '>':
+			ptr += 1
+			if ptr == len(ar):
+				ar.append(0)
+		elif instr == '<':
+			ptr -= 1
+			if ptr < 0:
+				raise ValueError("You can't go to a cell before 0")
+		elif instr == '.':
+			print(chr(ar[ptr]),end='')
+		elif instr == ',':
+			val = input()
+			if len(val) > 1:
+				raise ValueError('please put character one by one')
+			if val:
+				ar[ptr] = ord(val)
+			else:
+				ar[ptr] = 0
+		elif instr == '[':
+			if ar[ptr]:
+				blocks.append(index)
+			else:
+				index = bracket_info[index]
+		elif instr == ']':
+			if ar[ptr]:
+				index = blocks.pop()
+				continue
+		elif instr == '#':
+			print(ar, ptr, ar[ptr])
+
+		index += 1
+
+	return ar
+
+
+def format(prog,debug_mode=True):
+	if debug_mode:
+		return ''.join(i for i in prog if i in '[]<>+-.,#')
+	return ''.join(i for i in prog if i in '[]<>+-.,')
+
+
+def repl():
+	"""
+	use brainfuck in an interactive mode
+
+	special commands :
+		p: where is the pointer
+		v: val of the cell (the number, not the ascii val)
+		a: show the entire array
+
+	"""
+	ar = [0]
+	ptr = 0
+	blocks = []
+	while 1:
+		try:
+			not_ok = True
+			while not_ok:
+				try:
+					prog = input('> ')
+					not_ok = False
+				except KeyboardInterrupt:
+					print()
+		except EOFError:
+			break
+
+		if prog == 'p':
+			print(ptr)
+		elif prog == 'v':
+			print(ar[ptr])
+		elif prog == 'a':
+			print(ar)
+		elif prog == 'help':
+			repl_help()
+		elif prog == 'q':
+			break
+		elif prog == 'r':
+			repl()
+			return
+		else:
+			index = 0
+			bracket_info = pair_bracket(prog)
+			try:
+				while index < len(prog):
+					instr = prog[index]
+
+					if instr == '+':
+						ar[ptr] += 1
+					elif instr == '-':
+						ar[ptr] -= 1
+					elif instr == '>':
+						ptr += 1
+						if ptr == len(ar):
+							ar.append(0)
+					elif instr == '<':
+						ptr -= 1
+						if ptr < 0:
+							ptr = 0
+							raise BFError(f"You can't go to a cell before 0 (code before : {prog[:index]}, code after : {prog[index:]})")
+					elif instr == '.':
+						print(chr(ar[ptr]),end='')
+					elif instr == ',':
+						val = input()
+						if len(val) > 1:
+							raise ValueError('please put character one by one')
+						if val:
+							ar[ptr] = ord(val)
+						else:
+							ar[ptr] = 0
+					elif instr == '[':
+						if ar[ptr]:
+							blocks.append(index)
+						else:
+							index = bracket_info[index]
+					elif instr == ']':
+						if ar[ptr]:
+							index = blocks.pop()
+							continue
+						else:
+							blocks.pop()
+					elif instr == '#':
+						try:
+							if prog[index+1] == '(':
+								index = index+2
+								while prog[index] != ')':
+									print(prog[index],end='')
+									index += 1
+								print(' ',end='')
+						except IndexError:
+							pass 
+						print(ar, ptr, ar[ptr])
+
+					index += 1
+			except KeyboardInterrupt:
+				pass
+			except BFError as e:
+				cprint(e,'red')
+
+			if '.' in prog:
+				print()
+
+
+def repl_help():
+	print("""\
+In this repl, you can enter any valid brainfuck expression.
+There is also some special command : 
+	'a' will show you the state of the memory
+	'p' will show you where is the pointer
+	'v' will show you the value of the cell
+	'r' will reset the array""")
+
+
+
+def main():
+	if len(sys.argv) == 2:
+		interpret(open(sys.argv[2]).read())
+	elif len(sys.argv) == 3:
+		if sys.argv[1] == '-i':		#oui c'est de lam erde comme manière de faire
+			interpret(sys.argv[2])
+	else:
+		repl()
+
+
+if __name__ == '__main__':
+	main()

grammar.ebnf

@@ -0,0 +1,26 @@
+program = statement, {statement}
+
+block = "{",{statement}, "}"
+statement = short_statement | while_block | if_block
+short_statement = declaration | assignement | expression | inc-dec, ";"
+assignement = name, assignement_symbol, expression
+declaration = "var" , name , {",",name},  ";"
+
+expression = compar
+
+compar = calcul, [compar_op, calcul]
+calcul = terme, [('+'|'-'), terme]
+terme = factor [("*"|"/"), factor]
+factor = val ["**", val]
+val = name | number | "(", expression, ")"
+inc-dec = name, ("++" | "--")
+
+condition = '(', expression, ')'
+while_block = "while", condition, block
+if_block = "if", condition, block, ["else", block]
+
+
+
+bin_op = "+"|"-"|"*"|"/"|"**"
+compar_op = ">"|">="|"<"|"<="|"=="
+assignement_symbol = "="|"+="|"-="|"/="|"*="

to_bf_compiler.py

@@ -0,0 +1,522 @@
+import re
+from collections import namedtuple
+import os
+
+from termcolor import cprint
+
+os.system('color')
+
+REGEXS = [(re.compile(i),j) for i,j in (
+	(r'\s+','WHITESPACE'),
+	(r'//[^\n]*|/\*(?s:.)*\*/','COMMENTS'),
+	(r'if|for|while|else|var','KEYWORD'),
+
+	(r'>=|<=|==|>|<','COMPAR_OP'),
+	(r'\+=|-=|\*=|/=|=','ASSIGNEMENT_OP'),
+	(r'\+\+|--','INC_DEC_OP'),
+	(r'\+|\*\*|\*|-|/','BIN_OP'),
+	(r'\(|\)|\{|\}|;|,','CONTROL_CHAR'),
+
+	(r'[a-zA-Z]\w*','IDENTIFIERS'),
+	(r'\d[\d_]*','NUMBERS')
+
+)]
+
+USELESS_TAGS = ('WHITESPACE','COMMENTS')
+
+Token = namedtuple('Token',('text','tag'))
+
+def lex(program,keep_whitespace=False):
+	pos = 0
+	tokens = []
+	while pos < len(program):
+		for regex, tag in REGEXS:
+			match = regex.match(program,pos)
+			if match is not None:
+				token = match.group(0)
+				tokens.append(Token(token,tag))
+				pos = match.end(0)
+				break
+		else:
+			raise SyntaxError(f"No match find during the lexing for {program[pos:pos+20]}...")
+	if keep_whitespace:
+		return tokens
+	return clean_tokens(tokens)
+
+def clean_tokens(tokens):
+	return [token for token in tokens if token.tag not in USELESS_TAGS]
+
+
+#****************************
+
+
+ProgramNode = namedtuple('ProgramNode',('list_of_statement'))
+BlockNode = namedtuple('BlockNode',('list_of_statement'))
+
+IfNode = namedtuple('IfNode',('condition','block','else_block'))
+WhileNode = namedtuple('WhileNode',('condition','block'))
+
+AssignementNode = namedtuple('AssignementNode',('target','operator','expression'))
+IncDecNode = namedtuple('IncDecNode',('name','operator'))
+DeclarationNode = namedtuple('DeclarationNode',('names'))
+BinOpNode = namedtuple('BinOpNode',('left','op','right'))
+
+IdentifierNode = namedtuple('IdentifierNode',('name'))
+NumberNode = namedtuple('NumberNode',('value'))
+
+
+class Parser:
+	def __init__(self,tokens):
+		self.tokens = tokens
+		self.pos = 0
+
+	def parse(self):
+		return self.program()
+
+	def accept_text(self,value):
+		try:
+			token = self.tokens[self.pos]
+		except IndexError:
+			#print("reach the end")
+			return False
+		if token.text == value:
+			self.pos += 1
+			return token
+		return False
+
+	def accept_tag(self,tag):
+		try:
+			token = self.tokens[self.pos]
+		except IndexError:
+			return False
+		if token.tag == tag:
+			self.pos += 1
+			return token
+		return False
+
+
+
+
+	def program(self):
+		nodes = []
+		while 1:
+			statement = self.statement()
+			if statement:
+				nodes.append(statement)
+			else:
+				break
+		if not len(nodes):
+			raise ValueError("Your program seems to be empty")
+		return ProgramNode(nodes)
+
+	def block(self):
+		#print(f"enter block ({self.pos})")
+		if not self.accept_text("{"):
+			return None
+		nodes = []
+		while 1:
+			statement = self.statement()
+			if statement:
+				nodes.append(statement)
+			else:
+				break
+		if not self.accept_text('}'):
+			raise SyntaxError("'}' missing at the end of the block")
+
+		#cprint("block",'green')
+		return BlockNode(nodes)
+
+	def statement(self):
+		#print(f"enter statement ({self.pos})")
+		for func in (self.short_statement,self.while_block, self.if_block):
+			node = func()
+			if node:
+				#cprint("statement",'green')
+				return node
+		#cprint("no statement",'red')
+		return None
+
+	def short_statement(self):
+		#print(f"enter short_statement ({self.pos})")
+		for func in (self.declaration, self.assignement,self.inc_dec,self.expression,):
+			node = func()
+			if node:
+				if self.accept_text(";"):
+					#cprint('short_statement','green')
+					return node
+				else:
+					raise SyntaxError(f"Missing ';' ({node})")
+		#cprint("no short_statement",'red')
+		return None
+
+	def declaration(self):
+		if not self.accept_text('var'):
+			return None
+		name = self.accept_tag('IDENTIFIERS')
+		if not name:
+			raise SyntaxError("You must specifies an identifiers after a 'var' keyword")
+		names = [IdentifierNode(name.text)]
+		while 1:
+			if self.accept_text(','):
+				name = self.accept_tag('IDENTIFIERS')
+				if name:
+					names.append(IdentifierNode(name.text))
+				else:
+					raise SyntaxError("Expected an identifiers after a ',' in a declaration statemement")
+			else:
+				break
+			
+		return DeclarationNode(names)
+
+	def assignement(self):
+		#print(f"enter assignement ({self.pos})")
+		name = self.accept_tag('IDENTIFIERS')
+		if not name:
+			#cprint("no assignement (no name)",'red')
+			return None
+		sym = self.accept_tag('ASSIGNEMENT_OP')
+		if not sym:
+			self.pos -= 1 #for the name
+			#cprint("no assignement (no op)",'red')
+			return None
+		expr = self.expression()
+		if not expr:
+			raise SyntaxError("Missing expression in a assignement")
+		#cprint("assignement",'green')
+		return AssignementNode(IdentifierNode(name.text),sym.text,expr)
+
+	def inc_dec(self):
+		#print(f"enter inc_dec ({self.pos})")
+		name = self.accept_tag('IDENTIFIERS')
+		if not name:
+			#cprint("no inc_dec (no name)",'red')
+			return None
+		op = self.accept_tag('INC_DEC_OP')
+		if not op:
+			self.pos -= 1 	#for the name
+			#cprint("no inc_dec (no op)",'red')
+			return None
+		#cprint("inc_dec",'green')
+		return IncDecNode(IdentifierNode(name.text),op.text)
+
+	def expression(self):
+		#print(f"enter expression ({self.pos})")
+		compar = self.compar()
+		if compar:
+			#cprint("expression",'green')
+			return compar
+
+		#cprint("no expression",'red')
+		return None
+
+	def compar(self):
+		calcul1 = self.calcul()
+		if not calcul1:
+			return None
+
+		op = self.accept_tag('COMPAR_OP')
+		if op:
+			calcul2 = self.calcul()
+			if not calcul2:
+				raise SyntaxError("missing second term in calcul")
+			return BinOpNode(calcul1,op.text,calcul2)
+		return calcul1
+
+	def calcul(self):
+		#print(f"enter calcul ({self.pos})")
+		"""There is calcul, terme, factor and val for differentiate between +/-, * or /, and **"""
+		terme1 = self.terme()
+		if not terme1:
+			return None
+
+		op = None
+		sym = self.accept_text('+')
+		if sym:
+			op = sym
+		sym = self.accept_text('-')
+		if sym:
+			op = sym
+
+		if op:
+			terme2 = self.terme()
+			if not terme2:
+				raise SyntaxError("missing second term in calcul")
+			return BinOpNode(terme1,op.text,terme2)
+		return terme1
+
+
+	def terme(self):
+		#print(f"enter terme ({self.pos})")
+		factor1 = self.factor()
+		if not factor1:
+			return None
+
+		op = None
+		sym = self.accept_text('*')
+		if sym:
+			op = sym
+		sym = self.accept_text('/')
+		if sym:
+			op = sym
+
+		if op:
+			factor2 = self.factor()
+			if not factor2:
+				raise SyntaxError("missing second factor in terme")
+			return BinOpNode(factor1,op.text,factor2)
+		return factor1
+
+	def factor(self):
+		#print(f"enter factor ({self.pos})")
+		val = self.value()
+		if not val:
+			return None
+		op = self.accept_text('**')
+		if op:
+			val2 = self.value()
+			if not val2:
+				raise SyntaxError("missing second val un factor")
+			return BinOpNode(val,op.text,val2)
+		return val
+
+	def value(self):
+		#print(f"enter value ({self.pos})")		
+		name = self.accept_tag('IDENTIFIERS')
+		if name:
+			return IdentifierNode(name.text)
+		number = self.accept_tag('NUMBERS')
+		if number:
+			return NumberNode(int(number.text))
+		if self.accept_text('('):
+			expr = self.expression()
+			if not (expr and self.accept_text(')')):
+				raise SyntaxError("missing expression or matching ')'")
+			return expr
+		return None
+
+	def while_block(self):
+		#print(f"enter while_block ({self.pos})")		
+		if not self.accept_text('while'):
+			#cprint("no while_block (keyword)",'red')
+			return None
+
+		if not self.accept_text('('):
+			raise SyntaxError("Bad while block")
+
+		cond = self.expression()
+		if not cond:
+			raise SyntaxError("Bad while block")
+		if not self.accept_text(')'):
+			raise SyntaxError("Bad while block")
+		block = self.block()
+		if not block:
+			raise SyntaxError("Bad while block")
+		#cprint("while_block",'green')
+		return WhileNode(cond,block)
+
+	def if_block(self):
+		#print(f"enter if_block ({self.pos})")
+		if not self.accept_text('if'):
+			#cprint("no if_block (keyword)",'red')
+			return None
+
+		if not self.accept_text('('):
+			raise SyntaxError("Bad if block")
+
+		cond = self.expression()
+		if not cond:
+			raise SyntaxError("Bad if block")
+		if not self.accept_text(')'):
+			raise SyntaxError("Bad if block")
+		block = self.block()
+		if not block:
+			raise SyntaxError("Bad if block")
+
+		if self.accept_text('else'):
+			else_block = self.block()
+			if not else_block:
+				raise SyntaxError("Bad else block")
+			return IfNode(cond,block,else_block)
+		#cprint("if_block",'green')
+		return IfNode(cond,block,None)
+
+
+def parse(prog):
+	tokens = clean_tokens(lex(prog))
+	parser = Parser(tokens)
+	return parser.program()
+
+
+#***************
+
+
+class Ast_to_IR:
+
+	def __init__(self,ast):
+		self.ast = ast
+
+	def add(self,val):
+		self.ir.append(val)
+
+	def convert(self):
+		self.ir = []
+		vars_ = []
+		for statemement in self.ast.list_of_statement:
+			if isinstance(statemement,DeclarationNode):
+				vars_.extend(statemement.names)
+		vars_ = {val:index for index,val in enumerate(vars_)}
+		self.vars = vars_
+		self.pos = 0
+
+		self.add(('INIT',len(vars_)))
+		self.push_block(self.ast)
+		return self.ir
+
+	def push_block(self,node):
+		for statement in node.list_of_statement:
+			func = methods.get(type(statement),default)	#switch-case
+			func(self,statement)
+
+	def assignement_to_ir(self,node):
+		if node.operator == '=':
+			expression = node.expression
+		else:
+			operator = node.operator[0]	#ex : '+=' -> '+'
+			expression = BinOpNode(node.target,operator,node.expression)
+
+		self.push_expr(expression)
+		assign_distance = self.pos + self.vars[node.target]
+
+		self.add(('ASSIGN',assign_distance,node.target.name))
+		self.pos -= 1
+
+	def expression_statement_to_ir(self,node):
+		self.push_expr(node)
+		self.pos -= 1
+		self.add(('POP',))
+
+	def inc_dec_to_ir(self,node):
+		assign_distance = self.pos + self.vars[node.name]
+		if node.operator == "++":
+			self.add(('INC',assign_distance,node.name.name))
+		else:
+			self.add(('DEC',assign_distance,node.name.name))
+
+	def push_expr(self,node):
+		if isinstance(node,NumberNode):
+			self.pos += 1
+			self.add(('PUSH_NUMBER',node.value))
+			return
+		if isinstance(node,IdentifierNode):
+			self.pos += 1
+			distance = self.pos + self.vars[node]
+			self.add(('PUSH_VAR',distance,node.name))
+			return
+
+		if isinstance(node,BinOpNode):
+			self.push_expr(node.left)
+			self.push_expr(node.right)
+			self.pos -= 1
+			self.add(('BIN_OP',node.op))
+			return
+
+		raise Exception(f"cette expression n'est pas bonne : {node}")
+
+	def while_to_ir(self,node):
+		self.push_expr(node.condition)
+		self.add(('WHILE_ENTER',))
+		self.pos -= 1
+		self.push_block(node.block)
+		self.push_expr(node.condition)
+		self.add(('WHILE_END',))
+		self.pos -= 1
+
+	def if_to_ir(self,node):
+		self.push_expr(node.condition)
+		self.add(('IF_ENTER',))
+		self.pos += 1
+		self.push_block(node.block)
+		if node.else_block:
+			self.add(('ELSE_ENTER',))
+			self.pos -= 2
+			self.push_block(node.else_block)
+			self.add(('ELSE_END',))
+		else:
+			self.add(('IF_END',))
+			self.pos -= 2
+
+
+
+methods = {
+	DeclarationNode: lambda self,node:None,
+	AssignementNode: Ast_to_IR.assignement_to_ir,
+	WhileNode: Ast_to_IR.while_to_ir,
+	IfNode: Ast_to_IR.if_to_ir,
+	IncDecNode: Ast_to_IR.inc_dec_to_ir,
+}
+default = Ast_to_IR.expression_statement_to_ir
+
+
+#************
+
+def init(nb):
+	return '>' * (nb-1) + f'	INIT {nb}'
+
+def assign(val,name):
+	return f"{'<'*val}[-]{'>'*val}[-{'<'*val}+{'>'*val}]<	ASSIGN {name}"
+
+def inc(val,name):
+	return f"{'<'*val}+{'>'*val}	INC {name}"
+
+def dec(val,name):
+	return f"{'<'*val}-{'>'*val}	DEC {name}"
+
+def pop():
+	return '[-]<	POP'
+
+def push_number(val):
+	return ">" + "+"*val + f"	PUSH_NUMBER {val}"
+
+def push_var(val,name):
+	return '<' * (val-1) + f"[-{'>'*val}+>+<{'<'*val}]" + f"{'>'*val}>[-<{'<'*val}+>{'>'*val}]<" + f"	PUSH_VAR {name}"
+
+def bin_op(op):
+	if op == "+":
+		bf = "[-<+>]<"
+	elif op == "-":
+		bf =  "[-<->]<"
+	else:
+		raise Exception(f"bin_op {op} not implemented yet")
+	return bf + f"	BIN_OP {op if op not in ('+','-') else {'+':'plus','-':'minus'}[op]}"
+
+def while_enter():
+	return "[[-]<	WHILE_ENTER"
+
+def while_end():
+	return "]<	WHILE_END"
+
+def if_enter():
+	return ">+<[[-]>-	IF_ENTER"
+
+def else_enter():
+	return "<]>[-<<	ELSE_ENTER"
+
+def else_end():
+	return ">>]<<	ELSE_END"
+
+def if_end():
+	return "<]>[-]<<	IF_END"
+
+def compile_ir(ir):
+	return '\n'.join(globals()[i[0].lower()](*i[1:]) for i in ir)
+
+
+#**************
+
+def compile(prog):
+	tokens = lex(prog)
+	ast = Parser(tokens).parse()
+	ir = Ast_to_IR(ast).convert()
+	brainfuck = compile_ir(ir)
+	return brainfuck
+