146,000

2012-07-15 · 146,000

XML
CL-WHO
htout
CL-WHO
CL-WHO
WRITE-STRING
CL-WHO
CL-WHO
CL-WHO
Common Lisp
CL-WHO
*HTTP-STREAM*
CL-WHO
HTML
CL-WHO
WITH-HTML-OUTPUT
body
transformation rules
"foo" => (write-string "foo" s)
(:br) => (write-string "<br />" s)
HTML-MODE
:SGML
(:br) => (write-string "<br>" s)
NIL
(:td :bgcolor "red") => (write-string "<td bgcolor='red' />" s)
T
HTML-MODE
:XML
(:td :nowrap t) => (write-string "<td nowrap='nowrap' />" s)
HTML-MODE
:SGML
(:td :nowrap t) => (write-string "<td nowrap>" s)
NIL
(:td :nowrap nil) => (write-string "<td />" s)
"~A"
(:table :border 3) => (write-string "<table border='3' />" s)
princ
T
NIL
;; simplified example, see function CHECKBOX below
;; note that this form is not necessarily CONSTANTP in all Lisps

(:table :border (+ 1 2)) => (write-string "<table border='" s)
                              (princ (+ 1 2) s)
                              (write-string "' />" s)
(:table :border 0 :cellpadding 5 :cellspacing 5)
      => (write-string "<table border='0' cellpadding='5' cellspacing='5' />" s)
transformation rules
(:p "Paragraph") => (write-string "<p>Paragraph</p>" s)
(:p :class "foo" "Paragraph") => (write-string "<p class='foo'>Paragraph</p>" s)
(:p :class "foo" "One" " " "long" " " "sentence")
    => (write-string "<p class='foo'>One long sentence</p>" s)
(:p :class "foo" "Visit " (:a :href "http://www.cliki.net/" "CLiki"))
    => (write-string "<p class='foo'>Visit <a href='http://www.cliki.net/'>CLiki</a></p>" s)
LHTML
((:p) "Paragraph") => (write-string "<p>Paragraph</p>" s)
((:p :class "foo") "Paragraph") => (write-string "<p class='foo'>Paragraph</p>" s)
((:p :class "foo" :name "humpty-dumpty") "One" " " "long" " " "sentence")
    => (write-string "<p class='foo' name='humpty-dumpty'>One long sentence</p>" s)
((:p :class "foo") "Visit " ((:a :href "http://www.cliki.net/") "CLiki"))
    => (write-string "<p class='foo'>Visit <a href='http://www.cliki.net/'>CLiki</a></p>" s)
* (defun checkbox (stream name checked &optional value)
    (with-html-output (stream)
      (:input :type "checkbox" :name name :checked checked :value value)))

CHECKBOX
* (with-output-to-string (s) (checkbox s "foo" t))

 "<input type='checkbox' name='foo' checked='checked' />"
* (with-output-to-string (s) (checkbox s "foo" nil))

"<input type='checkbox' name='foo' />"
* (with-output-to-string (s) (checkbox s "foo" nil "bar"))

"<input type='checkbox' name='foo' value='bar' />"
* (with-output-to-string (s) (checkbox s "foo" t "bar"))

"<input type='checkbox' name='foo' checked='checked' value='bar' />"
:hr => (write-string "<hr />" s)
(str form1 form*)
(let ((result form1)) (when result (princ result s)))
form1
        (loop for i below 10 do (str i)) => 
        (loop for i below 10 do
           (let ((#:result i))
             (when <a href='#:result (princ '>:result (princ </a>:result *standard-output*))))
(fmt form*)
<||
というフォームは、
>||
(format s form*)
<||
というフォームに置換される。
>||
(loop for i below 10 do (fmt "~R" i)) => (loop for i below 10 do (format s "~R" i))
(esc form1 form*)
(let ((result form1)) (when result (write-string (escape-string result s))))
(htm form*)
transformation rules
(loop for i below 100 do (htm (:b "foo") :br))
    => (loop for i below 100 do (progn (write-string "<b>foo</b><br />" s)))
CL-WHO
HTML
XHTML
CL-WHO
:hr
:foobar
CL-WHO
CL-WHO
body
Syntax and Semantics
transformation rules
var
stream
stream
NIL
var
var
stream
prologue
NIL
prologue
T
prologue
*PROLOGUE*
CL-WHO
indent
indent
HTML
PRE
TEXTAREA
result*
forms
prologue
indent
    * (with-html-output (*standard-output* nil :prologue t)
        (:html (:body "Not much there"))
        (values))
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html><body>Not much there</body></html>
    * (with-html-output (*standard-output*)
        (:html (:body :bgcolor "white"
             "Not much there"))
        (values))
    <html><body bgcolor='white'>Not much there</body></html>
    * (with-html-output (*standard-output* nil :prologue t :indent t)
        (:html (:body :bgcolor "white"
                 "Not much there"))
        (values))
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    <html>
      <body bgcolor='white'>
        Not much there
      </body>
    </html>
WITH-HTML-OUTPUT
(defmacro with-html-output-to-string ((var &optional string-form
                                           &key (element-type 'character)
                                                prologue
                                                indent)
                                      &body body)
  "Transform the enclosed BODY consisting of HTML as s-expressions
into Lisp code which creates the corresponding HTML as a string."
  `(with-output-to-string (,var ,string-form :elementy-type ,element-type)
    (with-html-output (,var nil :prologue ,prologue :indent ,indent)
      ,@body)))
WITH-OUTPUT-TO-STRING
*STANDARD-OUTPUT*
WITH-HTML-OUTPUT
* (show-html-expansion (s)
    (:html
     (:body :bgcolor "white"
      (:table
       (:tr
        (dotimes (i 5)
          (htm (:td :align "left"
                (str i)))))))))
(LET ((S S))
  (PROGN
    (WRITE-STRING
      "<html><body bgcolor='white'><table><tr>" S)
    (DOTIMES (I 5)
      (PROGN
        (WRITE-STRING "<td align='left'>" S)
        (PRINC I S)
        (WRITE-STRING "</td>" S)))
    (WRITE-STRING "</tr></table></body></html>" S)))
#\'
#\"
WITH-HTML-OUTPUT
prologue
T
    "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"
strict
XML
CL-WHO
NIL
CL-WHO
*HTML-EMPTY-TAGS*


T
HTML
*HTML-EMPTY-TAG-AWARE-P*
    (:area :atop :audioscope :base :basefont :br :choose :col :frame
     :hr :img :input :isindex :keygen :left :limittext :link :meta
     :nextid :of :over :param :range :right :spacer :spot :tab :wbr)
NIL
XML
T
Syntax and Semantics
HTML-MODE
HTML
XHTML
:XML
(SETF (HTML-MODE) :SGML)
XML
HTML
SGML HTML
*prologue*
doctype string
HTML 4.01 transitional
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
SGML HTML
XHTML
string
test
HTML-MODE
:SGML
test
generalized boolean
*ESCAPE-CHAR-P*
Syntax and Semantics
ESC
    * (escape-string "<H&#252;hner> 'na&#239;ve'")
    "&lt;H&#xFC;hner&gt; &#x27;na&#xEF;ve&#x27;"
    * (with-html-output-to-string (s)
        (:b (esc "<H&#252;hner> 'na&#239;ve'")))
    "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"<b>&lt;H&#xFC;hner&gt; &#x27;na&#xEF;ve&#x27;</b>"
ESCAPED-STRING
ESCAPE-CHAR
test
    #'(lambda (char)
        (or (find char "<>&'\"")
            (> (char-code char) 127)))
ESCAPE-STRING
ESCAPE-CHAR
    (defun escape-string-minimal (string)
      "Escape only #\<, #\>, and #\& in STRING."
      (escape-string string :test #'(lambda (char) (find char "<>&"))))

    (defun escape-string-minimal-plus-quotes (string)
      "Like ESCAPE-STRING-MINIMAL but also escapes quotes."
      (escape-string string :test #'(lambda (char) (find char "<>&'\""))))

    (defun escape-string-iso-8859-1 (string)
      "Escapes all characters in STRING which aren't defined in ISO-8859-1."
      (escape-string string :test #'(lambda (char)
                                      (or (find char "<>&'\"")
                                          (> (char-code char) 255)))))

    (defun escape-string-iso-8859 (string)
      "Identical to ESCAPE-STRING-ISO-8859-1.  Kept for backward compatibility."
      (escape-string-iso-8859-1 string))

    (defun escape-string-all (string)
      "Escapes all characters in STRING which aren't in the 7-bit ASCII
    character set."
      (escape-string string :test #'(lambda (char)
                                      (or (find char "<>&'\"")
                                          (> (char-code char) 127)))))

    * (conc "This" " " "is" " " "a" " " "sentence")
    "This is a sentence"
    * (with-html-output-to-string (s)
        (:div :style (conc "padding:"
                           (format nil "~A" (+ 3 2)))
         "Foobar"))
    "<div style='padding:5'>Foobar</div>"
CL-WHO
LISP
tag
attr-list
body
body-fn
body-fn
    * (defmethod convert-tag-to-string-list ((tag (eql :red)) attr-list body body-fn)
        (declare (ignore attr-list))
        (nconc (cons "<font color='red'>" (funcall body-fn body)) (list "</font>"))) 
    ; Compiling LAMBDA (PCL::.PV-CELL. PCL::.NEXT-METHOD-CALL. TAG ATTR-LIST BODY BODY-FN): 
    ; Compiling Top-Level Form: 

    #<STANDARD-METHOD CONVERT-TAG-TO-STRING-LIST ((EQL :RED) T T T) {582B268D}>
    * (with-html-output (*standard-output*)
        (:red (:b "Bold and red")) 
        (values))
    <font color='red'><b>Bold and red</b></font>
    * (show-html-expansion (s)
        (:red :style "spiffy" (if (foo) (htm "Attributes are ignored")))) 

    (LET ((S S))
      (PROGN
       NIL
       (WRITE-STRING "<font color='red'>" S)
       (IF (FOO) (PROGN (WRITE-STRING "Attributes are ignored" S)))
       (WRITE-STRING "</font>" S)))
    * (defmethod convert-tag-to-string-list ((tag (eql :table)) attr-list body body-fn)
        (cond ((cdr (assoc :simple attr-list))
               (nconc (cons "<table"
                            (convert-attributes (remove :simple attr-list :key #'car)))
                      (list ">")
                      (loop for row in body
                            collect "<tr>"
                            nconc (loop for col in row
                                        collect "<td>"
                                        when (constantp col)
                                          collect (format nil "~A" col)
                                        else 
                                          collect col
                                        collect "</td>")
                            collect "</tr>")
                      (list "</table>")))
              (t

146,000

CL-WHO - Yet another Lisp markup language を訳してみた

注意

Abstract

Contents

Example usage

Download and installation

Support and mailing lists

Syntax and Semantics

The CL-WHO dictionary