highlight.scheme

diff --git a/autotests/html/highlight.scheme.html b/autotests/html/highlight.scheme.html index e83b790..a561179 100644 --- a/autotests/html/highlight.scheme.html +++ b/autotests/html/highlight.scheme.html @@ -1,193 +1,193 @@ highlight.scheme

 ; This is a test file to test kates scheme highlighting
 ; This is a comment
 
 ;; Another comment, usually used.
 ;BEGIN region marker
 ;; a vektor
 #(1 2 3 4 5)
 ;END region marker
 ;; this represents integer 28 (FIXME: does not work perfectly atm!)
 28 028 #e28 #i28       ;; Normal, normal, exact, inexact
 #b11100 #o34 #d28 #x1c ;; Bin, okt, dec, hex
 #oe34 #eo34            ;; combined.
 
 ;; char.
 (#\y #\space) ;; list: `y' space.
 (#\  #\\ #\)) ;; list of spaces, backslash and`)'.
 #\newline     ;; a newline-char
 #\NewLine     ;; another one :)
 
 "Hello, world" ;; a string
 
 "hoho, what do you
 want to do  ;; this is NO comment
 with that?"
 
 ;; R5RS definiert diese beiden.
 "Das ist \"in Anführungszeichen\" und mit \\ Backslash."
 
-(let ((x (+ 1 2)) (y "blah")) ;; `let' highlighting.
+(let ((x (+ 1 2)) (y "blah")) ;; `let' highlighting.
   (and (number? x)            ;; `and' highlighting.
        (string? y)))
 
-(let* ((x 2) (y (+ x 1))) ;; `let*' too.
+(let* ((x 2) (y (+ x 1))) ;; `let*' too.
   (or (negative? x)       ;; `or' anyways.
       (negative? y)))
 
 (do ((vec (make-vector 5)) ;; `do' you may guess!
-     (i 0 (+ i 1)))
-    ((= i 5) vec)
+     (i 0 (+ i 1)))
+    ((= i 5) vec)
   (vector-set! vec i i))
 
-(quasiquote ((+ 1 2) (unquote (+ 1 2))))
+(quasiquote ((+ 1 2) (unquote (+ 1 2))))
 ;; same as: `((+ 1 2) ,(+ 1 2))
 
 ;; see above.
-(quasiquote ((+ 1 2) (unquote-splicing (list 1 2 3))))
+(quasiquote ((+ 1 2) (unquote-splicing (list 1 2 3))))
 ;; same as: `((+ 1 2) ,@(+ 1 2))
 
 ;; not necessary.
 (quote ())
 
 (cond ((string? x) (string->symbol x)) ;; `cond' highlighting.
-      ((symbol? x) => (lambda (x) x))  ;; `=>' highlighting.
+      ((symbol? x) => (lambda (x) x))  ;; `=>' highlighting.
       (else ;; `else' highlighting.
        (error "Blah")))
 
 (case x ;; `case' highlighting.
   ((#t) 'true) ((#f) 'false)
   ((()) 'null)
   ((0) 'zero))
 
 ;; highlight `let-syntax' and `syntax-rules' .
 (let-syntax ((when (syntax-rules ()
                      ((when test stmt1 stmt2 ...)
                       ;; hl `begin' .
                       (if test (begin stmt1 stmt2 ...))))))
   (let ((if #t)) ;; here`if' is actually no keyword.
     (when if (set! if 'now)) ;; nor here.
     if))
 
 (letrec-syntax ...) ;; hl `letrec-syntax'.
 
-(define-syntax when
+(define-syntax when
   (syntax-rules ()
     ((when test stmt1 stmt2 ...)
      (if test (begin stmt1 stmt2 ...))))))
 
 ;; variable definitions.
-(define natural-numbers ;; hl `define' and the var name
+(define natural-numbers ;; hl `define' and the var name
   ;; endless stream of all natual numbers.
   (letrec ((next-cell    ;; hl `letrec'.
             (lambda (x)  ;; hl `lambda'.
               ;; hl `delay' .
-              (cons x (delay (next-cell (+ x 1)))))))
+              (cons x (delay (next-cell (+ x 1)))))))
     (next-cell 0)))
 
 ;; a procedure with unusual but allowed name.
-(define 1+
+(define 1+
   (lambda (x)
-    (+ x 1)))
+    (+ x 1)))
 
 ;; a predicate
-(define between?
+(define between?
   (lambda (x y z)
-    (if (and (>= x y) (<= x z))
+    (if (and (>= x y) (<= x z))
         #t ;; True
       #f))) ;; False.
 
 ;; imperative procedure
-(define set-something!
+(define set-something!
   (lambda (required-argument another-one . all-remaining-args)
     (set-car! another-one (lambda all-args
                             (set-cdr! required-argument
                                       (append all-remaining-args
                                               all-args))))))
 
-(define compose
+(define compose
   (lambda (f g)
     (lambda (x)
       (f (g x)))))
 
 ;; syntactical sugar for procedure-definitions.
-(define (compose f g)
+(define (compose f g)
   (lambda (x)
     (f (g x))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; NOW: Guile extensions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; procedure-generator.
-(define ((compose f g) x)
+(define ((compose f g) x)
   (f (g x)))
 
 ;; scheme doesn't say, which chars may be in variables...
 ;; At least: Guile accepts umlauts
-(define-private (timetr??? sprache) ;; hl `define-private'.
+(define-private (timetr??? sprache) ;; hl `define-private'.
   (list-dialekt? sprache))
 
-(define-public x #t)  ;; hl `define-public'.
-(define-module (foo bar)) ;; hl `define-module'.
-(define-macro (neither . exprs) ;; hl `define-macro'.
+(define-public x #t)  ;; hl `define-public'.
+(define-module (foo bar)) ;; hl `define-module'.
+(define-macro (neither . exprs) ;; hl `define-macro'.
   `(and ,@(map (lambda (x) `(not ,x)) exprs)))
 
-(defmacro neither exprs ;; `defmacro' as well.
+(defmacro neither exprs ;; `defmacro' as well.
   `(and ,@(map (lambda (x) `(not ,x)) exprs)))
 
 ;; hl, but I really don't know what this is supposed to do :-)
-(define-syntax-macro ...)
+(define-syntax-macro ...)
 
 ;; hl GOOPS-`defines'
-(define-method (foo bar (baz <vector>) qux) ...)
-(define-class <foo> ...)
-(define-generic foo)
-(define-accessor bar)
+(define-method (foo bar (baz <vector>) qux) ...)
+(define-class <foo> ...)
+(define-generic foo)
+(define-accessor bar)
 
 ;; Keywords!
 (blah #:foo 33 #:bar 44)
 
 ;; another convention for symbols:
 #{foo}#
 
 #{a
 few
 lines}#
 
 #{4711}#
 
 ;; more chars.
 #\nul #\nl #\esc #\bs #\bel #\syn #\ack #\sp ;; etc, utc, itc, oops (this is boring)
 
 #!
  guile block-comment.
 !#
 
 ;; now, a bit hairy:
 #! comment !#
 still comment!!!
 !#
 'now-no-comment-anymore
 
 ;; more precise:
 #! comment !#
 still comment
 !# still comment!
 !#
 'now-no-comment-anymore
 
-(while (> foo 10) ;; Highlight `while'.
-  (set! foo (- foo 1))
+(while (> foo 10) ;; Highlight `while'.
+  (set! foo (- foo 1))
   (catch #t ;; Highlight `catch'.
     (lambda () (display foo))
     (lambda (key . args)
       (if (eq? key 'system-error)
           (break) ;; Highlight `break'.
         (continue))))) ;; Highlight `continue'.

diff --git a/data/syntax/scheme.xml b/data/syntax/scheme.xml index 19a9941..749a913 100644 --- a/data/syntax/scheme.xml +++ b/data/syntax/scheme.xml @@ -1,394 +1,394 @@ - + <= < = => >= > - / *,* *) + #\nul #\soh #\stx #\etx #\eot #\enq #\ack #\bel #\bs #\ht #\nl #\vt #\np #\cr #\so #\si #\dle #\dc1 #\dc2 #\dc3 #\dc4 #\nak #\syn #\etb #\can #\em #\sub #\esc #\fs #\gs #\rs #\us #\space #\sp #\newline #\nl #\tab #\ht #\backspace #\bs #\return #\cr #\page #\np #\null #\nul define define* define-accessor define-class defined? define-generic define-macro define-method define-module define-private define-public define*-public define-reader-ctor define-syntax define-syntax-macro defmacro defmacro* defmacro*-public abs acos and angle append applymap asin assoc assq assv atan begin boolean? break caaaar caaadr caaar caadar caaddr caadr caar cadaar cadadr cadar caddar cadddr caddr cadr call/cc call-with-current-continuation call-with-input-file call-with-output-file call-with-values car case catch cdaaar cdaadr cdaar cdadar cdaddr cdadr cdar cddaar cddadr cddar cdddar cddddr cdddr cddr cdr ceiling char-alphabetic? char-ci>=? char-ci>? char-ci=? char-ci<=? char-downcase char->integer char>=? char>? char=? char? char-lower-case? char<?c char<=? char-numeric? char-ready? char-upcase char-upper-case? char-whitespace? close-input-port close-output-port complex? cond cons continue cos current-input-port current-output-port denominator display do dynamic-wind else eof-object? eq? equal? eqv? eval even? exact->inexact exact? exp expt floor force for-each gcd har-ci<? if imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment lambda lcm length let let* letrec letrec-syntax let-syntax list->string list list? list-ref list-tail load log magnitude make-polar make-rectangular make-string make-vector max member memq memv min modulo negative? newline not null-environment null? number? number->string numerator odd? open-input-file open-output-file or output-port? pair? peek-char port? positive? procedure? quotient rational? rationalize read-char read real? real-part remainder reverse round scheme-report-environment set-car! set-cdr! sin sqrt string-append string-ci>=? string-ci>? string-ci=? string-ci<=? string-ci<? string-copy string-fill! string>=? string>? string->list string->number string->symbol string=? string string? string-length string<=? string<? string-ref string-set! substring symbol->string symbol? syntax-rules tan transcript-off transcript-on truncate values vector-fill! vector->listlist->vector vector vector? vector-length vector-ref vector-set! while with-input-from-file with-output-to-file write-char write zero? - - + + - - - - - - + + + + + +