giles
728a91e49f
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 34s
Adds Go unary prefix operators per Go spec § Operators: +x -x !x ^x *p &v <-ch gp-parse-unary is recursive (so !!x and -^x chain correctly) and sits between gp-parse-expr and gp-parse-primary — unary therefore always binds tighter than any binary op without needing a unary entry in the precedence table. Symbols +, -, *, &, ^ are shared between unary and binary forms; the positional split (expression-start sees unary, mid-expression sees binary) disambiguates them cleanly with no lookback. Unary nodes are single-arg ast-app: (ast-app (ast-var OP) (list OPERAND)) parse 37/37, total 166/166. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
124 lines
4.0 KiB
Plaintext
124 lines
4.0 KiB
Plaintext
;; lib/go/parse.sx — Go parser. Tokenises via go-tokenize (lib/go/lex.sx),
|
|
;; builds canonical AST nodes per lib/guest/ast.sx, and uses
|
|
;; pratt-op-lookup from lib/guest/pratt.sx for operator-precedence climbing.
|
|
;;
|
|
;; Slices so far:
|
|
;; 1. Primary expressions — literal / identifier → ast-literal / ast-var
|
|
;; 2. Binary operators — Pratt precedence climbing against
|
|
;; go-precedence-table; binary application
|
|
;; emitted as (ast-app (ast-var OP) [LHS RHS]).
|
|
;;
|
|
;; The climbing loop is per-language (see lib/guest/pratt.sx header on why)
|
|
;; but the entry shape and lookup are shared.
|
|
;;
|
|
;; All scanner locals are gp- prefixed: SX host primitives silently shadow
|
|
;; guest-language defines.
|
|
|
|
(define
|
|
go-precedence-table
|
|
(list
|
|
(list "*" 5 :left)
|
|
(list "/" 5 :left)
|
|
(list "%" 5 :left)
|
|
(list "<<" 5 :left)
|
|
(list ">>" 5 :left)
|
|
(list "&" 5 :left)
|
|
(list "&^" 5 :left)
|
|
(list "+" 4 :left)
|
|
(list "-" 4 :left)
|
|
(list "|" 4 :left)
|
|
(list "^" 4 :left)
|
|
(list "==" 3 :left)
|
|
(list "!=" 3 :left)
|
|
(list "<" 3 :left)
|
|
(list "<=" 3 :left)
|
|
(list ">" 3 :left)
|
|
(list ">=" 3 :left)
|
|
(list "&&" 2 :left)
|
|
(list "||" 1 :left)))
|
|
|
|
(define
|
|
go-parse
|
|
(fn
|
|
(src)
|
|
(let
|
|
((gp-tokens (go-tokenize src)) (gp-idx 0))
|
|
(define gp-cur (fn () (nth gp-tokens gp-idx)))
|
|
(define gp-advance! (fn () (set! gp-idx (+ gp-idx 1))))
|
|
(define gp-tok-type (fn () (get (gp-cur) :type)))
|
|
(define gp-tok-value (fn () (get (gp-cur) :value)))
|
|
(define
|
|
gp-parse-primary
|
|
(fn
|
|
()
|
|
(let
|
|
((ty (gp-tok-type)) (v (gp-tok-value)))
|
|
(cond
|
|
(or
|
|
(= ty "int")
|
|
(= ty "float")
|
|
(= ty "imag")
|
|
(= ty "string")
|
|
(= ty "rune"))
|
|
(do (gp-advance!) (ast-literal v))
|
|
(= ty "ident")
|
|
(do (gp-advance!) (ast-var v))
|
|
:else nil))))
|
|
(define
|
|
gp-unary-ops
|
|
;; Go spec § Operators: prefix unary, all higher precedence than
|
|
;; any binary operator. <- is the channel receive form (send is a
|
|
;; statement, not an expression, so never appears here as binary).
|
|
(list "+" "-" "!" "^" "*" "&" "<-"))
|
|
(define
|
|
gp-parse-unary
|
|
(fn
|
|
()
|
|
(let ((tok (gp-cur)))
|
|
(cond
|
|
(and (= (get tok :type) "op")
|
|
(some (fn (u) (= u (get tok :value))) gp-unary-ops))
|
|
(do
|
|
(gp-advance!)
|
|
(let ((operand (gp-parse-unary)))
|
|
(cond
|
|
(= operand nil) nil
|
|
:else (ast-app (ast-var (get tok :value)) (list operand)))))
|
|
:else (gp-parse-primary)))))
|
|
(define
|
|
gp-parse-expr
|
|
(fn
|
|
(min-prec)
|
|
(let ((left (gp-parse-unary))) (gp-pratt-loop left min-prec))))
|
|
(define
|
|
gp-pratt-loop
|
|
(fn
|
|
(left min-prec)
|
|
(cond
|
|
(= left nil) nil
|
|
:else
|
|
(let
|
|
((tok (gp-cur)))
|
|
(cond
|
|
(not (= (get tok :type) "op"))
|
|
left
|
|
:else (let
|
|
((entry (pratt-op-lookup go-precedence-table (get tok :value))))
|
|
(cond
|
|
(= entry nil)
|
|
left
|
|
(< (pratt-op-prec entry) min-prec)
|
|
left
|
|
:else (do
|
|
(gp-advance!)
|
|
(let
|
|
((next-min (if (= (pratt-op-assoc entry) :left) (+ (pratt-op-prec entry) 1) (pratt-op-prec entry))))
|
|
(let
|
|
((right (gp-parse-expr next-min)))
|
|
(gp-pratt-loop
|
|
(ast-app
|
|
(ast-var (get tok :value))
|
|
(list left right))
|
|
min-prec)))))))))))
|
|
(gp-parse-expr 1))))
|