We can parse function calls now.

diff --git a/mad b/mad
index 6b0eecd61cc4ab29885263dec5a1317b379bcaac..a508c96ad09b9ba492339f48288e352e71736847 100755 (executable)
--- a/mad
+++ b/mad
@@ -1,11 +1,13 @@
 #!/usr/bin/env python
 
-reserved = ('DIMENSION', 'FOR', 'OF', 'THROUGH', 'VALUES')
+reserved = ('CONDITIONAL', 'DIMENSION', 'END', 'FOR', 'FORMAT',
+            'FUNCTION', 'INTEGER', 'OF', 'PRINT', 'PROGRAM', 'READ',
+            'THROUGH', 'TO', 'TRANSFER', 'VALUES', 'VECTOR', 'WHENEVER')
 
 tokens = reserved + (
     'TAB', 'SEMI',
     'COMMA',
-    'NAME','INTEGER', 'FLOAT',
+    'NAME','INTNUM', 'FLOATNUM', 'FUNCALL',
     'LPAREN','RPAREN',
     'PLUS','MINUS','TIMES','DIVIDE','EQUALS',
     'NOT', 'OR', 'AND', 'THEN', 'EQV',
@@ -38,16 +40,18 @@ t_DIVIDE  = r'/'
 t_EQUALS  = r'='
 t_LPAREN  = r'\('
 t_RPAREN  = r'\)'
-t_FLOAT   = r'\d+\.\d*'
-t_INTEGER = r'\d+'
+t_FLOATNUM= r'\d+\.\d*'
+t_INTNUM  = r'\d+'
 
 reserved_map = { }
 for r in reserved:
     reserved_map[r] = r
 
 def t_NAME(t):
-    r'[a-zA-Z_][a-zA-Z0-9_]*'
+    r'[A-Z][A-Z0-9]*\.?'
     t.type = reserved_map.get(t.value, "NAME")
+    if t.type and t.value[-1] == '.':
+        t.type = 'FUNCALL'
     return t
 
 t_ignore = " \n"
@@ -105,6 +109,38 @@ def p_dimension_list_continue(t):
     'dimension_list : dimension_list COMMA NAME application'
     t[0] = t[1] + [[t[3], tuple(t[4])]]
 
+## END
+def p_end_of_program(t):
+    "statement : END OF PROGRAM"
+    t[0] = ('end_program')
+def p_end_of_conditional(t):
+    "statement : END OF CONDITIONAL"
+    t[0] = ('end_conditional')
+def p_end_of_functions(t):
+    "statement : END OF FUNCTION"
+    t[0] = ('end_function')
+
+## INTEGER
+def p_integer(t):
+    "statement : INTEGER varlist"
+    t[0] = ('integer',) + tuple(t[2])
+def p_varlist(t):
+    'varlist : NAME'
+    t[0] = [t[1]]
+def p_varlist_continue(t):
+    'varlist : varlist COMMA NAME'
+    t[0] = t[1] + [t[3]]
+
+## READ FORMAT
+def p_read_format(t):
+    "statement : READ FORMAT varlist"
+    t[0] = ('read',) + tuple(t[3])
+
+## PRINT FORMAT
+def p_print_format(t):
+    "statement : PRINT FORMAT varlist"
+    t[0] = ('print',) + tuple(t[3])
+
 ## THROUGH
 def p_through_for(t):
     'statement : THROUGH NAME COMMA FOR NAME EQUALS expression COMMA expression COMMA expression'
@@ -119,6 +155,25 @@ def p_map_continue(t):
     'value_list : value_list COMMA expression'
     t[0] = t[1] + [t[3]]
 
+## TRANSFER TO
+def p_transfer(t):
+    "statement : TRANSFER TO NAME"
+    t[0] = ('goto', t[3])
+
+## WHENEVER
+def p_whenever_simple(t):
+    'statement : WHENEVER expression COMMA statement'
+    t[0] = ('if', t[2], t[4])
+def p_whenever_complex(t):
+    'statement : WHENEVER expression'
+    t[0] = ('whenever', t[2], t[4])
+
+## VECTOR VALUES
+#def p_vector_values(t):
+#    "statement : VECTOR VALUES assignlist"
+#    t[0] = ('values',) + tuple(t[3])
+
+
 ## Assignment
 def p_statement_substitution(t):
     'statement : NAME EQUALS expression'
@@ -169,17 +224,21 @@ def p_expression_group(t):
     t[0] = t[2]
 
 def p_expression_integer(t):
-    'expression : INTEGER'
+    'expression : INTNUM'
     t[0] = ('integer', t[1])
 
 def p_expression_float(t):
-    'expression : FLOAT'
+    'expression : FLOATNUM'
     t[0] = ('float', t[1])
 
 def p_expression_subscript(t):
     'expression : NAME application'
     t[0] = ('variable', t[1], tuple(t[2]))
 
+def p_function_application(t):
+    'expression : FUNCALL application'
+    t[0] = ('apply', t[1], tuple(t[2]))
+
 def p_expression_application(t):
     "application : LPAREN inner_expression RPAREN"
     t[0] = t[2]
@@ -209,5 +268,6 @@ import sys, re
 source = sys.stdin.read()
 # Grotty hack to add end-of-statement delimiters
 source = re.sub("\n([A-Z]|\t)", " ;\n\\1", source).rstrip() + " ;\n"
-yacc.parse(source, debug=2)
-print cards
+yacc.parse(source, debug=1)
+for card in cards:
+    print card