first milestone

ast_ds.py

@@ -9,61 +9,61 @@ def eval(self, env):
 		return self.i
 
 class VarExp(ArithmeticExp):
-	def __init__(self, x):
+	def __init__(self, (x, _)):
 		self.x = x
 
 	def eval(self, env):
-		if self.name in env:
-			return env[self.name]
-		else
+		if self.x in env:
+			return env[self.x]
+		else:
 			return 0
 
 class BinopExp(ArithmeticExp):
-	def __init__(self, op, left, right):
+	def __init__(self, (op, _), left, right):
 		self.op = op
 		self.left = left
 		self.right = right
 
 	def eval(self, env):
 		left_val = self.left.eval(env)
 		right_val = self.right.eval(env)
-		if self.op == '+'
+		if self.op == '+':
 			return left_val + right_val
-		elif self.op == '-'
+		elif self.op == '-':
 			return left_val - right_val
-		elif self.op == '*'
+		elif self.op == '*':
 			return left_val * right_val
-		elif self.op == '/'
+		elif self.op == '/':
 			return left_val / right_val
-		else
-			raise Excpetion('Unknown operator' + self.op)
+		else:
+			raise Exception('Unknown operator' + self.op)
 
 class BooleanExp:
 	pass
 
 class RelExp(BooleanExp):
-	def __init__(self, op, left, right):
+	def __init__(self, (op, _), left, right):
 		self.op = op
-        self.left = left
-        self.right = right
+		self.left = left
+		self.right = right
 
 	def eval(self, env):
 		left_val = self.left.eval(env)
-        right_val = self.right.eval(env)
-        if self.op == '<'
-            return left_val < right_val
-        elif self.op == '>'
-            return left_val > right_val
-        elif self.op == '<='
-            return left_val <= right_val
-        elif self.op == '>='
-            return left_val >= right_val
-		elif self.op == '=='
+		right_val = self.right.eval(env)
+		if self.op == '<':
+			return left_val < right_val
+		elif self.op == '>':
+			return left_val > right_val
+		elif self.op == '<=':
+			return left_val <= right_val
+		elif self.op == '>=':
+			return left_val >= right_val
+		elif self.op == '==':
 			return left_val == right_val
-		elif self.op == '!='
+		elif self.op == '!=':
 			return left_val != right_val
-        else
-            raise Excpetion('Unknown operator' + self.op)
+		else:
+			raise Exception('Unknown operator' + self.op)
 
 class AndExp(BooleanExp):
 	def __init__(self, left, right):
@@ -78,26 +78,26 @@ def eval(self, env):
 class OrExp(BooleanExp):
 	def __init__(self, left, right):
 		self.left = left
-        self.right = right
+		self.right = right
 
-    def eval(self, env):
-        left_val = self.left.eval(env)
-        right_val = self.right.eval(env)
-        return left_val or right_val
+	def eval(self, env):
+		left_val = self.left.eval(env)
+		right_val = self.right.eval(env)
+		return left_val or right_val
 
 class NotExp(BooleanExp):
 	def __init__(self, exp):
-        self.exp = exp
+		self.exp = exp
 
-    def eval(self, env):
+	def eval(self, env):
 		val = self.exp.eval(env)
-        return not val
+		return not val
 
 class Statement:
 	pass
 
 class AssignmentStatement(Statement):
-	def __init__(self, name, val):
+	def __init__(self, (name, _), val):
 		self.name = name
 		self.val = val
 
@@ -116,7 +116,7 @@ def eval(self, env):
 			self.body.eval(env)
 			eval_cond = self.condition.eval(env)
 
-class IfThenElseStatement(Statement):
+class IfStatement(Statement):
 	def __init__(self, condition, true_body, false_body):
 		self.condition = condition
 		self.true_body = true_body

chatlang.py

@@ -0,0 +1,19 @@
+import sys
+from chatlang_lexer import *
+from parser import *
+
+if __name__ == "__main__":
+	filename = sys.argv[1]
+	code = open(filename).read()
+	tokens = chatlang_lexer(code)
+	parsed = chatlang_parse(tokens)
+	if not parsed:
+		sys.stderr.write('Parse error!\n')
+		sys.exit(1)
+	ast, pos = parsed
+	env = {}
+	#import pdb;pdb.set_trace();
+	ast.eval(env)
+
+	for name in env:
+		sys.stdout.write('%s: %s\n' % (name, env[name]))

chatlang_lexer.py

@@ -11,15 +11,15 @@
     (r'\(', RESERVED),
     (r'\)', RESERVED),
     (r';', RESERVED),
-    (r':', RESERVED),
+    (r'\:', RESERVED),
     (r'\+', RESERVED),
     (r'-', RESERVED),
     (r'\*', RESERVED),
     (r'/', RESERVED),
-    (r'<', RESERVED),
     (r'<=', RESERVED),
-    (r'>', RESERVED),
+    (r'<', RESERVED),
     (r'>=', RESERVED),
+    (r'>', RESERVED),
 	(r'==', RESERVED),
     (r'=', RESERVED),
     (r'!=', RESERVED),

combinators.py

@@ -1,3 +1,5 @@
+import pdb;
+
 class Parser:
 	pass
 
@@ -6,16 +8,14 @@ def __init__(self, name, tag):
 		self.name = name
 		self.tag = tag
 
-	def __call__(self, tokens, pos):
+	def __call__(self, tokens, pos):	
 		if pos < len(tokens):
 			token = tokens[pos]
 			name, tag = token
 			if name == self.name and tag == self.tag:
 				return (token, pos+1)
 			else:
 				return None
-		else:
-			raise Exception("Unexpected eof")
 
 class Tag(Parser):
 	def __init__(self, tag):
@@ -26,24 +26,22 @@ def __call__(self, tokens, pos):
 			token = tokens[pos]
 			_, tag = token
 			return (token, pos+1) if tag is self.tag else None
-		else:
-			raise Exception("Unexpected eof")
 
 class Sequence(Parser):
 	def __init__(self, *parsers):
 		self.parsers = parsers
 
 	def __call__(self, tokens, pos):
-		cur_pos = pos
 		values = []
+		cur_pos = pos
 		for parser in self.parsers:
 			result = parser(tokens, cur_pos)
 			if result:
 				ast, cur_pos = result
 				values.append(ast)
 			else:
 				return None
-		return tuple(values), pos
+		return tuple(values), cur_pos
 
 class Or(Parser):
 	def __init__(self, *parsers):
@@ -98,6 +96,7 @@ def __init__(self, parser):
 
 	def __call__(self, tokens, pos):
 		result = self.parser(tokens,pos)
+		ast, pos = result
 		if result and pos == len(tokens):
 			return result
 		else:
@@ -112,19 +111,20 @@ def __call__(self, tokens, pos):
 		result = self.parser(tokens, pos)
 		if result:
 			ast, pos = result
-		else
+		else:
 			return None
 		def process_next(parsed):
 			sep_func, exp = parsed
-			return sep_fun(ast, exp)
+			return sep_func(ast, exp)
 		next_parser = Process(Sequence(self.separator, self.parser), process_next)
 		next_result = result
 
 		while next_result:
-			next_result = next_parser(tokens, result.pos)
+			next_result = next_parser(tokens, pos)
 			if next_result:
 				result = next_result
-		return next_result
+				ast, pos = result
+		return result
 
 if __name__ == "__main__":
 	b = Reserved("if", "RESERVED")

hello.cl

@@ -1,6 +1,8 @@
-n := 5;
-p := 1;
-while n > 0 do
-  p := p * n;
-  n := n - 1
-end
+var1 := (2 * (4 / 2)) + 5;
+var2 := 5 - 6;
+while var2 <= 0 do
+	var2 := var2 + 1
+end;
+finish := 0;
+if var2 > 0 :
+	finish := 1