Fix script syntax

src/main.c

@@ -92,11 +92,16 @@ void script()
 
     Lexer_lex(lexer, '\n');
     LEXER_DELETE(lexer);
-    if (Tokens_top(tokens) == NULL) return;
 
-    struct Object *const program = parse(tokens);
+    struct Object *program = NULL;
+
+    while (Tokens_top(tokens)) {
+        program = Object_new_pair(parse(tokens), program);
+    }
     TOKENS_DELETE(tokens);
 
+    if (program == NULL) return;
+
     struct Object *const environment = Object_new_pair(NULL, NULL);
     syntax_script(program, environment);
 }

src/syntax.c

@@ -20,7 +20,7 @@ struct Object *syntax_script(
     struct Object *args,
     struct Object *const environment
 ) {
-    return eval(args, environment);
+    return syntax_begin(args, environment);
 }
 
 /*******************

tests/arcana/builtin.scm

@@ -1,4 +1,3 @@
-(begin
 (assert-true (null? (arcana/builtin 'foobar)))
 
 ; Testing some builtin procedures for sanity
@@ -48,4 +47,3 @@
 (assert-true (procedure? (arcana/builtin 'display)))
 (assert-true (procedure? (arcana/builtin 'displayln)))
 (assert-true (procedure? (arcana/builtin 'newline)))
-)

tests/arcana/parse.scm

@@ -1,4 +1,3 @@
-(begin
 (assert-equal
   '(displayln (+ 123 456))
   (arcana/parse
@@ -35,4 +34,3 @@
       (cons 'TOKEN_NUM           "78")
       (cons 'TOKEN_ROUND_CLOSE   ")")
       (cons 'TOKEN_ROUND_CLOSE   ")"))))
-)

tests/arcana/tokenize.scm

@@ -1,4 +1,3 @@
-(begin
 (assert-equal '() (arcana/tokenize ""))
 (assert-equal '() (arcana/tokenize "   "))
 ;(assert-equal '() (arcana/tokenize "\n"))
@@ -47,4 +46,3 @@
     (cons 'TOKEN_NUM         "1")
     (cons 'TOKEN_ROUND_CLOSE ")")
     (cons 'TOKEN_ROUND_CLOSE ")")))
-)

tests/arcana/typeof.scm

@@ -1,4 +1,3 @@
-(begin
 (assert-equal 'null      (arcana/typeof '()))
 (assert-equal 'procedure (arcana/typeof +))
 (assert-equal 'pair      (arcana/typeof (cons 123 456)))
@@ -7,4 +6,3 @@
 (assert-equal 'symbol    (arcana/typeof 'foo))
 (assert-equal 'string    (arcana/typeof "foo"))
 (assert-equal 'number    (arcana/typeof 123))
-)

tests/arithm_ops.scm

@@ -1,5 +1,4 @@
-(begin
+;;; = ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;;; = ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal #true  (= 123))
 (assert-equal #true  (= 123 123))
 (assert-equal #false (= 123 456))
@@ -13,18 +12,17 @@
 (assert-equal #false (= 123 123 456 123))
 (assert-equal #false (= 123 123 123 456))
 
-  ;;; + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal 0    (+))
 (assert-equal 123  (+ 123))
 (assert-equal 11   (+ 1 10))
 (assert-equal 111  (+ 1 10 100))
 (assert-equal 1111 (+ 1 10 100 1000))
 
-  ;;; - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal 0 (- 0))
 ;(assert-equal -123 (- 123))
 (assert-equal 99 (- 100 1))
 (assert-equal 97 (- 100 1 2))
 (assert-equal 94 (- 100 1 2 3))
 (assert-equal 90 (- 100 1 2 3 4))
-)

tests/basic_data_structs.scm

@@ -1,12 +1,10 @@
-(begin
+;;; car ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;;; car ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal 123 (car (cons 123 456)))
 
-  ;;; cdr ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; cdr ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal 456 (cdr (cons 123 456)))
 
-  ;;; list ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; list ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal '()        (list))
 (assert-equal '(123)     (list 123))
 (assert-equal '(123 456) (list 123 456))
-)

tests/equiv.scm

@@ -1,5 +1,4 @@
-(begin
+;;; equal? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;;; equal? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; No args
 (assert-true  (equal?))
 ; A single arg
@@ -52,4 +51,3 @@
 (assert-false (equal? 'foo 'foo 'bar))
 (assert-false (equal? "foo" "foo" "bar"))
 (assert-false (equal? 123 123 789))
-)

tests/logic_ops.scm

@@ -1,5 +1,4 @@
-(begin
+;; not ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;; not ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (not '()))
 (assert-false (not #true))
 (assert-true  (not #false))
@@ -8,4 +7,3 @@
 (assert-false (not "foo"))
 (assert-false (not 123))
 (assert-false (not (cons 123 456)))
-)

tests/syntax.scm

@@ -1,11 +1,10 @@
-(begin
+;;; begin ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;;; begin ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal '() (begin))
 (assert-equal 123 (begin 123))
 (assert-equal 456 (begin 123 456))
 (assert-equal 789 (begin 123 456 789))
 
-  ;;; define ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; define ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal
   '(123 579)
   (begin
@@ -20,12 +19,12 @@
     (define x 456)
     (list old x)))
 
-  ;;; if ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; if ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal 123 (if #true 123 456))
 (assert-equal 123 (if "foo" 123 456))
 (assert-equal 456 (if #false 123 456))
 
-  ;;; quote ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; quote ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal '+     (quote +))
 (assert-equal '+     '+)
 (assert-equal '()    (quote ()))
@@ -44,4 +43,3 @@
 (assert-equal 123    '123)
 (assert-equal '(cons 123 456) (quote (cons 123 456)))
 (assert-equal '(cons 123 456) '(cons 123 456))
-)

tests/type_conv.scm

@@ -1,14 +1,12 @@
-(begin
+;;; number->string ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;;; number->string ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal "123"   (number->string 123))
 ;(assert-equal "-123"  (number->string -123))
 (assert-equal "1e240" (number->string 123456 16))
 
-  ;;; string->symbol ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; string->symbol ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;(assert-equal '||  (string->symbol ""))
 ;(assert-equal '| | (string->symbol " "))
 (assert-equal 'foo (string->symbol "foo"))
 
-  ;;; symbol->string ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; symbol->string ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-equal "foo" (symbol->string 'foo))
-)

tests/type_preds.scm

@@ -1,5 +1,4 @@
-(begin
+;;; boolean? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-  ;;; boolean? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (boolean? +))
 (assert-false (boolean? '()))
 (assert-true  (boolean? #true))
@@ -10,7 +9,7 @@
 (assert-false (boolean? 123))
 (assert-false (boolean? (cons 123 456)))
 
-  ;;; char? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; char? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (char? +))
 (assert-false (char? '()))
 (assert-false (char? #true))
@@ -21,7 +20,7 @@
 (assert-false (char? 123))
 (assert-false (char? (cons 123 456)))
 
-  ;;; null? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; null? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (null? +))
 (assert-true  (null? '()))
 (assert-false (null? #true))
@@ -32,7 +31,7 @@
 (assert-false (null? 123))
 (assert-false (null? (cons 123 456)))
 
-  ;;; number? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; number? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (number? +))
 (assert-false (number? '()))
 (assert-false (number? #true))
@@ -43,7 +42,7 @@
 (assert-true  (number? 123))
 (assert-false (number? (cons 123 456)))
 
-  ;;; pair? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; pair? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (pair? +))
 (assert-false (pair? '()))
 (assert-false (pair? #true))
@@ -54,7 +53,7 @@
 (assert-false (pair? 123))
 (assert-true  (pair? (cons 123 456)))
 
-  ;;; procedure? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; procedure? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-true  (procedure? +))
 (assert-false (procedure? '()))
 (assert-false (procedure? #true))
@@ -65,7 +64,7 @@
 (assert-false (procedure? 123))
 (assert-false (procedure? (cons 123 456)))
 
-  ;;; string? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; string? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (string? +))
 (assert-false (string? '()))
 (assert-false (string? #true))
@@ -76,7 +75,7 @@
 (assert-false (string? 123))
 (assert-false (string? (cons 123 456)))
 
-  ;;; symbol? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; symbol? ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (assert-false (symbol? +))
 (assert-false (symbol? '()))
 (assert-false (symbol? #true))
@@ -86,4 +85,3 @@
 (assert-false (symbol? "foo"))
 (assert-false (symbol? 123))
 (assert-false (symbol? (cons 123 456)))
-)