Cleanups and grammar update

Author: FrankC01

bootstrap/fing.defs

@@ -3,92 +3,93 @@
 ; {} optional - zero or more
 ; [] zero or one
 ; 'term' terminal
-; non-term (no quotes) - non terminal
-; reg_ex(...) - regular expression
+; NON-TERMINAL
+; reg_ex(...) - regular
 
-S =: module
+S =: MODULE
 
-module =: 'module' symbol {i_decls} {decltypes}
+MODULE =: 'module' SYMBOL {IDECLS} {DECLTYPES}
 
-idecls =: 'include' (idecl_list | symbol_type)
-idelc_list =: '[' symbol {[,] symbol} ']'
+IDECLS =: 'include' (IDECL_LIST | SYMBOL)
 
-decl_types =: {var_decl | func_decl}
+IDELC_LIST =: '[' SYMBOL {[,] SYMBOL} ']'
 
-var_decl =: 'var' symbol_type [expression]
+DECLTYPES =: {VAR_DECL | FUNC_DECL}
 
-func_decl =: 'func' symbol_type symbol_list {expression}
+VAR_DECL =: 'var' SYMBOL_TYPE [EXPRESSION]
 
-expression =: literal
-			| symbol_type
-			| collection
-			| func_call
-			| if_expr
-			| partial expr
-			| group_expr
-			| let_expr
-			| match_expr
-			| lambda_expr
+FUNC_DECL =: 'func' SYMBOL_TYPE SYMBOL_LIST {EXPRESSION}
 
-func_call =: func_prefix expression {expression}
-func_prefix =: symbol_type ":"
+EXPRESSION =: LITERAL
+			| SYMBOL_TYPE
+			| COLLECTION
+			| FUNC_CALL
+			| IF_EXPR
+			| PARTIAL EXPR
+			| GROUP_EXPR
+			| LET_EXPR
+			| MATCH_EXPR
+			| LAMBDA_EXPR
 
-; Partials are interesting:
-; 1. If the symbol type is func reference and argument counts align, then it becomes a call
-; 2. If the symbol type is func reference and arg count in partial is less, it's a partial declaration
-; 3. If the symbol type is lambda reference and argument counts align, then it becomes a call
-; 4. If the symbol type is lambda reference and arg count in partial is less, it's a partial declaration
-; 5. Otherwise they are partial invocations
+FUNC_CALL =: FUNC_PREFIX EXPRESSION {EXPRESSION}
 
-partial_expr =: "(" (func_prefix | symbol_type) {expression} ")"
+PARTIAL_EXPR =: "(" SYMBOL_TYPE {EXPRESSION} ")"
 
-group_expr =: "@(" expression {expression} ")"
+GROUP_EXPR =: "@(" EXPRESSION {EXPRESSION} ")"
 
-let_expr =: "let" [symbol_type] "[" symbol_type expression {symbol_type expression} "]" expression
+LET_EXPR =: "let" [SYMBOL_TYPE] "[" SYMBOL_TYPE EXPRESSION {SYMBOL_TYPE EXPRESSION} "]" EXPRESSION
 
-match_expr =: 'match' [symbol_type] expression match_pair
+MATCH_EXPR =: 'match' [SYMBOL_TYPE] EXPRESSION MATCH_PAIR
 
-match_pair =: '|' expression expression {match_pair}
-			| ':default' expression
+MATCH_PAIR =: '|' EXPRESSION EXPRESSION {MATCH_PAIR}
+			| ':default' EXPRESSION
 
-; Lambdas my be interesting:
-; 1. If the body has not references to funcargs, letargs, letresult it's straight up
-; 2. Otherwise it is a closure. Closures need free variable management:
-;	1. Each free variable inserts into the begining of the declared symbol_list
-;	2. It needs to imbue those free vars at the point of declaration
+LAMBDA_EXPR =: '^' SYMBOL_LIST EXPRESSION
 
-lambda_expr =: '^' symbol_list expression
+COLLECTION 	=: MAP_COLLECTION
+			| LIST_COLLECTION
+			| VECTOR_COLLECTION
+			| SET_COLLECTION
 
-symbol_list =: "[" "]"
-			| "[" symbol_type {[,] symbol_type} "]"
-
-symbol_type =: symbol 							; foo
-			| reg_ex([a-zA-Z][a-zA-Z0-9_]+!)	; fo_o!
-			| reg_ex([a-zA-Z][a-zA-Z0-9_]+\?)	; f_oo?
-
-symbol =: reg_ex([a-zA-Z]([a-zA-Z0-9_]*)?)
-
-collection =: map_collection
-			| list_collection
-			| vector_collection
-			| set_collection
-
-map_collection =: "{" expression expression {[,] expression expression} "}"
+MAP_COLLECTION =: "{" EXPRESSION EXPRESSION {[,] EXPRESSION EXPRESSION} "}"
 				| "{" "}"
 
-list_collection =: "[" expression {[,] expression } "]"
+LIST_COLLECTION =: "[" EXPRESSION {[,] EXPRESSION } "]"
 				| "[" "]"
 
-set_collection =: "#{" expression {[,] expression} "}"
+SET_COLLECTION =: "#{" EXPRESSION {[,] EXPRESSION} "}"
 				| "#{" "}"
 
-vector_collection =: "<" expression {[,] expression} ">"
+VECTOR_COLLECTION =: "<" EXPRESSION {[,] EXPRESSION} ">"
 				| "<" ">"
 
-literal =: integer 	; 1234
-		| real		; 0.1, 19.52, 1.39489384938493849384983
-		| hex		; 0x9ab5
-		| bit 		; 0b01010101
-		| string 	; "Something in quotes"
-		| keyword   ; :master
-		| char 		; 'c', 'd', '1'
+LITERAL =: INTEGER
+		| REAL
+		| HEX
+		| BIT
+		| STRING
+		| KEYWORD
+		| CHAR
+
+SYMBOL_LIST =: "[" "]"
+			| "[" SYMBOL_TYPE {[,] SYMBOL_TYPE} "]"
+
+SYMBOL_TYPE =: SYMBOL
+			| reg_ex("[a-zA-Z][a-zA-Z0-9_]+!")
+			| reg_ex("[a-zA-Z][a-zA-Z0-9_]+\?")
+
+SYMBOL 		=: reg_ex("[a-zA-Z]([a-zA-Z0-9_]*)?")
+
+FUNC_PREFIX =: SYMBOL_TYPE ":"
+
+INTEGER 	=:	regex("-?[0-9]+")
+REAL 		=: 	regex("-?(?:0|[1-9]\d*)\.\d*(?:[eE][+\-]?\d+)?")
+HEX 		=: 	regex("0[xX][0-9a-fA-F]+")
+BIT 		=: 	regex("0[bB][0-1]+")
+STRING		=: 	regex("\"(.|\n)*?\"")
+KEYWORD 	=: 	regex(":[a-zA-Z]([a-zA-Z0-9_]*)?")
+CHAR 		=:  regex("\'[0-9a-zA-Z]*?\'")
+
+COMMENT 	=:	regex(";.*")
+IGNORES 	=: 	regex("[,\t ]+")
+NLCR 		=:  regex("(\r\n|[\r\n])")

bootstrap/test.foidl

@@ -134,12 +134,13 @@ var :private ast_type {
         TYPE    :private}
 }
 
-; Sets of things for utility
-var collection_set #{:empty_collection :collection}
-var coltype_set #{:list :map :set :vector}
-var littype_set #{:string :keyword :integer :real_number :hex :bin :char}
-var decl_set    #{:function :variable :include :module}
-var ref_set     #{:literalref :funcref :varref}
+; Convenience sets for predicates
+
+var collection_set  #{:empty_collection :collection}
+var coltype_set     #{:list :map :set :vector}
+var littype_set     #{:string :keyword :integer :real_number :hex :bin :char}
+var decl_set        #{:function :variable :include :module}
+var ref_set         #{:literalref :funcref :varref}
 
 var name_set #{
     :module
@@ -156,12 +157,9 @@ var invalid_set #{
     :function
     :variable
     :include
-    :module
-    :match_exprref}
+    :module}
 
-; Function:
-; Description:
-; Syntax:
+; Predicates
 
 func is_decl [node]
     getd: decl_set get: node TYPE false
@@ -186,17 +184,9 @@ func has_exprs? [node]
             false
             true
 
-; Function:
-; Description:
-; Syntax:
-
 func is_not_decl? [node]
     not: getd: decl_set get: node TYPE false
 
-; Function:
-; Description:
-; Syntax:
-
 func is_funclambda_args? [node]
     ?: getd: collection_set get: node TYPE false
         ?: getd: coltype_set get: node COLLTYPE false
@@ -213,12 +203,13 @@ func is_funclambda_args? [node]
 ;   token   - The source file token (has sourcepos, etc.)
 
 func type_instance [typekw source token]
-    let typeinst [] getd: ast_type typekw nil
+    let typeinst []
+        getd: ast_type typekw nil
     ?: nil?: typeinst
         failWith: extend: "Unrecognized AST type " typekw
         let []
             map_extend!:                            ; Extend new instance with token
-                extendKV: typeinst SOURCE source   ; Create new instance and extend
+                extendKV: typeinst SOURCE source    ; Create new instance and extend
                 TOKEN token
 
 ; Function: type_with_exprs
@@ -232,29 +223,45 @@ func type_with_exprs [typekw source token]
     let node [] type_instance: typekw source token
     map_extend!: node EXPRS list_inst!:
 
+; Function: type_literal_ref
+; Description: Constructs a literal reference storing the
+; base type in modules literal map
+
 func type_literal_ref [mmodule token source]
-    let ttype [] get: token :token_type
-    let lmap [] get: get: mmodule LITERALS ttype
-    let lref [] type_instance: :literalref source token
-    map_extend!: lref LITTYPE ttype
-    map_extend!: lmap get: token :token_str lref
+    let ttype []
+        get: token :token_type
+    ; Create the literal reference
+    let lref []
+        map_extend!:
+            type_instance: :literalref source token
+            LITTYPE ttype
+    ; Add to the global (module) literal map
+    map_extend!:
+        get: get: mmodule LITERALS ttype
+        get: token :token_str lref
+    ; Return the literal reference
     lref
 
 ; Function:
 ; Description:
 ; Syntax:
 
 func :private gen_literal_map [mnode]
-        fold:
-            ^[acc x]
-                map_extend!: acc x map_inst!:
-            map_inst!: littype_set
+    fold:
+        ^[acc x]
+            map_extend!: acc x map_inst!:
+        map_inst!: littype_set
+
+; Function:
+; Description:
+; Syntax:
 
 func type_module_create [source token]
-    let mnode [] type_with_exprs: :module source token
+    let mnode []
+        type_with_exprs: :module source token
+
     map_extend!:
         map_extend!:
             mnode
-            LITERALS
-            gen_literal_map: mnode
+            LITERALS gen_literal_map: mnode
         EXTERNS map_inst!:

docs/grammer.txt

@@ -23,7 +23,13 @@ module foidlc
 include cmdline
 include handler
 
-var version "foidlc version 0.01.00  (Self-hosted)"
+var version "foidlc version 0.01.00 (Self-hosted)"
+
+; Function: execute
+; Description: Core compiler execution. If version (-v)
+; was not specified on the command line, either
+; a header generation (-g) or compilation (-c) is requested
+; Help (-h) is handled by cmdlineparse
 
 func :private execute [argv cmap]
 	?: get: cmap :version
@@ -32,5 +38,8 @@ func :private execute [argv cmap]
 			build_handler_and_run: cmap
 			cmap
 
+; Function: main
+; Description: Main entry point to program/application
+
 func main [argv]
 	execute: argv cmdlineparse: argv

foidlc/fsrc/ast_type.foidl

@@ -24,8 +24,14 @@ module simple
 func fauxfunc [a b]
     +: a b
 
+func noarg []
+    9
+
 func foo [arg1]
-    let a [b 5]
-        +: arg1 b
+    match arg1
+    | 1     fauxfunc: %0 9
+    | 2     let a [b 5]
+                +: arg1 noarg:
+
+
 
-    fauxfunc: a 9