Racket regexp literal syntax

(define (read-hex-char in)
  (let ((c (peek-char in)))
    (case c
      [(#\0 #\1 #\2 #\3 #\4
        #\5 #\6 #\7 #\8 #\9
        #\a #\A #\b #\B #\c #\C
        #\d #\D #\e #\E #\f #\F) (read-char in)]
      [else (read-regexp-literal in)
            (raise-syntax-error #f "not a hexadecimal character" c)])))

(define (read-hex-escape in)
  (let* ([a (read-hex-char in)]
         [b (read-hex-char in)])
    (read (open-input-string (string #\# #\\ #\u a b)))))

(define (read-unicode-escape in)
  (let* ([a (read-hex-char in)]
         [b (read-hex-char in)]
         [c (read-hex-char in)]
         [d (read-hex-char in)])
    (read (open-input-string (string #\# #\\ #\u a b c d)))))

(define (read-regexp-literal in)
  (let ([ch (read-char in)])
    (case ch
      [(#\\) (let ([next (read-char in)])
               (case next
                 [(#\/) (cons next
                              (read-regexp-literal in))]
                 [(#\x) (cons (read-hex-escape in)
                              (read-regexp-literal in))]
                 [(#\u) (cons (read-unicode-escape in)
                              (read-regexp-literal in))]
                 [(#\n) (cons #\newline (read-regexp-literal in))]
                 [(#\r) (cons #\return  (read-regexp-literal in))]
                 [(#\t) (cons #\tab     (read-regexp-literal in))]
                 [(#\a) (cons #\u07     (read-regexp-literal in))]
                 [(#\e) (cons #\u1B     (read-regexp-literal in))]
                 [(#\f) (cons #\u0C     (read-regexp-literal in))]
                 [(#\v) (cons #\u0B     (read-regexp-literal in))]
                 [else  (list* ch next  (read-regexp-literal in))]))]
      [(#\/) null]
      [else  (cons ch (read-regexp-literal in))])))


(define (regexp-literal-readtable ch port src line col pos)
  (let* ([a (read-char port)]
         [b (read-char port)])
    (cond ((and (eq? a #\x) (eq? b #\/))
            (pregexp (apply string (read-regexp-literal port))))
          ((and (eq? a #\x) (eq? b #\"))
                     ;; TODO: should this be read or read/recursive?
            (pregexp (read/recursive port b #f #f)))
          (else
            (raise-syntax-error #f "unknown #p syntax" (string a b))))))

(current-readtable
  (make-readtable (current-readtable)
    #\p 'dispatch-macro regexp-literal-readtable))