kallithea Files · rhodecode/public/js/mode/scheme/index.html

Files @ 9dd726706178

Branch filter:

Location: kallithea/rhodecode/public/js/mode/scheme/index.html

9dd726706178 2.2 KiB text/html Show Annotation Show as Raw Download as Raw

Bradley M. Kuhn

Complete copyright notices for web interface; change footer to link to them.

The original copyright notice found in the footer was not accurate as it
included only one of the many copyright holders in this project. This change
creates an "about" page, which currently contains just the copyright and
license information. It links to repository for additional potential copyright
holders not listed on the about page.

Unlisted contributors are mentioned in template comments.

Html links for Kallithea is fixed and we link to Conservancy.

Display of version information in the footer is improved.

<!doctype html>
<html>
  <head>
    <meta charset="utf-8">
    <title>CodeMirror: Scheme mode</title>
    <link rel="stylesheet" href="../../lib/codemirror.css">
    <script src="../../lib/codemirror.js"></script>
    <script src="scheme.js"></script>
    <style>.CodeMirror {background: #f8f8f8;}</style>
    <link rel="stylesheet" href="../../doc/docs.css">
  </head>
  <body>
    <h1>CodeMirror: Scheme mode</h1>
    <form><textarea id="code" name="code">
; See if the input starts with a given symbol.
(define (match-symbol input pattern)
  (cond ((null? (remain input)) #f)
    ((eqv? (car (remain input)) pattern) (r-cdr input))
    (else #f)))

; Allow the input to start with one of a list of patterns.
(define (match-or input pattern)
  (cond ((null? pattern) #f)
    ((match-pattern input (car pattern)))
    (else (match-or input (cdr pattern)))))

; Allow a sequence of patterns.
(define (match-seq input pattern)
  (if (null? pattern)
      input
      (let ((match (match-pattern input (car pattern))))
    (if match (match-seq match (cdr pattern)) #f))))

; Match with the pattern but no problem if it does not match.
(define (match-opt input pattern)
  (let ((match (match-pattern input (car pattern))))
    (if match match input)))

; Match anything (other than '()), until pattern is found. The rather
; clumsy form of requiring an ending pattern is needed to decide where
; the end of the match is. If none is given, this will match the rest
; of the sentence.
(define (match-any input pattern)
  (cond ((null? (remain input)) #f)
    ((null? pattern) (f-cons (remain input) (clear-remain input)))
    (else
     (let ((accum-any (collector)))
       (define (match-pattern-any input pattern)
         (cond ((null? (remain input)) #f)
           (else (accum-any (car (remain input)))
             (cond ((match-pattern (r-cdr input) pattern))
                   (else (match-pattern-any (r-cdr input) pattern))))))
       (let ((retval (match-pattern-any input (car pattern))))
         (if retval
         (f-cons (accum-any) retval)
         #f))))))
</textarea></form>
    <script>
      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {});
    </script>

    <p><strong>MIME types defined:</strong> <code>text/x-scheme</code>.</p>

  </body>
</html>