(use-modules (ice-9 format))

(define (lexer)
  (define (scan)
    (do
      ((ch (read-char) (read-char)))
      ((or (eof-object? ch) (not (char-whitespace? ch))) ch)
    )
  )

  ; return is the **NEXT** which will use `(scan)`
  (define (cc return)
    (let loop ()
      (set! return
        (call/cc
          (lambda (resume-here)
            (set! cc resume-here)
            (return (scan))
          )
        )
      )
      (loop)
    )
  )

  (lambda () (call/cc cc))
)

(define (parser cb lexer)
  (define (E)
    (T)
    (format #t "begin [+-..]\n")
    (do
      ((next (lexer) (lexer)))
      ((not (or (equal? #\+ next) (equal? #\- next))))
      (begin (cb next) (T))
    )
    (format #t "ret-E\n")
  )

  (define (T)
    (S)
    (format #t "begin [*/..]\n")
    (do
      ((next (lexer) (lexer)))
      ((not (or (equal? #\* next) (equal? #\/ next))))
      (begin (cb next) (S))
    )
    (format #t "ret-T\n")
  )

  (define (S)
    (let ((next (lexer)))
      (cond
        ((char-numeric? next)
         (cb next))
        ((equal? #\( next)
         (cb next)
         (E)
         (let ((next2 (lexer)))
           (if (equal? #\) next2)
             (cb next2)
             (error "PARSE FAIL1")
           )
         ))
        ((eof-object? next) (begin (format #t "bye~") (exit)))
        (else (error "PARSE FAIL2"))
      )
    )
  )

  (E)
)

;(parser (lambda (ch) (format #t "parsed: ~c\n" ch)) (lexer))
(parser (lambda (ch) (format #t "parsed: ~c\n" ch)) read-char)