User:Wladek92/lisp


;; source: https://en.wikipedia.org/wiki/Format_(Common_Lisp)
;; ide   : https://www.jdoodle.com/execute-clisp-online/
;;
(print  (+ 2 3) )
;; meta character ~ (tilde)
;; ~[prefixParameters][modifiers]directiveType

;; passage a la ligne 
(format t "~C~C" #\return #\linefeed)
;; the FORMAT control ~% prints a newline (!).
(format t "Hello world.~%")

;; Prints "1 + 2 = 3" to the standard output and returns ``NIL''.
(format T "calcul simple: 10 + 20 = ~d~%" 30) 
;; format binaire
(format T "binaire simple pour ~d: ~b~%" 13 13) 
;; padding a gauche 
(format T "padding gauche sur 8 char: ~8,'0b~%" 5)

;; V pour longueur variable passée dans parameterlist
(let ((number-of-digits 6))
  (declare (type (integer 0 *) number-of-digits))
  (format T "padd left variable 6 char: ~v,'0b~%" number-of-digits 5))
  
(defun print-as-hexadecimal (number-to-format number-of-digits)
  "Prints the NUMBER-TO-FORMAT in the hexadecimal system (radix 16),
   left-padded with zeros to at least NUMBER-OF-DIGITS."
  (declare (type number        number-to-format))
  (declare (type (integer 0 *) number-of-digits))
  (format T "hexa format using local defun print-as-hexadecimal: ~v,'0x~%" number-of-digits number-to-format))

(print-as-hexadecimal 12 2)  

;; Directive conditionnelle  
;; Prints "none selected".
(format T "~#[none selected~;one selected: ~a~;two selected: ~a and ~a~:;more selected: ~@{~a~^, ~}~]~%")

;; Prints "one selected: BUNNY".
(format T "~#[none selected~;one selected: ~a~;two selected: ~a and ~a~:;more selected: ~@{~a~^, ~}~]~%" 'bunny)

;; Prints "two selected: BUNNY and PIGEON".
(format T "~#[none selected~;one selected: ~a~;two selected: ~a and ~a~:;more selected: ~@{~a~^, ~}~]~%" 'bunny 'pigeon)

;; Prints "more selected: BUNNY, PIGEON, MOUSE".
(format T "~#[none selected~;one selected: ~a~;two selected: ~a and ~a~:;more selected: ~@{~a~^, ~}~]~%" 'bunny 'pigeon 'mouse)  

;;@ modifier: always with a number's sign
;; ...A CLARIFIER...
(format T "@ modifier for always sign: ~@b~%" 5)
  
;;TYPE de directive
(format T "répétition de 5 char: ~5~~%" )

(setq *print-level* 102 *print-length* 5)
(format T "10 ~@[ print nil level = ~D~]~%" *print-level* *print-length*) 
(format nil "11 ~@[ print nil level = ~D~]~%" *print-level* *print-length*) 
(print (format nil "12 ~@[ print nil level = ~D~]~%" *print-level* *print-length*) )

(setq *print-level* nil *print-length* 5)
(print (format nil "13 ~@[ print nil level = ~D~]~@[ print length = ~D~]~%" *print-level* *print-length*) )

;; syntaxe plurielle  des que différent de 1
;;(format T "Cannot 00 call with argument~P~%" )  NOK il manque arg
(format T "~%Cannot 200 call with argument~P" 0 )  ;;with arguments bizarre 0 pluriel
(format T "~%Cannot 201 call with argument~P ~D" 0 0 )  ;; 0 pluriel?, 0 apres
(format T "~%Cannot 202 call with ~D argument~P" 0 0 )  ;; 0 pluriel?, 0 avant

(format T "~%Cannot 203 call with argument~P" 1 )  ;; OK singulier non figuré
(format T "~%Cannot 204 call with argument~P ~D" 1 1 )  ;; sing , 1 nommé apres
(format T "~%Cannot 205 call with ~D argument~P" 1 1 )  ;; singulier, 1 nommé navant


(format T "~%Cannot 206 call with argument~P" 2 )  ;; OK plural, non figuré
(format T "~%Cannot 206a call with argument~P ~D" 2 11 12)  ;; pluriel, figuré, 2 apres
(format T "~%Cannot 206b call with ~D argument~P" 2 10 11)  ;; pluriel, figuré,  avant

(format T "~%Cannot 207 call with argument~P" -10 )  ;; négatif pluriel
(format T "~%Cannot 207a call with argument~P ~S" -10 'suite... )  ;; négatif pluriel, suivant

(format T "~%Cannot 208 call with ~D argument~P" 1 1 )
(format T "~%Cannot 209 call with ~D argument~P~%" 3 3 )
(format T "~S : ~S a ~S argument~:P obligatoire~:P~%" 'module12 'func11 5 1);; 5 +extra ignored
(format T "~S : ~S a ~S argument~:P obligatoire~:P" 'module13 'func01 1 1);; 1 +extra ignored

(format T "~%Cannot 01 call with ~#[no arg~:;several args~]" )
(format T "~%Cannot 01 call with ~#[no arg~:;several args~]~%" 35503 "DEPART" )
;; il faut 2 arg
;;@ modifier: Only processes the clause if the format argument is T, otherwise skips it.
;;                            3 3
(format T "Cannot 02 call on ~D~@[ or more~] argument~P~%" 3 3  )
;; argument nil
;;                            0 nil
(format T "Cannot 03 call on ~D~@[ or more~] argument~P~%" 0 *print-level* nil)

(format T "Cannot 04 call ~S on ~D~@[ or more~] argument~P~%" "DEPART" 2 *print-level* 10)
;; syntaxe combinée   Cannot call "DEPART" on 6 
;; @ modifier: Only processes the clause [ if the format argument is T, otherwise skips it. 

;;(format T "Cannot 05 call ~S on ~D~@[ or more~] argument~P ~%" "DEPART" 0 *print-level*  )
   
   
(format T "600 Listing of compilation of file ~A~%on ~A by ~A, version ~A~%"
 'monfichier.txt '22.06.50 'Shimoun.Zoher '3.4.5.00 )  
(format T "600a Listing de compilation du fichier ~A~%le ~A par ~A, version ~A~%"
 'monfichier.txt '22.06.50 'Shimoun.Zoher '3.4.5.00 ) 
 
(format T "610 ~S from ~S: undefined label #~S#~%" 'at 'home '123AER45 2 )
(format T "~S de ~S : L'objet #Y~S n'a pas la syntaxe d'une «closure» compilée.~%"
  611 'moi '56789 ) 
(format T "612 ~S de ~S : #~S= #~S# n'est pas permis~%" 'func33 'home 'af 'cz )  
(format T "613 Image mémoire écrite dans ~A (~:D octet~:P)~%" 'fic1.txt 1024)
(format T "613a Image mémoire écrite dans ~A (~:D octet~:P)~%" 'fic1.txt 0)
(format T "613b Image mémoire écrite dans ~A (~:D octet~:P)~%" 'fic1.txt 1)

(format T "614 Nouveau ~S [valeur ~D de ~D]~A~%" 'fic3.s 10 30 'f.zip)
 
(format T "620 Recursive processing forma1 ~? ~D~%" "<~A ~D ~S>" '( "foo_forma2" 5 'bonjour) 7) 
(format T "620b Recursive processing forma1 ~? ~D~%" "<~A ~D>" '( "foo_forma2" 5) 7) 
(format T "620a Recursive processing forma1 ~? ~D~%" "<~A ~D>" '("foo_forma2" 5 14) 7)
(format T "620b Pour la fonction ~S avec arguments ~S:~%Dans compil méthode effec ~S:~%Méth non val : ~S~%~?~%"
  'cosval 1 'convert 'metho1 "!~A ~D! ~S" '( "foo forma2" 5 'bonsoir) ) 
  
(format T "630a ;; Traçage ~:[de la fonction~;de la macro~] ~S.~%" nil 'fin )
(format T "630b ;; Traçage ~:[de la fonction~;de la macro~] ~S.~%" 1 'fin)

(format T "640a une macro ~:[~;obsolète~]~%" 'oui)
(format T "640b une macro ~:[~;obsolète~]~%" nil)

(format T "650a un nombre entier sur ~S bit~:P, est représenté comme ~:[bignum~;fixnum~].~%" 
  16 nil)
(format T "650b un nombre entier sur ~S bit~:P, est représenté comme ~:[bignum~;fixnum~].~%" 
  1 T)
(format T "650c un nombre entier sur ~S bit~:P, est représenté comme ~:[bignum~;fixnum~].~%" 
  2 T)

(format T "660a ~S a ~D argument~:P mais ~S a ~D arguments obligatoire~:P~%" 'func1 3 'func2 5)
(format T "660b ~S a ~D argument~:P mais ~S a ~D argument~:P obligatoire~:P~%" 'func1 1 'func2 5)
(format T "660c ~S a ~D argument~P ~S~%" 'func1 1 1 'fin)
(format T "660d ~S a ~D argument~P ~S~%" 'func1 1 2 'fin)

(format T "670a ~S wascalwith ~S~:[~; ormore~] argbutreq ~:[~:[from ~S to ~S~;~S~]~;atleast ~*~S~] arg~:p.~%"
    'func0 10 T 2 3 4)
(format T "670b ~S wascalwith ~S~:[~; ormore~] argbutreq ~:[~:[from ~S to ~S~;~S~]~;atleast ~*~S~] arg~:p.~%"
    'func0 20 nil 2 3 4)
(format T "670c ~S wascalwith ~S~:[~; ormore~] argbutreq ~:[~:[from ~S to ~S~;~S~]~;atleast ~*~S~] arg~:p.~%"
    'func0 20 nil nil 3 4)
(format T "670d ~S wascalwith ~S~:[~; ormore~] argbutreq ~:[~:[from ~S to ~S~;~S~]~;atleast ~*~S~] arg~:p.~%"
    'func0 20 nil nil nil 4 44)    
    
(format T "671a ~S est appelé avec ~S ~:[~;ou plus d'~]argument~:P mais a besoin ~:[de ~:[~S à ~S~;~S~]~;d'au moins ~*~S~] argument~:P.~%"
    'func0 10 T 2 3 4)
(format T "671b ~S est appelé avec ~S ~:[~;ou plus d'~]argument~:P mais a besoin ~:[de ~:[~S à ~S~;~S~]~;d'au moins ~*~S~] argument~:P.~%"
    'func0 20 nil 2 3 4)
(format T "671c ~S est appelé avec ~S ~:[~;ou plus d'~]argument~:P mais a besoin ~:[de ~:[~S à ~S~;~S~]~;d'au moins ~*~S~] argument~:P.~%"
    'func0 20 nil nil 3 4)
(format T "671d ~S est appelé avec ~S ~:[~;ou plus d'~]argument~:P mais a besoin ~:[de ~:[~S à ~S~;~S~]~;d'au moins ~*~S~] argument~:P.~%"
    'func0 20 nil nil nil 4 44) 
(format T "671e ~S est appelé avec ~S ~:[~;ou plus d'~]argument~:P mais a besoin ~:[de ~:[~S à ~S~;~S~]~;d'au moins ~*~S~] argument~:P.~%"
    'func0 0 nil nil nil 4 44) 

(format T "680a importe les symboles externes de ~:D paquetage~:P ~{~A~^, ~} et~%"
    3 '(func0 func2 func7) )     

(format T "690a Use instead~@[ of ~S~]~%"   '(func0 func2 func7) )  
(format T "690b Utiliser à la place~@[ de ~S~]~%"   '(func0 func2 func7) ) 
(format T "690c Utiliser à la place~@[ de ~S~]~%"   nil ) 

(format T "700a mot~P clé~P non autorisé~P ~{~S~#[~; et ~S~:;, ~]~} pour la fonction ~S.~
                             ~%~[Les mots clés autorisés sont~;Le mot clé autorisé est~:;Les mots clés autorisés sont~] uniquement ~{~S~#[~; et ~S~:;, ~]~}.~%"
  1 'Charlot 'func0 '(func2 func7) 'coseval 2 '(func12 func17) )     
(format T "700d mot~P clé~P non autorisé~P ~{~S~#[~; et ~S~:;, ~]~} pour la fonction ~S.~
                             ~%~[Les mots clés autorisés sont~;Le mot clé autorisé est~:;Les mots clés autorisés sont~] uniquement ~{~S~#[~; et ~S~:;, ~]~}.~%"
  1 'Charlot 'func0 '(func2 func7) 'coseval 2 '(func12 func17) )  
(format T "700b mot~P clé~P non autorisé~P ~{~S~#[~; et ~S~:;, ~]~} pour la fonction ~S.~
                             ~%~[Les mots clés autorisés sont~;Le mot clé autorisé est~:;Les mots clés autorisés sont~] uniquement ~{~S~#[~; et ~S~:;, ~]~}.~%"
  1 'Charlot 'func0 '(func2 func7) 'coseval 1 '(func12) ) 
(format T "700c mot~P clé~P non autorisé~P ~{~S~#[~; et ~S~:;, ~]~} pour la fonction ~S.~
                             ~%~[Les mots clés autorisés sont~;Le mot clé autorisé est~:;Les mots clés autorisés sont~] uniquement ~{~S~#[~; et ~S~:;, ~]~}.~%"
  2 'Charlot 'func0 '(func2 func7) 'coseval 1 '(func12) ) 
(format T "710a ~S : ~S n'est pas permis dans des méthodes ~{~S~^ ~}~%"  
  'moduel 'atangt '(func0 func2 func7) ) 
(format T "720a . Il porte ~:D surnom~:P ~{~A~^, ~}~%" 1 '(fanfan)  )
(format T "720b . Il porte ~:D surnom~:P ~{~A~^, ~}~%" 2 '(fanfan mirette )  )

(format T "730a  vers ~:D paquetage~:P ~{~A~^, ~}~%" nil '(arcos23 gentic34 ) )
(format T "730b  vers ~:D paquetage~:P ~{~A~^, ~}~%" 1 '(arcos23 ) )
(format T "730c  vers ~:D paquetage~:P ~{~A~^, ~}~%" 2 '(arcos23 gentic34 ) )

(format T "735a to ~:D package~:P ~{~A~^, ~}~%" 1 '(arcos23 )   )
(format T "735b to ~:D package~:P ~{~A~^, ~}~%" 2 '(arcos23 gentic34 )   ) 

(format T "740 une liste de pointeurs invisible pour le GC, sur  ~{~S~^, ~}.~%" 
  '(arcos23 ki2 pi7 )   )
(format T "750a , possède ~:D propriété~:P ~{~S~^, ~}~%"  1 '(arcos23 )   )
(format T "750b , possède ~:D propriété~:P ~{~S~^, ~}~%"  2 '(arcos23 gentic34 )   )
(format T "750c , possède ~:D propriété~:P ~{~S~^, ~}~%"  nil nil  )

(format T "760a , est visible dans ~:d paquetage~:p ~{~A~^, ~}~%"  1 '(arcos23 )   )
(format T "760b , est visible dans ~:d paquetage~:p ~{~A~^, ~}~%"  2 '(arcos23 gentic34 )   )
(format T "760c , est visible dans ~:d paquetage~:p ~{~A~^, ~}~%"  nil nil  )

(format T "765a ~S : résultat ambigu : ~:{~%~S de ~@{~{~A ~S~}~^, ~}~}~%"  1 '(1.2 nil) 'arcos23 'gentic34  0   )
(format T "765b ~S : résultat ambigu : ~:{~%~S de ~@{~{~A ~S~}~^, ~}~}~%"  2 '(arcos23 gentic34 )   )
(format T "765c ~S : résultat ambigu : ~:{~%~S de ~@{~{~A ~S~}~^, ~}~}~%"  nil nil  )



;;   "Input a value to be used instead~@[ of ~S~]."
;;   "The value of ~S should be ~:[of type ~S~;~:*~A~]."
;;  "READ: ~@?"
;;  "the syntax `,@form is invalid"
;;  "the syntax `( ... . ,@form) is invalid"
;;  "the syntax `,.form is invalid"
;;  "the syntax `,@form is invalid"
;;   "~S: unquotes may occur only in (...) or #(...) forms"
;;   "~S: A file with name ~A does not exist"
;;   "warning: %s %lu too large, using %lu instead"
;;   "Input a value to be used instead~@[ of ~S~]."
;;   "~S: Use of ~S implicitly applies FUNCTION.~@\n"
;; "The ~~:@R format directive requires an integer in the range 1 - 4999, not ~S"
;; "Cannot call ~S on ~D~@[ or more~] argument~P"
;;  "Function ~s~% was already defined~a~% with the signature~%~a~% it is being re-defined with a new signature~%~a"
  
;; A fourretout  
(format T  "~S ~S: invalid ~S lambda-list:~A~%" "Ch1" "Ch2" "Chaine" "minColumns,colInc,minPad,padChar" 1 2 3)

(format T "string format: ~S~%" "Bonjour")

;; Creates and returns a new string containing "1 + 2 = 3".
(format NIL "1 + 2 = ~d" 3)

;; Creates and returns a new string containing "1 + 2 = 3".
(with-output-to-string (output)
  (format output "1 + 2 = ~d" 3))

;; Appends to the dynamic string the string "1 + 2 = 3".
(let ((output-string (make-array 0
                       :element-type 'character
                       :adjustable T
                       :fill-pointer 0)))
  (declare (type string output-string))
  (format output-string "2 + 2 = ~d" 4)
  (the string output-string))






Appends to the dynamic string the string "1 + 2 = 3".

(let ((output-string (make-array 0

                      :element-type 'character
                      :adjustable T
                      :fill-pointer 0)))
 (declare (type string output-string))
 (format output-string "2 + 2 = ~d" 4)
 (the string output-string))