* boot/parser.boot ($sawParenthesizedHead): Remove.

	(bpReturnType): Likewise.
	(bpBeginParameterList): Likewise.
	(bpEndParameterList): Likewise.
	(bpBeginDefinition): Likewise.
	(bpDefinition): Adjust.
	(bpVariable): Likewise.

2 files changed, 10 insertions, 70 deletions

diff --git a/src/boot/parser.boot b/src/boot/parser.boot
index 52169219..eb070e8a 100644
--- a/src/boot/parser.boot
+++ b/src/boot/parser.boot
@@ -46,10 +46,6 @@ namespace BOOTTRAN
 module parser
  
 
-++ true when the current function definition has its parameters 
-++ written round parenthesis.
-$sawParenthesizedHead := false
-
 bpFirstToken()==
       $stok:=
           if null $inputStream
@@ -842,15 +838,10 @@ bpExit()==
             bpPush bfExit (bpPop2(),bpPop1()))
               or true)
 
-++ returns true if the next token introduces a definition.
-bpBeginDefinition() ==
-  bpEqPeek "DEF" or 
-    $sawParenthesizedHead and bpEqPeek "COLON"
-
 bpDefinition()==
         a:=bpState()
         bpExit() =>
-             bpBeginDefinition() =>
+             bpEqPeek "DEF" =>
                 bpRestore a
                 bpDef()
              bpEqPeek "TDEF" =>
@@ -867,19 +858,8 @@ bpStoreName()==
   $op := first $stack
   $wheredefs := nil
   $typings := nil
-  $returnType := true           -- assume we may return anything
   true
 
-bpReturnType() ==
-  -- a return type is acceptable for a function definition only
-  -- if its parameters are written in round parenthesis.  
-  -- In particular, we reject the situation `foo x:Integer == ...'
-  $sawParenthesizedHead and bpEqKey "COLON" =>
-    bpApplication() or bpTrap()
-    $returnType := bpPop1()
-    true
-  true
- 
 bpDef() ==  
   bpName() and bpStoreName() and bpDefTail()
  
@@ -893,9 +873,9 @@ bpSimpleDefinitionTail() ==
 
 ++ Parse the remaining of a compound definition.
 bpCompoundDefinitionTail() ==
-  bpVariable()  and bpReturnType()  and
-    bpEqKey "DEF" and (bpWhere() or bpTrap())
-      and bpPush %Definition(bpPop3(),bpPop2(),bpPop1())
+  bpVariable() and 
+    bpEqKey "DEF" and (bpWhere() or bpTrap()) and 
+      bpPush %Definition(bpPop3(),bpPop2(),bpPop1())
 
 
 ++ Parse the remainding of a definition.  When we reach this point
@@ -1090,19 +1070,9 @@ bpBoundVariablelist()==
      else bpColonName() and bpPush bfColonAppend(nil,bpPop1())
  
 
-++ Mark the start of parameter list enclosed in round parenthesis
-bpBeginParameterList() ==
-  $sawParenthesizedHead := false
-  true
-
-++ Mark the end of parameter list enclosed in round parenthesis
-bpEndParameterList() ==
-  $sawParenthesizedHead := true
-
 bpVariable()==
-  bpBeginParameterList() and
     bpParenthesized function bpBoundVariablelist and
-       bpPush bfTupleIf bpPop1() and bpEndParameterList()
+       bpPush bfTupleIf bpPop1()
          or bpBracketConstruct function bpPatternL
                 or bpName() or bpConstTok()
  
diff --git a/src/boot/strap/parser.clisp b/src/boot/strap/parser.clisp
index fd1472d2..36bece77 100644
--- a/src/boot/strap/parser.clisp
+++ b/src/boot/strap/parser.clisp
@@ -9,8 +9,6 @@
 
 (PROVIDE "parser")
 
-(DEFPARAMETER |$sawParenthesizedHead| NIL)
-
 (DEFUN |bpFirstToken| ()
   (DECLARE (SPECIAL |$ttok| |$stok| |$inputStream|))
   (PROGN
@@ -872,11 +870,6 @@
                 (|bpPush| (|bfExit| (|bpPop2|) (|bpPop1|))))
            T)))
 
-(DEFUN |bpBeginDefinition| ()
-  (DECLARE (SPECIAL |$sawParenthesizedHead|))
-  (OR (|bpEqPeek| 'DEF)
-      (AND |$sawParenthesizedHead| (|bpEqPeek| 'COLON))))
-
 (DEFUN |bpDefinition| ()
   (PROG (|a|)
     (RETURN
@@ -885,8 +878,7 @@
         (COND
           ((|bpExit|)
            (COND
-             ((|bpBeginDefinition|)
-              (PROGN (|bpRestore| |a|) (|bpDef|)))
+             ((|bpEqPeek| 'DEF) (PROGN (|bpRestore| |a|) (|bpDef|)))
              ((|bpEqPeek| 'TDEF)
               (PROGN (|bpRestore| |a|) (|bpTypeAliasDefition|)))
              ((|bpEqPeek| 'MDEF) (PROGN (|bpRestore| |a|) (|bpMdef|)))
@@ -894,25 +886,13 @@
           (#0# (PROGN (|bpRestore| |a|) NIL)))))))
 
 (DEFUN |bpStoreName| ()
-  (DECLARE (SPECIAL |$returnType| |$typings| |$wheredefs| |$op|
-                    |$stack|))
+  (DECLARE (SPECIAL |$typings| |$wheredefs| |$op| |$stack|))
   (PROGN
     (SETQ |$op| (CAR |$stack|))
     (SETQ |$wheredefs| NIL)
     (SETQ |$typings| NIL)
-    (SETQ |$returnType| T)
     T))
 
-(DEFUN |bpReturnType| ()
-  (DECLARE (SPECIAL |$returnType| |$sawParenthesizedHead|))
-  (COND
-    ((AND |$sawParenthesizedHead| (|bpEqKey| 'COLON))
-     (PROGN
-       (OR (|bpApplication|) (|bpTrap|))
-       (SETQ |$returnType| (|bpPop1|))
-       T))
-    ('T T)))
-
 (DEFUN |bpDef| () (AND (|bpName|) (|bpStoreName|) (|bpDefTail|)))
 
 (DEFUN |bpDDef| () (AND (|bpName|) (|bpDefTail|)))
@@ -922,8 +902,7 @@
        (|bpPush| (|%ConstantDefinition| (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpCompoundDefinitionTail| ()
-  (AND (|bpVariable|) (|bpReturnType|) (|bpEqKey| 'DEF)
-       (OR (|bpWhere|) (|bpTrap|))
+  (AND (|bpVariable|) (|bpEqKey| 'DEF) (OR (|bpWhere|) (|bpTrap|))
        (|bpPush| (|%Definition| (|bpPop3|) (|bpPop2|) (|bpPop1|)))))
 
 (DEFUN |bpDefTail| ()
@@ -1114,18 +1093,9 @@
     ('T
      (AND (|bpColonName|) (|bpPush| (|bfColonAppend| NIL (|bpPop1|)))))))
 
-(DEFUN |bpBeginParameterList| ()
-  (DECLARE (SPECIAL |$sawParenthesizedHead|))
-  (PROGN (SETQ |$sawParenthesizedHead| NIL) T))
-
-(DEFUN |bpEndParameterList| ()
-  (DECLARE (SPECIAL |$sawParenthesizedHead|))
-  (SETQ |$sawParenthesizedHead| T))
-
 (DEFUN |bpVariable| ()
-  (OR (AND (|bpBeginParameterList|)
-           (|bpParenthesized| #'|bpBoundVariablelist|)
-           (|bpPush| (|bfTupleIf| (|bpPop1|))) (|bpEndParameterList|))
+  (OR (AND (|bpParenthesized| #'|bpBoundVariablelist|)
+           (|bpPush| (|bfTupleIf| (|bpPop1|))))
       (|bpBracketConstruct| #'|bpPatternL|) (|bpName|) (|bpConstTok|)))
 
 (DEFUN |bpAssignVariable| ()