[parenscript-devel] error using parenscript 2.5
Canhua
dreameration at gmail.com
Sat Jan 5 10:33:35 UTC 2013
Following is errors when loading ps-loop.lisp
cl-user> (load "/root/vendor-src/parenscript/src/lib/ps-loop.lisp")
STYLE-WARNING: redefining PARENSCRIPT::AS-KEYWORD in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::LOOP-CASE in DEFMACRO
STYLE-WARNING: redefining PARENSCRIPT::ERR in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::PUSH-TOKENS in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::PEEK in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::EAT in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::FOR-FROM in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::FOR-= in DEFUN
STYLE-WARNING: redefining PARENSCRIPT:FOR-IN in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::FOR-ON in DEFUN
; file: /root/vendor-src/parenscript/src/lib/ps-loop.lisp
; in: DEFUN FOR-CLAUSE
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; (:FROM (PARENSCRIPT::FOR-FROM PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; (:= (PARENSCRIPT::FOR-= PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; ((:IN :ACROSS) (PARENSCRIPT:FOR-IN PARENSCRIPT::PLACE
PARENSCRIPT::STATE))
; (:ON (PARENSCRIPT::FOR-ON PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; (:OF (PARENSCRIPT::FOR-KEYS-OF PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; (OTHERWISE
; (ERROR "FOR ~s ~s is not valid in PS-LOOP." PARENSCRIPT::PLACE
; PARENSCRIPT::TERM)))
;
; caught ERROR:
; during macroexpansion of
; (LOOP-CASE TERM
; (:FROM #)
; ...).
; Use *BREAK-ON-SIGNALS* to intercept:
;
; OF isn't a recognized loop keyword.
; (LET ((PARENSCRIPT::PLACE (PARENSCRIPT::EAT PARENSCRIPT::STATE))
; (PARENSCRIPT::TERM (PARENSCRIPT::EAT PARENSCRIPT::STATE :ATOM)))
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; (:FROM (PARENSCRIPT::FOR-FROM PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; (:= (PARENSCRIPT::FOR-= PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; ((:IN :ACROSS) (PARENSCRIPT:FOR-IN PARENSCRIPT::PLACE
PARENSCRIPT::STATE))
; (:ON (PARENSCRIPT::FOR-ON PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; (:OF (PARENSCRIPT::FOR-KEYS-OF PARENSCRIPT::PLACE PARENSCRIPT::STATE))
; (OTHERWISE
; (ERROR "FOR ~s ~s is not valid in PS-LOOP." PARENSCRIPT::PLACE
; PARENSCRIPT::TERM))))
;
; caught STYLE-WARNING:
; The variable PLACE is defined but never used.
;
; caught STYLE-WARNING:
; The variable TERM is defined but never used.
;
; compilation unit finished
; caught 1 ERROR condition
; caught 2 STYLE-WARNING conditions
STYLE-WARNING: redefining PARENSCRIPT::FOR-CLAUSE in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::A-WITH-CLAUSE in DEFUN
; file: /root/vendor-src/parenscript/src/lib/ps-loop.lisp
; in: DEFUN ACCUMULATE
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::KIND
; ((:SUM :COUNT) 0)
; ((:MAXIMIZE :MINIMIZE) NIL)
; ((:COLLECT :APPEND) 'PARENSCRIPT:[])
; ((:MAP) 'PARENSCRIPT:{}))
;
; caught ERROR:
; during macroexpansion of
; (LOOP-CASE KIND
; (# 0)
; ...).
; Use *BREAK-ON-SIGNALS* to intercept:
;
; MAP isn't a recognized loop keyword.
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::KIND
; (:SUM `(INCF ,PARENSCRIPT:VAR ,PARENSCRIPT::ITEM))
; (:COUNT `(UNLESS (NULL ,PARENSCRIPT::ITEM) (INCF ,PARENSCRIPT:VAR)))
; (:MINIMIZE
; `(SETF ,PARENSCRIPT:VAR
; (IF #
; ,PARENSCRIPT::ITEM
; #)))
; (:MAXIMIZE
; `(SETF ,PARENSCRIPT:VAR
; (IF #
; ,PARENSCRIPT::ITEM
; #)))
; (:COLLECT `((PARENSCRIPT:@ ,PARENSCRIPT:VAR :PUSH) ,PARENSCRIPT::ITEM))
; (:APPEND
; `(SETF ,PARENSCRIPT:VAR (APPEND ,PARENSCRIPT:VAR ,PARENSCRIPT::ITEM)))
; (:MAP
; (DESTRUCTURING-BIND
; (PARENSCRIPT::KEY PARENSCRIPT::VAL)
; PARENSCRIPT::ITEM
; `(SETF # ,PARENSCRIPT::VAL))))
;
; caught ERROR:
; during macroexpansion of
; (LOOP-CASE KIND
; (:SUM `#)
; ...).
; Use *BREAK-ON-SIGNALS* to intercept:
;
; MAP isn't a recognized loop keyword.
; (DEFUN PARENSCRIPT::ACCUMULATE
; (PARENSCRIPT::KIND PARENSCRIPT::ITEM PARENSCRIPT:VAR
; PARENSCRIPT::STATE)
; (WHEN (NULL PARENSCRIPT:VAR)
; (WHEN (AND (PARENSCRIPT::IMPLICIT-ACCUM-KIND
PARENSCRIPT::STATE) (NOT #))
; (ERROR
; "PS-LOOP encountered illegal ~a: ~a was already declared,
and there can only be one kind of implicit accumulation per loop."
; PARENSCRIPT::KIND
; (PARENSCRIPT::IMPLICIT-ACCUM-KIND PARENSCRIPT::STATE)))
; (UNLESS (PARENSCRIPT::IMPLICIT-ACCUM-VAR PARENSCRIPT::STATE)
; (SETF # #)
; (SETF # PARENSCRIPT::KIND))
; (SETF PARENSCRIPT:VAR
; (PARENSCRIPT::IMPLICIT-ACCUM-VAR PARENSCRIPT::STATE)))
; (LET ((PARENSCRIPT::INITIAL
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::KIND
; #
; #
; #
; #)))
; (PUSH (LIST PARENSCRIPT:VAR PARENSCRIPT::INITIAL)
; (PARENSCRIPT::PROLOGUE PARENSCRIPT::STATE)))
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::KIND
; (:SUM `(INCF ,PARENSCRIPT:VAR ,PARENSCRIPT::ITEM))
; (:COUNT `(UNLESS (NULL ,PARENSCRIPT::ITEM) (INCF ,PARENSCRIPT:VAR)))
; (:MINIMIZE `(SETF ,PARENSCRIPT:VAR #))
; (:MAXIMIZE `(SETF ,PARENSCRIPT:VAR #))
; (:COLLECT `((PARENSCRIPT:@ ,PARENSCRIPT:VAR :PUSH)
,PARENSCRIPT::ITEM))
; (:APPEND `(SETF ,PARENSCRIPT:VAR #))
; (:MAP
; (DESTRUCTURING-BIND
; (PARENSCRIPT::KEY PARENSCRIPT::VAL)
; PARENSCRIPT::ITEM
; `(SETF #)))))
; --> PROGN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA PARENSCRIPT::ACCUMULATE
; (PARENSCRIPT::KIND PARENSCRIPT::ITEM PARENSCRIPT:VAR
PARENSCRIPT::STATE)
; (BLOCK PARENSCRIPT::ACCUMULATE
; (WHEN (NULL PARENSCRIPT:VAR)
; (WHEN (AND # #)
; (ERROR
; "PS-LOOP encountered illegal ~a: ~a was already
declared, and there can only be one kind of implicit accumulation per
loop."
; PARENSCRIPT::KIND #))
; (UNLESS (PARENSCRIPT::IMPLICIT-ACCUM-VAR PARENSCRIPT::STATE)
; (SETF #)
; (SETF #))
; (SETF PARENSCRIPT:VAR #))
; (LET ((PARENSCRIPT::INITIAL #))
; (PUSH (LIST PARENSCRIPT:VAR PARENSCRIPT::INITIAL)
; (PARENSCRIPT::PROLOGUE PARENSCRIPT::STATE)))
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::KIND
; (:SUM `(INCF ,PARENSCRIPT:VAR ,PARENSCRIPT::ITEM))
; (:COUNT `(UNLESS # #))
; (:MINIMIZE `(SETF #))
; (:MAXIMIZE `(SETF #))
; (:COLLECT `(# ,PARENSCRIPT::ITEM))
; (:APPEND `(SETF #))
; (:MAP (DESTRUCTURING-BIND # PARENSCRIPT::ITEM `#)))))
;
; caught STYLE-WARNING:
; The variable ITEM is defined but never used.
;
; compilation unit finished
; caught 2 ERROR conditions
; caught 1 STYLE-WARNING condition
STYLE-WARNING: redefining PARENSCRIPT::ACCUMULATE in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::REPEAT-CLAUSE in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::WHILE-CLAUSE in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::UNTIL-CLAUSE in DEFUN
; file: /root/vendor-src/parenscript/src/lib/ps-loop.lisp
; in: DEFUN BODY-CLAUSE
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; ((:IF :WHEN :UNLESS)
; (LET* ((PARENSCRIPT::TEST-FORM #)
; (PARENSCRIPT::SEQS #)
; (PARENSCRIPT::ALTS #))
; (LOOP PARENSCRIPT:WHILE (EQ # :AND)
; DO (PARENSCRIPT::EAT PARENSCRIPT::STATE) (PUSH #
;
PARENSCRIPT::SEQS))
; (WHEN (EQ # :ELSE)
; (PARENSCRIPT::EAT PARENSCRIPT::STATE)
; (PUSH # PARENSCRIPT::ALTS)
; (LOOP PARENSCRIPT:WHILE #
; DO # #))
; (WHEN (EQ # :END) (PARENSCRIPT::EAT PARENSCRIPT::STATE))
; (IF (NULL PARENSCRIPT::ALTS)
; `(,# ,PARENSCRIPT::TEST-FORM ,@#)
; `(IF ,#
; #
; #))))
; ((:SUM :COLLECT :APPEND :COUNT :MINIMIZE :MAXIMIZE)
; (PARENSCRIPT::ACCUMULATE PARENSCRIPT::TERM
; (PARENSCRIPT::EAT PARENSCRIPT::STATE)
; (PARENSCRIPT::EAT PARENSCRIPT::STATE
:IF :INTO)
; PARENSCRIPT::STATE))
; (:MAP
; (LET ((PARENSCRIPT::KEY #))
; (MULTIPLE-VALUE-BIND (PARENSCRIPT::VAL PARENSCRIPT::VALP)
; (PARENSCRIPT::EAT PARENSCRIPT::STATE :IF :TO)
; (UNLESS PARENSCRIPT::VALP #)
; (PARENSCRIPT::ACCUMULATE :MAP # # PARENSCRIPT::STATE))))
; (:DO (PARENSCRIPT::EAT PARENSCRIPT::STATE :PROGN))
; (:RETURN
; `(RETURN-FROM ,(PARENSCRIPT::NAME PARENSCRIPT::STATE)
; ,(PARENSCRIPT::EAT PARENSCRIPT::STATE)))
; (OTHERWISE (PARENSCRIPT::ERR "a PS-LOOP keyword" PARENSCRIPT::TERM)))
;
; caught ERROR:
; during macroexpansion of
; (LOOP-CASE TERM
; (# #)
; ...).
; Use *BREAK-ON-SIGNALS* to intercept:
;
; IF isn't a recognized loop keyword.
; (DEFUN PARENSCRIPT::BODY-CLAUSE (PARENSCRIPT::TERM PARENSCRIPT::STATE)
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; ((:IF :WHEN :UNLESS)
; (LET* (# # #)
; (LOOP PARENSCRIPT:WHILE #
; DO # #)
; (WHEN # # # #)
; (WHEN # #)
; (IF #
; `#
; `#)))
; ((:SUM :COLLECT :APPEND :COUNT :MINIMIZE :MAXIMIZE)
; (PARENSCRIPT::ACCUMULATE PARENSCRIPT::TERM
; (PARENSCRIPT::EAT PARENSCRIPT::STATE)
; (PARENSCRIPT::EAT
PARENSCRIPT::STATE :IF :INTO)
; PARENSCRIPT::STATE))
; (:MAP
; (LET (#)
; (MULTIPLE-VALUE-BIND # # # #)))
; (:DO (PARENSCRIPT::EAT PARENSCRIPT::STATE :PROGN))
; (:RETURN
; `(RETURN-FROM ,(PARENSCRIPT::NAME PARENSCRIPT::STATE)
; ,(PARENSCRIPT::EAT PARENSCRIPT::STATE)))
; (OTHERWISE (PARENSCRIPT::ERR "a PS-LOOP keyword" PARENSCRIPT::TERM))))
; --> PROGN SB-INT:NAMED-LAMBDA
; ==>
; #'(SB-INT:NAMED-LAMBDA PARENSCRIPT::BODY-CLAUSE
; (PARENSCRIPT::TERM PARENSCRIPT::STATE)
; (BLOCK PARENSCRIPT::BODY-CLAUSE
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; ((:IF :WHEN :UNLESS)
; (LET* #
; #
; #
; #
; #))
; ((:SUM :COLLECT :APPEND :COUNT :MINIMIZE :MAXIMIZE)
; (PARENSCRIPT::ACCUMULATE PARENSCRIPT::TERM # # PARENSCRIPT::STATE))
; (:MAP
; (LET #
; #))
; (:DO (PARENSCRIPT::EAT PARENSCRIPT::STATE :PROGN))
; (:RETURN `(RETURN-FROM ,# ,#))
; (OTHERWISE
; (PARENSCRIPT::ERR "a PS-LOOP keyword" PARENSCRIPT::TERM)))))
;
; caught STYLE-WARNING:
; The variable TERM is defined but never used.
;
; caught STYLE-WARNING:
; The variable STATE is defined but never used.
;
; compilation unit finished
; caught 1 ERROR condition
; caught 2 STYLE-WARNING conditions
STYLE-WARNING: redefining PARENSCRIPT::BODY-CLAUSE in DEFUN
; file: /root/vendor-src/parenscript/src/lib/ps-loop.lisp
; in: DEFUN CLAUSE
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; (:NAMED
; (SETF (PARENSCRIPT::NAME PARENSCRIPT::STATE)
; (PARENSCRIPT::EAT PARENSCRIPT::STATE :SYMBOL)))
; (:WITH (PARENSCRIPT::A-WITH-CLAUSE PARENSCRIPT::STATE))
; (:FOR (PARENSCRIPT::FOR-CLAUSE PARENSCRIPT::STATE))
; (:REPEAT (PARENSCRIPT::REPEAT-CLAUSE PARENSCRIPT::STATE))
; (:WHILE (PARENSCRIPT::WHILE-CLAUSE PARENSCRIPT::STATE))
; (:UNTIL (PARENSCRIPT::UNTIL-CLAUSE PARENSCRIPT::STATE))
; (:FINALLY
; (PUSH (PARENSCRIPT::EAT PARENSCRIPT::STATE :PROGN)
; (PARENSCRIPT::FINALLY PARENSCRIPT::STATE)))
; (OTHERWISE
; (PUSH (PARENSCRIPT::BODY-CLAUSE PARENSCRIPT::TERM PARENSCRIPT::STATE)
; (PARENSCRIPT::BODY PARENSCRIPT::STATE))))
;
; caught ERROR:
; during macroexpansion of
; (LOOP-CASE TERM
; (:NAMED #)
; ...).
; Use *BREAK-ON-SIGNALS* to intercept:
;
; NAMED isn't a recognized loop keyword.
; (LET ((PARENSCRIPT::TERM (PARENSCRIPT::EAT PARENSCRIPT::STATE :ATOM)))
; (PARENSCRIPT::LOOP-CASE PARENSCRIPT::TERM
; (:NAMED (SETF # #))
; (:WITH (PARENSCRIPT::A-WITH-CLAUSE PARENSCRIPT::STATE))
; (:FOR (PARENSCRIPT::FOR-CLAUSE PARENSCRIPT::STATE))
; (:REPEAT (PARENSCRIPT::REPEAT-CLAUSE PARENSCRIPT::STATE))
; (:WHILE (PARENSCRIPT::WHILE-CLAUSE PARENSCRIPT::STATE))
; (:UNTIL (PARENSCRIPT::UNTIL-CLAUSE PARENSCRIPT::STATE))
; (:FINALLY
; (PUSH (PARENSCRIPT::EAT PARENSCRIPT::STATE :PROGN)
; (PARENSCRIPT::FINALLY PARENSCRIPT::STATE)))
; (OTHERWISE
; (PUSH (PARENSCRIPT::BODY-CLAUSE PARENSCRIPT::TERM PARENSCRIPT::STATE)
; (PARENSCRIPT::BODY PARENSCRIPT::STATE)))))
;
; caught STYLE-WARNING:
; The variable TERM is defined but never used.
;
; compilation unit finished
; caught 1 ERROR condition
; caught 1 STYLE-WARNING condition
STYLE-WARNING: redefining PARENSCRIPT::CLAUSE in DEFUN
STYLE-WARNING: redefining PARENSCRIPT::PARSE-PS-LOOP in DEFUN
On Sat, Jan 5, 2013 at 2:46 PM, Canhua <dreameration at gmail.com> wrote:
> hi,
>
> I am using quicklisp to load parenscript 2.5, and encounter the following error:
>
> Error while invoking #<compile-op (:verbose nil) {1008483323}>
> on #<cl-source-file "parenscript" "src" "lib" "ps-loop">
> [Condition of type asdf:compile-error]
>
>
> What does it mean ?
>
>
> Thanks
More information about the parenscript-devel
mailing list