;; SIlex unit test

(use srfi-13 setup-api silex test)


(define make-tok
  (lambda (tok-type lexeme line . attr)
    (cond ((null? attr)
	   (vector tok-type line lexeme))
	  ((null? (cdr attr))
	   (vector tok-type line lexeme (car attr)))
	  (else
	   (vector tok-type line lexeme (car attr) (cadr attr))))))


(define parse-spec-char
  (lambda (lexeme line)
    (make-tok char-tok lexeme line newline-ch)))

(define parse-digits-char
  (lambda (lexeme line)
    (let* ((num (substring lexeme 1 (string-length lexeme)))
	   (n (string->number num)))
      (make-tok char-tok lexeme line n))))

(define parse-quoted-char
  (lambda (lexeme line)
    (let ((c (string-ref lexeme 1)))
      (make-tok char-tok lexeme line (char->integer c)))))

(define parse-ordinary-char
  (lambda (lexeme line)
    (let ((c (string-ref lexeme 0)))
      (make-tok char-tok lexeme line (char->integer c)))))

(define extract-id
  (lambda (s)
    (let ((len (string-length s)))
      (substring s 1 (- len 1)))))

(define parse-id
  (lambda (lexeme line)
    (make-tok id-tok lexeme line (string-downcase lexeme) lexeme)))

(define parse-id-ref
  (lambda (lexeme line)
    (let* ((orig-name (extract-id lexeme))
	   (name (string-downcase orig-name)))
    (make-tok subst-tok lexeme line name orig-name))))

(define parse-power-m
  (lambda (lexeme line)
    (let* ((len (string-length lexeme))
	   (substr (substring lexeme 1 (- len 1)))
	   (m (string->number substr))
	   (range (cons m m)))
      (make-tok power-tok lexeme line range))))

(define parse-power-m-inf
  (lambda (lexeme line)
    (let* ((len (string-length lexeme))
	   (substr (substring lexeme 1 (- len 2)))
	   (m (string->number substr))
	   (range (cons m 'inf)))
      (make-tok power-tok lexeme line range))))

(define parse-power-m-n
  (lambda (lexeme line)
    (let ((len (string-length lexeme)))
      (let loop ((comma 2))
	(if (char=? (string-ref lexeme comma) #\,)
	    (let* ((sub1 (substring lexeme 1 comma))
		   (sub2 (substring lexeme (+ comma 1) (- len 1)))
		   (m (string->number sub1))
		   (n (string->number sub2))
		   (range (cons m n)))
	      (make-tok power-tok lexeme line range))
	    (loop (+ comma 1)))))))

(run (csi -n -R silex -e "'(lex \"regexp.l\" \"regexp.l.scm\" (quote counters) (quote line))'"))


(load "regexp.l.scm")


(define lexer-error error)


(define (run-lexer s)
  (if (string? s)
      (begin (lexer-init 'string s)
	     (let recur ((ax '()))
	       (let ((c (lexer)))
		 (if (equal? eof-tok (vector-ref c 0)) (reverse ax) (recur (cons (vector-ref c 2) ax))))))
      (else (error 'run-lexer "bad argument type; not a string" s)) ))


(test "numeric regexp lexer test"
      `("-"
	"?"
	"("
	"("
	"{decimal}"
	"+"
	"\\."
	"("
	"{decimal}"
	"+"
	")"
	"?"
	")"
	"|"
	"("
	"\\."
	"{decimal}"
	"+"
	")"
	")"
	"("
	"["
	"e"
	"E"
	"]"
	"("
	"[-"
	"+"
	"]"
	")"
	"?"
	"{decimal}"
	"+"
	")"
	"?")
      
      (run-lexer "-?(({decimal}+\\.({decimal}+)?)|(\\.{decimal}+))([eE]([-+])?{decimal}+)?"))

(test-exit)