id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
listlengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5,226 | test-ii.lisp | informatimago_lisp/languages/linc/test-ii.lisp | (eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC")
(defclass a ()
())
(defclass b ()
((b :initarg :b :accessor b)))
;; (defmethod shared-initialize :before
;; ((self b) slot-names &rest initargs &key &allow-other-keys)
;;
;; (print `(= (slot-boundp ,self 'b) , (slot-boundp self 'b)))
;; (print `(shared-initialize :before ((,self b) ,slot-names &rest ,initargs &key &allow-other-keys)))
;; (print `(= (next-method-p) ,(next-method-p)))
;; (when (next-method-p)
;; (apply (function call-next-method) self slot-names
;; :b 2 (remf initargs :b))))
(defmethod initialize-instance :before ())
(inspect (make-instance 'b :b 1))
(inspect *)
| 768 | Common Lisp | .lisp | 19 | 38.842105 | 104 | 0.649194 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ec226c420987c131322cf860de57cc8b2b369808ac3567dd17218374b1fd1b33 | 5,226 | [
-1
] |
5,227 | loader.lisp | informatimago_lisp/languages/linc/loader.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: loader.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Loads verrazano and tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2007-12-19 <PJB> Added this comment.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2007 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COMMON-LISP-USER")
(unless (find-package :split-sequence)
(asdf:operate 'asdf:load-op :split-sequence))
(unless (and (find-package :COM.INFORMATIMAGO.COMMON-LISP.SOURCE-FORM)
(find-package :COM.INFORMATIMAGO.COMMON-LISP.utility))
(asdf:operate 'asdf:load-op :COM.INFORMATIMAGO.COMMON-LISP))
(load "packages.lisp")
(load "c-syntax.lisp")
#-(and)
(progn
(defparameter *base-dir*
(or *load-pathname*
"/home/pjb/src/pjb/linc/"))
(defparameter *install-dir* (format nil "~Ainstall/" *base-dir*))
#+(or)
(ext:shell (format nil "cd cmake-2.2.1 ; ./configure --prefix ~S && make && make install" *install-dir*))
#+(or)
(ext:shell (format nil "cd gccxml ; ~A~:*/bin/cmake -DCMAKE_INSTALL_PREFIX:PATH=~A && make && make install" *install-dir*))
;; (load "asdf/asdf.lisp")
(setf ASDF:*CENTRAL-REGISTRY*
(nconc
(sort
(DELETE-DUPLICATES
(mapcar
(lambda (d) (MAKE-PATHNAME :NAME NIL :TYPE NIL :VERSION NIL :DEFAULTS d))
(directory "**/*.asd"))
:test (function equal))
(LAMBDA (A B) (if (= (length a) (length b))
(string< a b)
(< (length a) (length b))))
:key (function namestring))
ASDF:*CENTRAL-REGISTRY*))
(asdf:operate 'asdf:load-op :cffi)
(asdf:operate 'asdf:load-op :s-xml)
(asdf:operate 'asdf:load-op :parse-number)
(asdf:operate 'asdf:load-op :split-sequence)
(asdf:operate 'asdf:load-op :verrazano-support)
(asdf:operate 'asdf:load-op :verrazano)
(ext:shell (format nil "~A~:*/bin/gccxml /usr/include/string.h -fxml=~A/../string.xml" *install-dir*))
(defparameter *conf* (verrazano::make-configuration
:binding-name "test"
:binding-nicknames '()
:included-files '("/usr/include/string.h")
:gccxml-flags nil
:symbols-hidden '()
:overrides '()
:options '()
:output-filename (format nil "~Astring.what" *base-dir*)))
(let ((cfg *conf*)(dbg? t))
(let ((ir (verrazano::parse-gccxml-output cfg "string.xml" "string.mac")))
(verrazano::simplify-ir ir cfg)
(when dbg?
(verrazano::print-ir ir)
(verrazano::print-class-bases ir)
(verrazano::print-class-vtables ir))
(let ((dq (verrazano::generate-definition-queue ir)))
(inspect dq))))
(verrazano::generate-package backend dq cfg)
(when (not dbg?) (verrazano::cleanup temp-c temp-xml temp-mac))
(verrazano::defbinding "test"
(nicknames "str")
(flags "")
(include
"/usr/include/string.h")
(export "")
(override "not supported yet"))
(verrazano:create-binding
*conf* filename outname backend &optional dbg?)
;; (let ((cfg (parse-configuration-file filename outname))
;; (temp-c (merge-pathnames "vzntemp.cpp" (working-directory bconf)))
;; (temp-xml (merge-pathnames "vzntemp.xml" (working-directory bconf)))
;; (temp-mac (merge-pathnames "vzntemp.mac" (working-directory bconf))))
;; (handler-case (generate-temporary-c-file cfg temp-c)
;; (file-error () (error 'tempcpp-error)))
;; (run-gccxml cfg (gccxml-path bconf) temp-c temp-xml temp-mac)
;; (let ((ir (parse-gccxml-output cfg temp-xml temp-mac)))
;; (simplify-ir ir cfg)
;; (when dbg?
;; (print-ir ir)
;; (print-class-bases ir)
;; (print-class-vtables ir))
;; (let ((dq (generate-definition-queue ir)))
;; (generate-package backend dq cfg))
;; (when (not dbg?) (cleanup temp-c temp-xml temp-mac)))))
)
| 5,161 | Common Lisp | .lisp | 120 | 37.416667 | 126 | 0.595214 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6fc6302cee7d6ad47687532be0e9f9bbb3a554e91d088bd1f0a2c168f5c5ed86 | 5,227 | [
-1
] |
5,228 | generate.lisp | informatimago_lisp/languages/linc/generate.lisp | (eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COMMON-LISP-USER")
(defvar *compile-linc-c-files* nil)
(defparameter *this-directory* (make-pathname :name nil :type nil :version nil
:defaults (or *load-truename*
(error "This file must be loaded as source."))))
(cd cl-user::*this-directory*)
(pushnew *this-directory* asdf:*central-registry* :test (function equalp))
(ql:quickload :com.informatimago.languages.linc)
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC")
(defparameter *test-files* '("test-include.sexpc"
"test-macros.sexpc"
"test-types.sexpc"
"test-expressions.sexpc"
"test-statements.sexpc"))
(defun call-dofiles (files thunk)
(dolist (path files)
(funcall thunk path
;; (make-pathname :name (pathname-name path) :type
;; (pathname-type path) :version
;; nil :defaults
;; cl-user::*this-directory*)
)))
(defmacro dofiles ((var test-files) &body body)
`(call-dofiles ,test-files (lambda (,var) ,@body)))
(if cl-user::*compile-linc-c-files*
(dofiles (test-sexpc *test-files*)
(cl-user::cc (translate-linc-file test-sexpc :print t :verbose t)
:output (make-pathname :type "o" :defaults test-sexpc :case :local)
:to :object
:options '("-Werror" "-Wall")))
(dofiles (test-sexpc *test-files*)
(translate-linc-file test-sexpc :print t :verbose t)))
| 1,758 | Common Lisp | .lisp | 34 | 39.588235 | 108 | 0.551163 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | d13b1e956e3d2017dd0d0d4fcdaec7784e7fb897671400abe30899a5caac5585 | 5,228 | [
-1
] |
5,229 | c-sexp-language.lisp | informatimago_lisp/languages/linc/c-sexp-language.lisp | (eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC.C-SEXP-LANGUAGE")
#|
The C Sexp Sources can be interpreted by two systems:
- Common Lisp usual LOAD and COMPILE-FILE, (wrapped in LOAD-LINC-FILE
and COMPILE-LINC-FILE to setup the C reader macros and environment)
which expands the toplevel forms (macros) into Common Lisp code
interpring them using the C semantics embedded in Common Lisp via a
C-like runtime. This allows to develop and debug code in the CL
environment, to later be translated to C.
- LINC TRANSLATE-LINC-FILE, which generates a C source file.
|#
;; pre-processor directives
(defmacro .ifdef (symbol &body toplevel-forms)
)
(defmacro .ifndef (symbol &body toplevel-forms)
)
(defmacro .if (constant-expression &body toplevel-forms)
"
.elif constant-expression
.else
"
)
(defmacro include (file)
"
(include <file>)
(include \"file\")
"
)
(defmacro define-macro (name &rest optional-lambda-list-and-expansion)
)
;; type expressions:
(defparameter *type-qualifiers*
'(const restrict volatile atomic))
(defparameter *type-qualifier-map*
'((atomic . |_Atomic|)))
(defparameter *type-specifier*
'(void char short int long float double signed unsigned bool complex))
(defparameter *type-specifier-map*
'((bool . |_Bool|)
(complex . |_Complex|)))
(eval-when (:compile-toplevel :load-toplevel :execute)
(defun struct-union-enum (type name-and-slots)
(let ((name (if (symbolp (first name-and-slots))
(first name-and-slots)
nil))
(slots (if (symbolp (first name-and-slots))
(rest name-and-slots)
name-and-slots)))
`(,type ,name ,slots))))
(defmacro struct (&rest name-and-slots) (struct-union-enum 'struct name-and-slots))
(defmacro union (&rest name-and-slots) (struct-union-enum 'union name-and-slots))
(defmacro enum (&rest name-and-values) (struct-union-enum 'enum name-and-values))
(defmacro atomic (type) `(atomic ,type))
(defmacro pointer (type) `(pointer ,type))
(defmacro array (type &optional size) `(array ,type ,size))
#|
(struct foo)
(struct foo (x int) (y int (bits 3)))
(struct (x int) (y int (bits 3)))
(union foo)
(union foo (x int) (y int (bits 3)))
(union (x int) (y int (bits 3)))
(enum bar)
(enum bar x y z)
(enum bar (x 0) y z)
(enum (x 0) y z)
<identifier>
(atomic type)
(pointer type)
;; char*
(pointer char)
;; char* []
(array (pointer char))
;; char* [42]
(array (pointer char) 42)
(direct-declarator \[ (opt type-qualifier-list) (opt assignment-expression) \])
(direct-declarator \[ static (opt type-qualifier-list) assignment-expression \])
(direct-declarator \[ type-qualifier-list static assignment-expression \])
(direct-declarator \[ (opt type-qualifier-list) \* \])
(align-as type)
(align-as const-expression)
|#
;; declarations:
(defmacro declare-structure (name &rest slots)
"
WILL GENERATE:
struct ,name {
,@slots
};
"
`(struct ,name ,@slots))
(defmacro declare-union (name &rest alternatives)
"
WILL GENERATE:
union ,name {
,@alternatives
};
"
`(union ,name ,@alternatives))
(defmacro declare-type (name &rest type)
"
WILL GENERATE:
typedef ,type ,name;
"
`(typedef ,name ,type)
)
(defmacro declare-enumeration (name &rest options-and-values)
)
(defmacro declare-constant (name &rest options-and-type)
)
(defmacro declare-variable (name &rest options-and-type)
)
(defmacro declare-function (name &rest options-and-lambda-list-and-type)
)
;; definitions:
(defmacro define-constant (name &rest options-and-type-and-value)
)
(defmacro define-variable (name &rest options-and-type-and-value)
)
(defmacro define-function (name &rest options-and-lambda-list-and-type-and-body)
)
| 3,960 | Common Lisp | .lisp | 123 | 28.926829 | 86 | 0.688654 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 9e89cc7107151e4a7c3e92fa433751f20d53b2daefda1bd9f082497d6fedbbd0 | 5,229 | [
-1
] |
5,230 | packages.lisp | informatimago_lisp/languages/linc/packages.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: packages.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the packages.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2007-12-24 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2007 - 2019
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(cl:in-package "COMMON-LISP-USER")
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(defpackage "COM.INFORMATIMAGO.LANGUAGES.LINC.C-RUNTIME.STDIO"
(:use "COMMON-LISP")
(:export "printf" "fopen" "fread" "fwrite" "fseek" "ftell" "fclose"))
(defpackage "COM.INFORMATIMAGO.LANGUAGES.LINC.C-RUNTIME"
(:use "COMMON-LISP")
(:export "INITIALIZE")
(:export "ENVIRONMENT" "VARIABLE" "ARRAY" "POINTER"))
(defpackage "COM.INFORMATIMAGO.LANGUAGES.LINC.C"
(:nicknames "COM.INFORMATIMAGO.LANGUAGES.LINC.C++")
(:use)
(:export
;; pre-processor directives
"include"
"#ifdef"
"#ifndef"
"#if"
"#elif"
"#else"
"#endif"
;; toplevel forms
"declare-structure"
"declare-union"
"declare-type"
"declare-enumeration"
"declare-constant"
"declare-variable"
"declare-function"
"define-constant"
"define-variable"
"define-function"
"define-macro"
;; statements:
"label" "goto"
"switch" "case" "default"
"block" "let" "let*"
"if" "while" "do" "for"
"break" "continue" "return"
"asm"
;; anyary operator:
"progn"
;; ternary operator:
"?"
;; binary operators:
"=" "*=" "/=" "%=" "+=" "-=" ">>=" "<<=" "&=" "|=" "^="
"||" "&&" "|" "^" "&" "==" "!=" "<" ">" "<=" ">=" "<<" ">>"
"+" "-" "*" "/" "%" ".*" "->*"
"." "->" "aref"
;; unary operators:
"++" "--" "!" "~"
"&" "sizeof"
"post++" "post--"
;; +, - and * can be used as unary operators too.
"cast" ","
;; types
;; "typedef"
"extern" "static" "thread-local" "auto" "register" "const"
"restrict" "volatile" "atomic" "void" "char" "short" "int" "long"
"float" "double" "signed" "unsigned" "bool" "complex" "struct" "enum"
"union" "atomic" "pointer" "array" "function"
"bit"
"inline" "noreturn"
;; ;; c++ extensions (not implemented yet).
;; "external"
;; "using" "namespace" "typename" "template"
"new" "new[]" "delete" "delete[]"
"::"
;; "absolute-scope" "scope"
))
(defpackage "COM.INFORMATIMAGO.LANGUAGES.LINC.C-SEXP-LANGUAGE"
(:use "COMMON-LISP")
(:export "INCLUDE"
"DECLARE-STRUCTURE"
"DECLARE-UNION"
"DECLARE-TYPE"
"DECLARE-ENUMERATION"
"DECLARE-CONSTANT"
"DECLARE-VARIABLE"
"DECLARE-FUNCTION"
"DEFINE-CONSTANT"
"DEFINE-VARIABLE"
"DEFINE-FUNCTION"
"DEFINE-MACRO"
;; Statemetns:
"LABEL" "GOTO"
"SWITCH" "CASE" "DEFAULT"
"BLOCK" "LET" "LET*"
"IF" "WHILE" "DO" "FOR"
"BREAK" "CONTINUE" "RETURN"
"ASM"
;;
"EXPORT"
;; Anyary operator:
"PROGN"
;; Ternary operator:
"?"
;; Binary operators:
"=" "*=" "/=" "%=" "+=" "-=" ">>=" "<<=" "&=" "|=" "^="
"||" "&&" "|" "^" "&" "==" "!=" "<" ">" "<=" ">=" "<<" ">>"
"+" "-" "*" "/" "%" ".*" "->*"
"." "->" "AREF"
;; Unary operators:
"++" "--" "!" "~"
"&" "SIZEOF"
"POST++" "POST--"
;; +, - and * can be used as unary operators too.
"CAST" ","
"BIT" "INLINE" "NORETURN"
;; C++ extensions (not implemented yet).
"EXTERN"
"USING" "NAMESPACE" "TYPENAME" "TEMPLATE"
"NEW" "NEW[]" "DELETE" "DELETE[]"
"::"
"ABSOLUTE-SCOPE" "SCOPE")
(:shadow "CASE" "BLOCK" "LET" "IF" "DO"
"BREAK" "CONTINUE" "RETURN"
"=" "/=" "<" ">" "<=" ">=" "+" "-" "*" "/" "++"
"AREF"))
(defpackage "COM.INFORMATIMAGO.LANGUAGES.LINC"
(:use "COMMON-LISP")
(:shadow "TYPEP" "FUNCTIONP" "DECLARATION")
(:use "SPLIT-SEQUENCE")
(:use "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.UTILITY")
(:shadow "INCLUDE-FILE")
(:use "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.LIST"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.STRING"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.SYMBOL"
"COM.INFORMATIMAGO.COMMON-LISP.LISP-SEXP.SOURCE-FORM")
(:use "COM.INFORMATIMAGO.LANGUAGES.LINC.C")
(:shadowing-import-from "COMMON-LISP"
"+" "-" "*" "/"
"<" ">" "<=" ">="
"=" "/="
"++")
(:export "COMPILE-LINC-FILE"
"LOAD-LINC-FILE"
"TRANSLATE-LINC-FILE"))
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC")
(eval-when (:compile-toplevel :load-toplevel :execute)
(defvar *c-package-name* "COM.INFORMATIMAGO.LANGUAGES.LINC.C")
(defvar *c-opening-brace* #\{)
(defvar *c-closing-brace* #\})
(defvar *c-progn* '|progn|))
;;;; THE END ;;;;
| 6,072 | Common Lisp | .lisp | 179 | 27.944134 | 83 | 0.525051 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 87641d8af42f990c33094dc8f48377f71d833d32e19e80562aa68dfc3ea9581d | 5,230 | [
-1
] |
5,231 | test.lisp | informatimago_lisp/languages/linc/test.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: test.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Test forms.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2007-12-19 <PJB> Extracted from linc.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2007 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC")
(setf *c-out* (open "test.c" :direction :output
:if-exists :supersede
:if-does-not-exist :create))
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC")
(defpackage "BC-MEM"
(:documentation "A package corresponding to a C module with prefixed function names.")
(:use)
(:export "COPY" "ALLOCATE" "DEALLOCATE"))
(in-package "COM.INFORMATIMAGO.LANGUAGES.LINC.C")
(declare-variable '(n-allocation n-data copy n-length))
(declare-function '(bc-mem:allocate bc-mem:deallocate bc-mem:copy))
(declare-macro '(minimum))
;; (generate (stmt-block
;; '(let ((obj1 (pointer abc) (new (abc 1 2 3)))
;; (obj2 (pointer abc) (new abc))
;; (arr (pointer (aref (pointer abc) 10)) (new [] (aref (pointer abc) 10))))
;; (-> obj1 (do-Something 4 5 6))
;; (delete obj1)
;; (delete obj2)
;; (delete [] arr))))
;; (in-package :c)
;; (com.informatimago.languages.linc::generate-expression '(+ 1 2))
;; (com.informatimago.languages.linc::generate-expression
;; '(* (+ 1 2 3 4) (/ 5 4 3 2) (- 5 4 3 2)
;; (pos a) (neg b) (deref c) (~ d) (! e)
;; (pos (+ 1 a)) (neg (+ 2 b)) (deref (+ c 3)) (~ (+ 4 d)) (! (< e 0))))
;; (com.informatimago.languages.linc::generate-expression
;; '(neg a))
(comment "Here is a little function")
(define-function string_add ((a string_t) (b string_t)) string_t
(let ((av int)
(bv int)
(res string_t (malloc (+ 2 (max (strlen a) (strlen b))))))
(sscanf a "%d" (address av))
(sscanf b "%d" (address bv))
(sprintf res "%d" (+ a b))
(return res)))
(comment "Here is another function."
"Slightly bigger this time."
(* 42 12))
(define-function test () void
(progn
(if (> n-Allocation 1)
(progn
(= n-Data (Bc-Mem:Allocate (* (sizeof char) n-Allocation)))
(if copy
(progn
(= n-Length (Minimum (- n-Allocation 1) (-> this dlength)))
(Bc-Mem:Copy (-> this data) n-Data (* n-Length (sizeof char))))
(= n-Length 0)))
(progn
(= n-Allocation 1)
(= n-Data (Bc-Mem:Allocate (* (sizeof char) n-Allocation)))
(= n-Length 0)))
(= (aref n-Data n-Length) (cast 0 char))
(Bc-Mem:Deallocate (cast (address (-> this data)) (pointer (pointer void))))
(= (-> this data) n-Data)
(= (-> this dlength) n-Length)
(= (-> this allocation) n-Allocation)
(let ((test double
(* (+ 1 2 3 4) (/ 5 4 3 2) (- 5 4 3 2)
(pos a) (neg b) (deref c) (~ d) (! e)
(pos (+ 1 a)) (neg (+ 2 b)) (deref (+ c 3)) (~ (+ 4 d)) (! (< e 0))))))
(return this)))
#||
(cl:map cl:nil (cl:lambda (x)
(com.informatimago.languages.linc::generate-expression x)
(cl:terpri))
'((+ 1 2 3 4)
(/ 5 4 3 2)
(- 5 4 3 2)
(pos a)
(neg b)
(pos (neg (pos (neg (pos (neg a))))))
(+ a (- b (+ c (- d (+ e (- a f))))))
(deref c)
(deref (address c))
(address (deref c))
(~ d)
(! e)
(pos (+ 1 a))
(neg (+ 2 b))
(deref (+ c 3))
(~ (+ 4 d))
(! (< e 0))
(& (+ (<< 1 b) (>> c 3)) (\| (<< 1 b) (>> c 3)))
(? (== a 0) 42 (- a 2))))
(com.informatimago.languages.linc::generate-expression
'(* (+ 1 2 3 4) (/ 5 4 3 2) (- 5 4 3 2)
(pos a) (neg b) (deref c) (~ d) (! e)
(pos (+ 1 a)) (neg (+ 2 b)) (deref (+ c 3)) (~ (+ 4 d)) (! (< e 0))))
;; (in-package :com.informatimago.languages.linc)
(setf *c-out* (open "test.c" :direction :output
:if-exists :supersede
:if-does-not-exist :create))
(cl:progn
(cl:close com.informatimago.languages.linc::*c-out*)
(cl-user::edit (cl:pathname com.informatimago.languages.linc::*c-out*) :wait cl:nil)
(cl:setf com.informatimago.languages.linc::*c-out* cl:t))
||#
;;;; THE END ;;;;
| 5,521 | Common Lisp | .lisp | 137 | 34.934307 | 95 | 0.525923 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | aa68ccfabe9c25e31995c3a6b5807b702490ac30aa950c6646d5fde7de39ee52 | 5,231 | [
-1
] |
5,232 | token.lisp | informatimago_lisp/languages/cpp/token.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: token.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines cpp tokens.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-06-28 <PJB>
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
;;; ------------------------------------------------------------
(defstruct (numbered-line
(:type list)
(:conc-name line-))
(text "")
(lino 1)
(file "-"))
(defun number-lines (lines file-name &key (start 1))
(loop
:for lino :from start
:for line :in lines
:collect (make-numbered-line :text line :lino lino :file file-name)))
(defgeneric token-file (token))
(defmethod token-file ((numbered-line cons))
(line-file numbered-line))
(defmethod token-line ((numbered-line cons))
(line-lino numbered-line))
(defmethod token-column ((numbered-line cons))
1)
(defmethod token-text ((numbered-line cons))
(line-text numbered-line))
;;; ------------------------------------------------------------
(defclass cpp-token (token)
((file :initform "-" :initarg :file :accessor token-file)))
(defmacro define-token-class (name &optional slots)
(let ((class-name (intern (concatenate 'string (string name) (string '-token)))))
`(progn
(defclass ,class-name (cpp-token) ,slots)
(defun ,(intern (concatenate 'string (string name) (string '-p))) (object)
(typep object ',class-name))
(defmethod print-object ((self ,class-name) stream)
(print-unreadable-object (self stream :identity nil :type t)
(let ((*print-circle* nil))
(format stream "~A:~A:~A: ~A ~S"
(token-file self) (token-line self) (token-column self)
(token-kind self) (token-text self))))
self)
(defun ,(intern (concatenate 'string (string 'make-) (string name))) (text &optional (column 0) (line 0) (file "-"))
(make-instance ',class-name :text text :column column :line line :file file)))))
(defgeneric token-symbol (token)
(:method ((token token))
(token-kind token)))
(define-token-class identifier
((symbol :initarg :symbol
:initform nil
:accessor token-symbol)))
(define-token-class number)
(define-token-class string-literal)
(define-token-class character-literal)
(define-token-class punctuation)
(define-token-class other)
(defgeneric token-value (token)
(:method ((token token)) (token-symbol token))
(:method ((token number-token)) (integer-value token))
(:method ((token character-literal-token)) (character-value token))
(:method ((token string-literal-token)) (string-value token)))
(defvar *identifier-package* (load-time-value (find-package #.(package-name *package*)))
"Package where to intern token-symbol of identifiers.")
(defmethod initialize-instance :after ((token identifier-token) &key &allow-other-keys)
(setf (slot-value token 'kind) 'identifier
(slot-value token 'symbol) (intern (slot-value token 'text) *identifier-package*)
(slot-value token 'text) nil))
(defmethod token-text ((token identifier-token))
(symbol-name (token-symbol token)))
(defmethod initialize-instance :after ((token punctuation-token) &key &allow-other-keys)
(setf (slot-value token 'kind) 'punctuation))
(defmethod initialize-instance :after ((token number-token) &key &allow-other-keys)
(setf (slot-value token 'kind) 'number))
(defmethod initialize-instance :after ((token string-literal-token) &key &allow-other-keys)
(setf (slot-value token 'kind) 'string-literal))
(defmethod initialize-instance :after ((token character-literal-token) &key &allow-other-keys)
(setf (slot-value token 'kind) 'character-literal))
(defun identifierp (token)
(typep token 'identifier-token))
(defun number-token-p (token)
(typep token 'number-token))
(defun pseudo-token (file lino)
(make-other "" 0 lino file))
(defun token-predicate-label (predicate-name)
(case predicate-name
(sharpp "« # »")
(sharpsharpp "« ## »")
(spacep "a space")
(openp "« ( »")
(closep "« ) »")
(open-bracket-p "« < »")
(close-bracket-p "« > »")
(commap "« , »")
(ellipsisp "« ... »")
(identifierp "an identifier")
(number-token-p "a number")
(otherwise (format nil "a ~(~A~)" predicate-name))))
(defmacro define-punctuation-predicate (name value)
`(defun ,name (token)
(and (typep token 'punctuation-token)
(or (string= ,value (token-text token))))))
(defparameter *whitespaces* #(#\space #\tab #\vt #\page #\nul #\newline #\return #\linefeed))
(defun whitespacep (character)
(find character *whitespaces*))
(defun spacep (token)
(and (typep token 'punctuation-token)
(= 1 (length (token-text token)))
(whitespacep (aref (token-text token) 0))))
(define-punctuation-predicate sharpp "#")
(define-punctuation-predicate sharpsharpp "##")
(define-punctuation-predicate openp "(")
(define-punctuation-predicate closep ")")
(define-punctuation-predicate open-bracket-p "<")
(define-punctuation-predicate close-bracket-p ">")
(define-punctuation-predicate commap ",")
(define-punctuation-predicate ellipsisp "...")
(define-punctuation-predicate op-plus-p "+")
(define-punctuation-predicate op-minus-p "-")
(define-punctuation-predicate op-lognot-p "!")
(define-punctuation-predicate op-bitnot-p "~")
(define-punctuation-predicate op-times-p "*")
(define-punctuation-predicate op-divides-p "/")
(define-punctuation-predicate op-remainder-p "%")
(define-punctuation-predicate op-left-shift-p "<<")
(define-punctuation-predicate op-right-shift-p ">>")
(define-punctuation-predicate op-lt-p "<")
(define-punctuation-predicate op-le-p "<=")
(define-punctuation-predicate op-gt-p ">")
(define-punctuation-predicate op-ge-p ">=")
(define-punctuation-predicate op-eq-p "==")
(define-punctuation-predicate op-ne-p "!=")
(define-punctuation-predicate op-bitand-p "&")
(define-punctuation-predicate op-bitior-p "|")
(define-punctuation-predicate op-bitxor-p "^")
(define-punctuation-predicate op-logand-p "&&")
(define-punctuation-predicate op-logior-p "||")
(define-punctuation-predicate op-question-p "?")
(define-punctuation-predicate op-colon-p ":")
(define-condition cpp-error (simple-error)
())
(define-condition cpp-warning (simple-warning)
())
(defgeneric cpp-error (token format-control &rest format-arguments)
(:method ((context context) format-control &rest format-arguments)
(cerror "Continue" 'cpp-error
:format-control "~A:~A: error: ~?"
:format-arguments (list (context-file *context*)
(context-line *context*)
format-control format-arguments)))
(:method ((token token) format-control &rest format-arguments)
(apply (function cpp-error)
(update-context *context* :token token
:line (token-line token)
:column (token-column token)
:file (token-file token))
format-control format-arguments))
(:method ((line cons) format-control &rest format-arguments)
(apply (function cpp-error) (first line) format-control format-arguments))
(:method ((line null) format-control &rest format-arguments)
(error 'cpp-error
:format-control format-control
:format-arguments format-arguments)))
(defgeneric cpp-warning (token format-control &rest format-arguments)
(:method ((context context) format-control &rest format-arguments)
(warn 'cpp-warning
:format-control "~A:~A: warning: ~?"
:format-arguments (list (context-file *context*)
(context-line *context*)
format-control format-arguments)))
(:method ((token token) format-control &rest format-arguments)
(apply (function cpp-warning)
(update-context *context* :token token
:line (token-line token)
:column (token-column token)
:file (token-file token))
format-control format-arguments))
(:method ((line cons) format-control &rest format-arguments)
(apply (function cpp-warning) (first line) format-control format-arguments))
(:method ((line null) format-control &rest format-arguments)
(warn 'cpp-warning
:format-control format-control
:format-arguments format-arguments)))
;;;; THE END ;;;;
| 10,041 | Common Lisp | .lisp | 214 | 41.490654 | 123 | 0.623211 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 1dd1c5e2c732852872e74dfd71e255565a0c86e8795018b5210c574199f5e174 | 5,232 | [
-1
] |
5,233 | expression.lisp | informatimago_lisp/languages/cpp/expression.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: expression.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Parses and evaluates cpp #if expressions.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-07-01 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(defun integer-value (integer-token)
(let* ((integer-text (token-text integer-token))
(end (length integer-text)))
(loop :while (and (< 1 end) (find (aref integer-text (1- end)) "UL" :test (function char-equal)))
:do (decf end))
(cond
((and (< 2 (length integer-text))
(string= "0x" integer-text :start2 0 :end2 2))
(or (ignore-errors (parse-integer integer-text :start 2 :end end :radix 16 :junk-allowed nil))
(progn
(cpp-error integer-token "Invalid hexadecimal integer syntax in ~S" integer-text)
0)))
((and (< 2 (length integer-text))
(string= "0b" integer-text :start2 0 :end2 2))
(or (ignore-errors (parse-integer integer-text :start 2 :end end :radix 2 :junk-allowed nil))
(progn
(cpp-error integer-token "Invalid binary integer syntax in ~S" integer-text)
0)))
((and (< 1 (length integer-text))
(string= "0" integer-text :start2 0 :end2 1))
(or (ignore-errors (parse-integer integer-text :start 1 :end end :radix 8 :junk-allowed nil))
(progn
(cpp-error integer-token "Invalid octal integer syntax in ~S" integer-text)
0)))
(t
(or (ignore-errors (parse-integer integer-text :end end :junk-allowed nil))
(progn
(cpp-error integer-token "Invalid decimal integer syntax in ~S" integer-text)
0))))))
(defun character-value (character-token)
(let* ((character-text (token-text character-token))
(character-string
(with-input-from-string (in character-text :start 1)
(read-c-string in #\'))))
(unless (= 1 (length character-string))
(cpp-error character-token "Invalid multi-byte character literal ~A" character-text)
(when (zerop (length character-string))
(setf character-string #(#\nul))))
(char-code (aref character-string 0))))
(defun string-value (string-token)
(with-input-from-string (in (token-text string-token) :start 1)
(read-c-string in #\")))
(defmacro with-binary-op-parsers ((&rest definitions) (&rest functions) &body body)
`(labels (,@(mapcar (lambda (definition)
(destructuring-bind (name subexpr &rest ops) definition
`(,name () (loop :with expr := (,subexpr)
:while ,(if (= 1 (length ops))
`(,(first (first ops)) (peek))
`(let ((next (peek)))
(some (lambda (pred) (funcall pred next))
',(mapcar (function first) ops))))
:do (setf expr (list ,(if (= 1 (length ops))
`(progn (eat) ',(second (first ops)))
`(let ((op (eat)))
(cond
,@(mapcar (lambda (pair)
`((,(first pair) op) (quote ,(second pair))))
ops))))
expr (,subexpr)))
:finally (return expr)))))
definitions)
,@functions)
,@body))
#|
integer constant
character constant (interpreted as in C, as numbers)
arithmetic operators + - * / % ^ & | ~ << >> < <= > >= != == && || !
macros are expanded
defined(macro-name)
_Pragma("pragma")
identifiers = 0 (warning on -Wunder)
calculations in the widest integer type known to the compiler; on most machines supported by GCC this is 64 bits
operator precedence:
2 + - ! ~ unary
3 * / %
4 + - binary
5 <<>>
6 < <= > >=
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
expr ::= expr12 .
expr12 ::= expr11 [ '||' expr12 ] .
expr11 ::= expr10 [ '&&' expr11 ] .
expr10 ::= expr9 [ '|' expr10 ] .
expr9 ::= expr8 [ '^' expr9 ] .
expr8 ::= expr7 [ '&' expr8 ] .
expr7 ::= expr6 [ ( '==' | '!=' ) expr7 ] .
expr6 ::= expr5 [ ( '<' | '<=' | '>' | '>=' ) expr6 ] .
expr5 ::= expr4 [ ( '<<' | '>>' ) expr5 ] .
expr4 ::= expr3 [ ( '+' | '-' ) expr4 ] .
expr3 ::= expr2 [ ( '*' | '/' | '%' ) expr3 ] .
expr2 ::= [ '+' | '-' | '!' | '~' ] expr1 .
expr1 ::= '_Pragma' '(' string ')'
| 'defined' '(' identifier ')'
| '(' expr12 ')'
| integer | character | identifier .
associativity of binary operations: left-to-right.
|#
(defmacro cpp-and (a b)
`(if (and (not (zerop ,a)) (not (zerop ,b)))
1 0))
(defmacro cpp-or (a b)
`(if (or (not (zerop ,a)) (not (zerop ,b)))
1 0))
(defun cpp-not (a) (if (zerop a) 1 0))
(defun cpp-< (a b) (if (< a b) 1 0))
(defun cpp-<= (a b) (if (<= a b) 1 0))
(defun cpp-> (a b) (if (> a b) 1 0))
(defun cpp->= (a b) (if (>= a b) 1 0))
(defun cpp-= (a b) (if (= a b) 1 0))
(defun cpp-/= (a b) (if (/= a b) 1 0))
(defun left-shift (value offset)
(ash value offset))
(defun right-shift (value offset)
(ash value (- offset)))
(defgeneric parse-expression (context line))
(defmethod parse-expression ((context context) line)
(with-binary-op-parsers ((expr12 expr11 (op-logior-p cpp-or))
(expr11 expr10 (op-logand-p cpp-and))
(expr10 expr9 (op-bitior-p logior))
(expr9 expr8 (op-bitxor-p logxor))
(expr8 expr7 (op-bitand-p logand))
(expr7 expr6 (op-eq-p cpp-=) (op-ne-p cpp-/=))
(expr6 expr5 (op-lt-p cpp-<) (op-le-p cpp-<=) (op-gt-p cpp->) (op-ge-p cpp->=))
(expr5 expr4 (op-left-shift-p left-shift) (op-right-shift-p right-shift))
(expr4 expr3 (op-plus-p +) (op-minus-p -))
(expr3 expr2 (op-times-p *) (op-divides-p truncate) (op-remainder-p mod)))
((expr13 ()
(let ((test (expr12)))
(if (op-question-p (peek))
(progn
(eat)
(let ((then (expr12)))
(if (op-colon-p (peek))
(progn
(eat)
`(if (zerop ,test) ,(expr12) ,then))
(cpp-error (peek) "Expected a colon in ternary if expression, got ~S instead" (token-text (eat))))))
test)))
(expr2 ()
(let ((op (peek)))
(cond ((op-plus-p op) (eat) (expr1))
((op-minus-p op) (eat) `(- ,(expr1)))
((op-lognot-p op) (eat) `(cpp-not ,(expr1)))
((op-bitnot-p op) (eat) `(lognot ,(expr1)))
(t (expr1)))))
(expr1 ()
;; expr2 ::= '_Pragma' '(' string ')'
;; | 'defined' '(' identifier ')'
;; | '(' expr12 ')'
;; | identifier [ '(' arguments… ')' ]
;; | integer
;; | character .
(let ((next (peek)))
(cond
((openp next)
(eat)
(prog1 (expr13)
(if (closep (peek))
(eat)
(progn (cpp-error next "Missing close parenthesis in #if expression, got ~S instead" (token-text (eat)))
(return-from parse-expression 0)))))
((number-p next)
(integer-value (eat)))
((character-literal-p next)
(character-value (token-text (eat))))
((identifierp next)
(let ((identifier (eat)))
(scase (token-text identifier)
(("_Pragma")
(cpp-error identifier "_Pragma is forbidden in #if expressions")
0)
(otherwise ;; we've already macroexpanded
(when (option context :warn-on-undefined-identifier)
(cpp-warning identifier "~S is not defined" (token-text identifier)))
0))))
(t (if next
(cpp-error next "token ~S is not valid in preprocessor expressions" (token-text next))
(cpp-error context "end of line reached before the end of the preprocessor expressions"))
(return-from parse-expression 0)))))
(eat () (pop line))
(peek () (first line)))
(prog1 (expr13)
(unless (null (peek))
(cpp-error (peek) "missing binary operator before token ~S" (eat))))))
(defun test/integer-value ()
(assert (equal (mapcar (function integer-value)
(list (make-number "42" 0 0 "-")
(make-number "0x42" 0 0 "-")
(make-number "0b101010" 0 0 "-")
(make-number "042" 0 0 "-")))
'(42 66 42 34)))
:success)
(defun test/character-value ()
(assert (equal (mapcar (function character-value)
(list (make-character-literal "'A'" 0 0 "-")
(make-character-literal "'\\x41'" 0 0 "-")
(make-character-literal "'\\n'" 0 0 "-")
(make-character-literal "'λ'" 0 0 "-")))
'(65 65 10 955)))
:success)
;;;; THE END ;;;;
| 11,538 | Common Lisp | .lisp | 242 | 34.301653 | 131 | 0.463798 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | beaac7114d02ae55cf981c19eea7af637536d456c6cfdf68056eb34708f27bdb | 5,233 | [
-1
] |
5,234 | cpp-test.lisp | informatimago_lisp/languages/cpp/cpp-test.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: cpp-test.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;;
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-07-06 <PJB> Extracted from cpp.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(define-test test/substitute-trigraphs ()
(check equal (substitute-trigraphs (make-numbered-line :text (copy-seq "hello world")))
'("hello world" 1 "-"))
(check equal (substitute-trigraphs (make-numbered-line :text (copy-seq "??( brackets ??)???<braces??>??=??'a??!??-; (??\\?) (a==b???-c:'??/n')")))
'("[ brackets ]?{braces}#^a|~; (??\\?) (a==b?~c:'\\n')" 1 "-"))
:success)
(define-test test/number-lines ()
(check equal (number-lines '("a" "b" "c") "file.c" :start 2)
'(("a" 2 #1="file.c") ("b" 3 #1#) ("c" 4 #1#)))
:success)
(define-test test/merge-continued-lines ()
(check equal (merge-continued-lines '(("first line" 1 #1="file.c")
("abc\\" 2 #1#)
("def\\" 3 #1#)
("ghi" 4 #1#)
("middle line" 5 #1#)
("abc \\" 6 #1#)
("def \\ " 7 #1#)
("ghi" 8 #1#)
("last line" 9 #1#))
:warn-spaces-in-continued-lines nil)
'(("first line" 1 #2="file.c") ("abcdefghi" 2 #2#) ("middle line" 5 #2#) ("abc def ghi" 6 #2#) ("last line" 9 #2#)))
:success)
(define-test test/remove-comments-in-line ()
(flet ((try (text &optional (state :top) comment-start)
(multiple-value-list (remove-comments-in-line comment-start
(make-numbered-line :text text
:lino 42 :file "hw.c")
state t))))
(check equal (try "Hello world")
'(("Hello world" 42 "hw.c") :top))
;; comment in string
(check equal (try "Hello \"salut /* le */ monde\" world")
'(("Hello \"salut /* le */ monde\" world" 42 "hw.c") :top))
(check equal (try "Hello \"salut \\\"/* le */\\\" monde\" world")
'(("Hello \"salut \\\"/* le */\\\" monde\" world" 42 "hw.c") :top))
(assert-true (typep (nth-value 1 (ignore-errors (try "Hello \"salut"))) 'error))
(assert-true (typep (nth-value 1 (ignore-errors (try "Hello \"salut\\"))) 'error))
;; comment in characters
(check equal (try "Hello 'salut /* le */ monde' world")
'(("Hello 'salut /* le */ monde' world" 42 "hw.c") :top))
(check equal (try "Hello 'salut \\'/* le */\\' monde' world")
'(("Hello 'salut \\'/* le */\\' monde' world" 42 "hw.c") :top))
(assert-true (typep (nth-value 1 (ignore-errors (try "Hello 'salut"))) 'error))
(assert-true (typep (nth-value 1 (ignore-errors (try "Hello 'salut\\"))) 'error))
;; single line comment
(check equal (try "Hello//monde*/world") '(("Hello" 42 "hw.c") :top))
;; monoline block comment
(check equal (try "Hello/*monde*/world") '(("Hello world" 42 "hw.c") :top))
(check equal (try "Hello/*mon//de*/world") '(("Hello world" 42 "hw.c") :top))
(check equal (try "Hello/*mon/*de*/world") '(("Hello world" 42 "hw.c") :top))
;; multiline block comment first line
(check equal (try "Hello world/*salut") '(("Hello world" 42 "hw.c") :in-multiline-comment))
(check equal (try "Hello/*monde*/world/*salut") '(("Hello world" 42 "hw.c") :in-multiline-comment))
;; multiline block comment in the middle lines
(check equal (try "in the middle comment" :in-multiline-comment '("Hello world" 42 "hw.c"))
'(("Hello world" 42 "hw.c") :in-multiline-comment))
(check equal (try "in /* the // middle comment" :in-multiline-comment '("Hello world" 42 "hw.c"))
'(("Hello world" 42 "hw.c") :in-multiline-comment))
;; multiline block comment in the end line
(check equal (try "end comment */end line" :in-multiline-comment '("Hello world" 42 "hw.c"))
'(("Hello world end line" 42 "hw.c") :top))
(check equal (try "end comment */end/*fin*/line" :in-multiline-comment '("Hello world" 42 "hw.c"))
'(("Hello world end line" 42 "hw.c") :top))
(check equal (try "end // comment */end/*fin*/line" :in-multiline-comment '("Hello world" 42 "hw.c"))
'(("Hello world end line" 42 "hw.c") :top))
(check equal (try "end // comment */end/*fin*/line// c'est fini" :in-multiline-comment '("Hello world" 42 "hw.c"))
'(("Hello world end line" 42 "hw.c") :top))
:success))
(define-test test/remove-comments ()
(check equal (remove-comments '(("Line one" 1 #1="test.c")
("Line/**/two" 2 #1#)
("Line/*three*/3" 3 #1#)
("Line/*4*/four/*and*/some" 4 #1#)
("Line/*-*/five/*a//nd*/some" 5 #1#)
("Line/*/five/*a//nd some" 6 #1#)
("Line//6 */seven" 7 #1#)
("Line/*/eight/*a//nd some" 8 #1#)
("Line nine" 9 #1#)
("Line//9 */ten" 10 #1#)
("Line \"ele/*v*/en\"--" 11 #1#)
("Line 'tw//elv/*e*/'--" 12 #1#)))
'(("Line one" 1 #2="test.c")
("Line two" 2 #2#)
("Line 3" 3 #2#)
("Line four some" 4 #2#)
("Line five some" 5 #2#)
("Line seven" 6 #2#)
("Line ten" 8 #2#)
("Line \"ele/*v*/en\"--" 11 #2#)
("Line 'tw//elv/*e*/'--" 12 #2#)))
:success)
(define-test test/scan-identifier ()
(check equal (multiple-value-list (scan-identifier '(" Hello world " 42 "t.c") 3 "_$" :accept-unicode-escapes t))
'("Hello" 8))
(check equal (multiple-value-list (scan-identifier '(" Hello _wo$rl42d " 42 "t.c") 9 "_$" :accept-unicode-escapes t))
'("_wo$rl42d" 18))
(check equal (multiple-value-list (scan-identifier '(" Hello _\\u0145teve " 42 "t.c") 9 "_$" :accept-unicode-escapes t))
'("_\\u0145teve" 20))
(check equal (multiple-value-list (scan-identifier '(" Hello _\\U0145BABEteve " 42 "t.c") 9 "_$" :accept-unicode-escapes t))
'("_\\U0145BABEteve" 24))
(check equal (multiple-value-list (scan-identifier '(" Hello _world\\u014 " 42 "t.c") 9 "_$" :accept-unicode-escapes t))
'("_world" 15))
(check equal (multiple-value-list (scan-identifier '(" Hello _world\\U0145BABXteve " 42 "t.c") 9 "_$" :accept-unicode-escapes t))
'("_world" 15))
:success)
(define-test test/scan-number ()
(check equal (multiple-value-list (scan-number '(" 123 " 42 "t.c") 3))
'("123" 6))
(check equal (multiple-value-list (scan-number '(" 0xBABE42 _wo$rl42d " 42 "t.c") 3))
'("0xBABE42" 11))
(check equal (multiple-value-list (scan-number '(" 0xBABE42+42 " 42 "t.c") 3))
'("0xBABE42" 11))
(check equal (multiple-value-list (scan-number '(" 0xE+12/42 " 42 "t.c") 3))
'("0xE+12" 9))
(check equal (multiple-value-list (scan-number '(" 0.123_4e-56*32 " 42 "t.c") 3))
'("0.123_4e-56" 14))
(check equal (multiple-value-list (scan-number '(" .9999+.1111 " 42 "t.c") 3))
'(".9999" 8))
:success)
(define-test test/scan-punctuation ()
(check equal (multiple-value-list (scan-punctuation '("{&===>>==..." 42 "test.c") 0))
'("{" 1))
(check equal (multiple-value-list (scan-punctuation '("{&===>>==..." 42 "test.c") 1))
'("&=" 3))
(check equal (multiple-value-list (scan-punctuation '("{&===>>==..." 42 "test.c") 3))
'("==" 5))
(check equal (multiple-value-list (scan-punctuation '("{&===>>==..." 42 "test.c") 5))
'(">>=" 8))
(check equal (multiple-value-list (scan-punctuation '("{&===>>==..." 42 "test.c") 8))
'("=" 9))
(check equal (multiple-value-list (scan-punctuation '("{&===>>==..." 42 "test.c") 9))
'("..." 12))
:success)
(define-test test/scan-delimited-literal ()
(check equal (multiple-value-list (scan-delimited-literal '("'e'" 42 "test.c") 0))
'("'e'" 3))
(check equal (multiple-value-list (scan-delimited-literal '("'\\x41'" 42 "test.c") 0))
'("'\\x41'" 6))
:success)
(define-test text/skip-spaces ()
(check equal (skip-spaces-in-text " xyz()" 0) 4)
(check equal (skip-spaces-in-text " xyz()" 7) 7)
(check equal (skip-spaces-in-text " xyz ()" 7) 8)
(check equal (skip-spaces-but-one " xyz()" 0) 3)
(check equal (skip-spaces-but-one " xyz()" 7) 7)
(check equal (skip-spaces-but-one " xyz ()" 7) 7)
:success)
;; (define-test test/comment-in-directive ()
;; "The only white-space characters that shall appear between preprocessing tokens within a preprocessing directive -- are space and horizontal-tab -- including spaces that have replaced comments -- in translation phase 3 --"
;; "# /* comment valid here */ include <stdio.h>")
(define-test test/extract-path ()
(check equal (multiple-value-list (extract-path "#include"
(list (make-instance 'string-literal-token
:text "\"/usr/local/include/\\xe9t\\xe9.h\""))))
'("/usr/local/include/été.h" :quote nil))
(check equal (multiple-value-list (extract-path "#include"
(list (make-instance 'string-literal-token
:text "</usr/local/include/\\xe9t\\xe9.h>"))))
'("/usr/local/include/\\xe9t\\xe9.h" :bracket nil))
(check equal (multiple-value-list (extract-path "#include"
(list (make-instance 'punctuation-token :text "<")
(make-instance 'string-literal-token
:text "/usr/local/include")
(make-instance 'string-literal-token
:text "/file.h")
(make-instance 'punctuation-token :text ">"))))
'("/usr/local/include/file.h" :bracket nil))
:success)
(define-test test/parse-f-m-call-arguments ()
(let ((*context* (make-instance 'context :base-file "test.c" :file "test.c"))
(tokenized-lines (list (list (make-instance 'identifier-token :text "next_line"))))
(after (make-instance 'identifier-token :text "same_line"))
(foo (make-instance 'identifier-token :text "FOO"))
(arg1 (make-instance 'identifier-token :text "arg1"))
(arg2 (make-instance 'identifier-token :text "arg2"))
(plus (make-instance 'punctuation-token :text "+"))
(minus (make-instance 'punctuation-token :text "-"))
(comma (make-instance 'punctuation-token :text ","))
(left (make-instance 'punctuation-token :text "("))
(right (make-instance 'punctuation-token :text ")")))
(check equal
(multiple-value-list
(parse-function-macro-call-arguments foo (list left right after)
tokenized-lines))
(list '(())
(list after)
tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left comma right after)
tokenized-lines))
(list '(() ())
(list after)
tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left arg1 right after)
tokenized-lines))
`(((,arg1))
(,after)
,tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left arg1 comma arg2 right after)
tokenized-lines))
`(((,arg1) (,arg2))
(,after)
,tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left arg1 comma right after)
tokenized-lines))
`(((,arg1) ())
(,after)
,tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left arg1 plus arg2 comma arg1 minus arg2 right after)
tokenized-lines))
`(((,arg1 ,plus ,arg2) (,arg1 ,minus ,arg2))
(,after)
,tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left arg1 left arg2 right comma arg1 minus arg2 right after)
tokenized-lines))
`(((,arg1 ,left ,arg2 ,right) (,arg1 ,minus ,arg2))
(,after)
,tokenized-lines))
(check equal (multiple-value-list
(parse-function-macro-call-arguments foo (list left arg1 left comma arg2 comma right
comma arg1 minus arg2 right after)
tokenized-lines))
`(((,arg1 ,left ,comma ,arg2 ,comma ,right) (,arg1 ,minus ,arg2))
(,after)
,tokenized-lines)))
:success)
(define-test test/all/cpp ()
(test/read-c-string)
(test/number-lines)
(test/substitute-trigraphs)
(test/merge-continued-lines)
(test/remove-comments-in-line)
(test/remove-comments)
(test/scan-identifier)
(test/scan-number)
(test/scan-punctuation)
(test/scan-delimited-literal)
(text/skip-spaces)
(test/extract-path)
(test/parse-f-m-call-arguments)
(test/character-value)
(test/integer-value))
(defun test/all ()
(test/all/cpp))
;;;; THE END ;;;;
| 15,836 | Common Lisp | .lisp | 287 | 42.452962 | 227 | 0.506893 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 737d139b260b28741f7ef651f456acddaa11ca40986ecfdc76c929684923d2c6 | 5,234 | [
-1
] |
5,235 | expression-test.lisp | informatimago_lisp/languages/cpp/expression-test.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: expression-test.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Tests expressions.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-07-06 <PJB> Extracted from expression.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(define-test test/integer-value ()
(check equal (mapcar (function integer-value)
(list (make-number "42" 0 0 "-")
(make-number "0x42" 0 0 "-")
(make-number "0b101010" 0 0 "-")
(make-number "042" 0 0 "-")))
'(42 66 42 34))
:success)
(define-test test/character-value ()
(check equal (mapcar (function character-value)
(list (make-character-literal "'A'" 0 0 "-")
(make-character-literal "'\\x41'" 0 0 "-")
(make-character-literal "'\\n'" 0 0 "-")
(make-character-literal "'λ'" 0 0 "-")))
'(65 65 10 955))
:success)
;;;; THE END ;;;;
| 2,324 | Common Lisp | .lisp | 53 | 38.09434 | 83 | 0.533304 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | cd7ea9f5eeab24a8a5f7d69a5d37be4acc65b08deea232a3a37de77ca562970e | 5,235 | [
-1
] |
5,236 | c-string-reader.lisp | informatimago_lisp/languages/cpp/c-string-reader.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: c-string-reader.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; A C string reader, implememting C string back-slash escapes.
;;;; Also includes a writer to print strings with C back-slash escapes.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-05-22 <PJB> Added character-code-reader-macro, factorized
;;;; out c-escaped-character-map.
;;;; Published as http://paste.lisp.org/display/137262
;;;; 2011-05-21 <PJB> Updated from http://paste.lisp.org/display/69905 (lost).
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(defun c-escaped-character-map (escaped-character)
(case escaped-character
((#\' #\" #\? #\\) escaped-character)
((#\newline) -1)
((#\a) 7)
((#\b) 8)
((#\t) 9)
((#\n) 10)
((#\v) 11)
((#\f) 12)
((#\r) 13)
((#\x) :hexa)
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7) :octal)
(otherwise :default)))
(defun char-unicode (character)
(let ((bytes (babel:string-to-octets (string character)
:encoding :utf-32be
:use-bom nil)))
(+ (* 256 (+ (* 256 (+ (* 256 (aref bytes 0))
(aref bytes 1)))
(aref bytes 2)))
(aref bytes 3))))
(defun character-code-reader-macro (stream quotation-mark)
"Reads the emacs syntax for character
?a -> 64
?\\10 -> 8
?\\x10 -> 16
#\\? must have been already read.
"
(declare (ignore quotation-mark))
(flet ((encode (ch) (char-unicode ch)))
(let ((ch (read-char stream)))
(if (char/= #\\ ch)
(encode ch)
(let* ((ch (read-char stream))
(code (c-escaped-character-map ch)))
(flet ((read-code (*read-base* base-name)
(let ((code (read stream)))
(if (and (integerp code) (<= 0 code (1- char-code-limit)))
code
(cpp-error "Invalid ~A character code: ~A" base-name code)))))
(case code
(:hexa (read-code 16 "hexadecimal"))
(:octal (unread-char ch stream) (read-code 8 "octal"))
(:default ;; In emacs ?\x = ?x
(encode ch))
(otherwise
(if (characterp code)
(encode code)
code)))))))))
;; (set-macro-character #\? 'character-code-reader-macro t)
(defun read-c-string (stream delimiter)
"Read a C string or a C char from the STREAM, depending on delimiter = #\\\" or #\\'.
The initial delimited must have been read already."
;; TODO: "\xE9" and "é" won't issue the same bytes depending on the target encoding "\xE9" is fixed char[]{233,0}.
(let ((buffer (make-array 80 :element-type 'character
:adjustable t :fill-pointer 0))
(state :in-string)
(start 0))
(flet ((process-token (ch)
(ecase state
((:in-string)
(setf state (cond
((char= delimiter ch) :out)
((char= #\\ ch) :escape)
(t (vector-push-extend ch buffer)
:in-string)))
nil)
((:escape)
(setf state :in-string)
(let ((code (c-escaped-character-map ch)))
(case code
(:hexa
(setf state :in-hexa
start (fill-pointer buffer)))
(:octal
(setf state :in-octal
start (fill-pointer buffer))
(vector-push-extend ch buffer))
(:default
(cpp-error "Invalid escape character \\~C at position ~D"
ch (fill-pointer buffer)))
(otherwise
(cond
((characterp code) (vector-push-extend code buffer))
((eql -1 code) #|remove it|#)
(t (vector-push-extend (aref #(- - - - - - -
#\bell #\backspace #\tab
#\linefeed #\vt #\page
#\return)
code)
buffer))))))
nil)
((:in-octal)
(flet ((insert-octal ()
(setf (aref buffer start) (code-char (parse-integer buffer :start start :radix 8))
(fill-pointer buffer) (1+ start)
state :in-string)))
(case ch
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7)
(vector-push-extend ch buffer)
(when (<= 3 (- (fill-pointer buffer) start))
(insert-octal))
nil)
(otherwise
(insert-octal)
:again))))
((:in-hexa)
(case ch
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9
#\a #\b #\c #\d #\e #\f
#\A #\B #\C #\D #\E #\F)
(vector-push-extend ch buffer)
nil)
(otherwise
(if (< start (fill-pointer buffer))
(setf (aref buffer start) (code-char (parse-integer buffer :start start :radix 16))
(fill-pointer buffer) (1+ start))
(cpp-error "Invalid hexadecimal digit at position ~A" (fill-pointer buffer)))
(setf state :in-string)
:again))))))
(loop
:for ch = (read-char stream)
:do (loop :while (process-token ch))
:until (eq state :out)
:finally (return buffer)))))
(defun write-c-string (string &optional (stream *standard-output*))
"Prints the string as a C string, with C escape sequences."
(loop
:for ch :across string
:initially (princ "\"" stream)
:do (princ (case ch
((#\bell) "\\a")
((#\backspace) "\\b")
((#\page) "\\f")
((#\newline
#-#.(cl:if (cl:char= #\newline #\linefeed) '(:and) '(:or))
#\linefeed) "\\n")
((#\return) "\\r")
((#\tab) "\\t")
((#\vt) "\\v")
((#\") "\\\"")
((#\\) "\\\\")
(otherwise
(if (< (char-code ch) 32)
(format nil "\\~3,'0o" (char-code ch))
ch))) stream)
:finally (princ "\"" stream)))
;;;; THE END ;;;;
| 8,385 | Common Lisp | .lisp | 189 | 30.756614 | 117 | 0.435606 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 9bc81e7a2c775b6ff11cad0ac9d2814768f7785b1de567fb6d6078a9098c805a | 5,236 | [
-1
] |
5,237 | c-string-reader-test.lisp | informatimago_lisp/languages/cpp/c-string-reader-test.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: c-string-reader-test.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Tests c-string-reader.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-07-06 <PJB> Extracted from c-string-reader.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(define-test test/read-c-string ()
(let ((*readtable*
(let ((rt (copy-readtable nil)))
(set-macro-character #\" 'read-c-string nil rt)
(set-macro-character #\' 'read-c-string nil rt)
rt)))
(check equal (read-from-string "(\"Hello, bell=\\a, backspace=\\b, page=\\f, newline=\\n, return=\\r, tab=\\t, vt=\\v, \\
\\\"double-quotes\\\", \\'single-quotes\\', question\\?, backslash=\\\\, \\
hexa=\\x3BB, octal=\\101, \\7\\77\\107\\3071\" 'a' '\\xe9' '\\\\' '\\'' '\\n')")
'("Hello, bell=, backspace=, page= , newline=
, return=
, tab= , vt= , \"double-quotes\", 'single-quotes', question?, backslash=\\, hexa=λ, octal=A, ?GÇ1"
"a" "é" "\\" "'" "
"))
:success))
;;;; THE END ;;;;
| 2,266 | Common Lisp | .lisp | 51 | 41.941176 | 124 | 0.571946 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 37d73ce8191da5be196f87c8366ef274557711ab645f471f677bb7b275bdd0f7 | 5,237 | [
-1
] |
5,238 | built-in-macros.lisp | informatimago_lisp/languages/cpp/built-in-macros.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: built-in-macros.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the builtin cpp macros.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-06-27 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(defun string-literal (string)
(make-string-literal (format nil "~S" string)
(context-column *context*) (context-line *context*) (context-file *context*)))
(defun number-literal (value)
(make-number (format nil "~A" value)
(context-column *context*) (context-line *context*) (context-file *context*)))
(defmacro define-built-in-macro (name kind &body lambda-list-and-body)
(let ((lambda-list (if (eql :function kind)
(first lambda-list-and-body)
nil))
(body (if (eql :function kind)
(rest lambda-list-and-body)
lambda-list-and-body)))
`(setf (environment-macro-definition *default-environment* ',name)
(make-instance
',(ecase kind
(:object 'macro-definition/object/computed)
(:function 'macro-definition/function/computed))
:name ',name
:compute-expansion-function ,(if (eq kind :object)
`(lambda (macro-definition)
(declare (ignorable macro-definition))
;;DEBUG;;(print ',name)
,@body)
`(lambda (macro-definition arguments)
(declare (ignorable macro-definition arguments))
(destructuring-bind ,lambda-list arguments
;;DEBUG;;(print ',name)
,@body)))))))
(define-built-in-macro "__TIMESTAMP__" :object
(when (option *context* :warn-date-time)
(cpp-warning *context* "macro ~A might prevent reproducible builds" "__TIMESTAMP__"))
(let ((date (or (file-write-date (context-file *context*)) (get-universal-time))))
(multiple-value-bind (se mi ho da mo ye dow) (decode-universal-time date 0)
(list (string-literal (format nil "~[Mon~;Tue~;Wed~;Thi~;Fri~;Sat~;Sun~] ~[~;Jan~;Feb~;Mar~;Apr~;May~;Jun~;Jul~;Aug~;Sep~;Oct~;Nov~;Dec~] ~2,'0D ~2,'0D:~2,'0D:~2,'0D ~4,'0D"
dow mo da ho mi se ye))))))
(define-built-in-macro "__FILE__" :object
(list (string-literal (file-namestring (context-file *context*)))))
(define-built-in-macro "__BASE_FILE__" :object
(list (string-literal (file-namestring (context-base-file *context*)))))
(define-built-in-macro "__INCLUDE_LEVEL__" :object
(list (number-literal (format nil "~D" (context-include-level *context*)))))
(define-built-in-macro "__STDC__" :object
(list (number-literal 0 #|are we?|#)))
(define-built-in-macro "__DATE__" :object
(when (option *context* :warn-date-time)
(cpp-warning *context* "macro ~A might prevent reproducible builds" "__DATE__"))
(let ((date (get-universal-time)))
(multiple-value-bind (se mi ho da mo ye) (decode-universal-time date 0)
(declare (ignore se mi ho))
(list (string-literal (format nil "~[~;Jan~;Feb~;Mar~;Apr~;May~;Jun~;Jul~;Aug~;Sep~;Oct~;Nov~;Dec~] ~2,'0D ~4,'0D"
mo da ye))))))
(define-built-in-macro "__TIME__" :object
(when (option *context* :warn-date-time)
(cpp-warning *context* "macro ~A might prevent reproducible builds" "__DATE__"))
(let ((date (get-universal-time)))
(multiple-value-bind (se mi ho) (decode-universal-time date 0)
(list (string-literal (format nil "~2,'0D:~2,'0D:~2,'0D" ho mi se))))))
(define-built-in-macro "__COUNTER__" :object
(when (option *context* :directives-only)
(cpp-error *context* "__COUNTER__ expanded inside directive with -fdirectives-only"))
(list (number-literal (prog1 (context-counter *context*)
(incf (context-counter *context*))))))
;;;; THE END ;;;;
| 5,437 | Common Lisp | .lisp | 100 | 44.8 | 179 | 0.563428 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 3b36fdfec8d3a088397231b70d4b83dd500ce1e88c0e4c4074a8a98bbbcf6e96 | 5,238 | [
-1
] |
5,239 | packages.lisp | informatimago_lisp/languages/cpp/packages.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: packages.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the C Preprocessor packages.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-06-27 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(defpackage "COM.INFORMATIMAGO.LANGUAGES.CPP"
(:use "COMMON-LISP"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.STREAM"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.STRING"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.SEQUENCE"
"COM.INFORMATIMAGO.COMMON-LISP.CESARUM.UTILITY"
"COM.INFORMATIMAGO.COMMON-LISP.PARSER.SCANNER"
#|temporarily|# "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.SIMPLE-TEST")
(:shadow "IMPORT" "INCLUDE")
(:shadowing-import-from "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.STRING"
"STRING-DESIGNATOR")
(:shadowing-import-from "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.STREAM"
"COPY-STREAM")
(:import-from "ALEXANDRIA" "PLIST-ALIST")
(:export "PROCESS-TOPLEVEL-FILE"
"CPP-TOKEN" "TOKEN-LINE" "TOKEN-COLUMN" "TOKEN-FILE"
"TOKEN-TEXT" "IDENTIFIER-TOKEN" "NUMBER-TOKEN" "PUNCTUATION-TOKEN"
"OTHER-TOKEN"
"TOKEN-STRING" "TOKEN-SYMBOL" "TOKEN-VALUE"
"*IDENTIFIER-PACKAGE*"
"IDENTIFIER" "NUMBER" "STRING-LITERAL" "CHARACTER-LITERAL" "PUNCTUATION"
"ENVIRONMENT-MACRO-DEFINITION"
"ENVIRONMENT-MACRO-DEFINEDP"
"ENVIRONMENT-MACRO-UNDEFINE"
;;;
"READ-CPP-TOKENS"
"CPP-E"
"*WHITESPACES*" "WHITESPACEP"
"STRING-VALUE" "CHARACTER-VALUE" "INTEGER-VALUE"))
;;;; THE END ;;;;
| 2,857 | Common Lisp | .lisp | 65 | 38.8 | 83 | 0.611828 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 18c33975f2b02ec6c80462e053b405562805ad122ee45f58fe0182410dd9e860 | 5,239 | [
-1
] |
5,240 | cpp-macro.lisp | informatimago_lisp/languages/cpp/cpp-macro.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: cpp-macro.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the cpp macros.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-06-28 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
(defvar *context* nil) ; the current instance of context.
;; Cpp macro definitions are kept in the environment hash-table, keyed
;; by the macro name (string).
(defgeneric environment-macro-definedp (environment macro-name))
(defgeneric environment-macro-undefine (environment macro-name))
(defgeneric environment-macro-definition (environment macro-name))
(defgeneric (setf environment-macro-definition) (definition environment macro-name))
(defun make-environment ()
(make-hash-table :test 'equal))
(defmethod environment-macro-definedp ((environment hash-table) (macro-name string))
(assert (eq 'equal (hash-table-test environment)))
(nth-value 1 (gethash macro-name environment)))
(defmethod environment-macro-undefine ((environment hash-table) (macro-name string))
(assert (eq 'equal (hash-table-test environment)))
(remhash macro-name environment))
(defmethod environment-macro-definition ((environment hash-table) (macro-name string))
(assert (eq 'equal (hash-table-test environment)))
(gethash macro-name environment))
(defmethod (setf environment-macro-definition) (definition (environment hash-table) (macro-name string))
(assert (eq 'equal (hash-table-test environment)))
(setf (gethash macro-name environment) definition))
;; The values kept in the environment are instances of subclasses of macro-definition.
(defclass macro-definition ()
((name :initarg :name :accessor macro-definition-name)))
(defgeneric expand-macro-definition (macro-definition &optional arguments)
(:documentation
"Binds the arguments (list of list of tokens) to the macro
parameters if any, and expands the macro.
object-like macros don't take arguments.
function-like macros take an argument list, possibly empty, but if it
contains a single empty list of tokens and the function-like macro
takes no parameters, then it's still a match (at this stage, we don't
distinguish f() from f( ) anymore.
"))
(defclass macro-definition/object (macro-definition)
((expansion :initarg :expansion :accessor macro-definition-expansion))
(:documentation "Normal object-like macro."))
(defmethod print-object ((macro macro-definition/object) stream)
(let ((*print-circle* nil))
(print-unreadable-object (macro stream :type t :identity t)
(format stream ":name ~S :expansion ~S"
(macro-definition-name macro)
(macro-definition-expansion macro)))
macro))
(defmethod expand-macro-definition ((macro-definition macro-definition/object) &optional (arguments '() argumentsp))
(declare (ignore arguments))
(when argumentsp
(error "~S cannot take arguments for object-like macro ~A" 'expand-macro-definition (macro-definition-name macro-definition)))
(substitute-concatenates (macro-definition-expansion macro-definition)))
(defclass macro-definition/function (macro-definition)
((parameters :initarg :parameters :initform '() :accessor macro-definition-parameters)
(expansion :initarg :expansion :accessor macro-definition-expansion))
(:documentation "Normal function-like macro."))
(defmethod print-object ((macro macro-definition/function) stream)
(let ((*print-circle* nil))
(print-unreadable-object (macro stream :type t :identity t)
(format stream ":name ~S :parameters ~S :expansion ~S"
(macro-definition-name macro)
(macro-definition-parameters macro)
(macro-definition-expansion macro)))
macro))
(defun ellipsis-parameter-p (parameter)
(and (consp parameter)
(eq :ellipsis (first parameter))))
;;; ------------------------------------------------------------
;;; The expand-macro-definition method for normal macros.
;;; ------------------------------------------------------------
#|
object-like macros
------------------
- The macro definition is a single line of token.
- When the macro is expanded, the expansion is macroexpanded:
#undef FOO
#undef BAR
#define FOO BAR
int i[]={ FOO,
#undef BAR
#define BAR 1
FOO,
#undef BAR
#define BAR 2
FOO };
-->
int i[]={ BAR,
1,
2 };
- But happily, an object-like macro cannot expand to a partial
function-like macro invocation:
#define LEFT F("l",
#define RIGHT ,"r")
#define FOO LEFT "foo" RIGHT
1: FOO; /* ok, FOO expands to F("l","foo","r") */
#define F(a,b,c) a##b##c
// 2: FOO; /* good: error: unterminated argument list invoking macro "F" (in expanding LEFT from FOO)*/
- Recursive expansion is detected and prevented.
Therefore we can process object-like macro expansions independently.
function-like macros
--------------------
This is crazy.
- macro arguments are macro-expanded before they are substituted in the macro body,
but not for their stringify and token concatenation use:
#define VOO 42
#define F(X) #X[X]
F(33)
F(VOO)
F(C(VOO,VOO))
-->
"33"[33]
"VOO"[42]
"C(VOO,VOO)"[VOOVOO]
So basically, we need to pass the arguments under two forms.
"If an argument is stringified or concatenated, the prescan does
not occur. If you want to expand a macro, then stringify or
concatenate its expansion, you can do that by causing one macro to
call another macro that does the stringification or
concatenation."
This doesn't sound right, from the above test.
- after substitution the entire macro expansion is again scanned for
macros to be expanded.
- The self-references that do not expand in the first scan are marked
so that they will not expand in the second scan either. !!!
- but happily again, a function-like macro cannot expand to a partial
function-like macro invocation, so we can also perform this later
expansion independently.
But "toplevel" function-like macro calls can span several lines,
including pre-processor directives (#ifs, #defines, #includes, etc).
So parsing function-like macros calls must take into account several
lines, and may have to perform recursive directive processing
#undef LEFT
#undef RIGHT
#undef FOO
#undef F
#define FOO(E) F(l,E,r)
1: FOO(foo); /* ok */
#define F(a,b,c) a##b##c
2: FOO(bar); /* ok since FOO(E) contains the whole F() call. */
3: FOO(
#define F(a,b,c) a##a
baz
#undef F
#define F(a,b,c) c##c
);
4: FOO(
#undef F
#define F(a,b,c) a##a
FOO(baz)
#undef F
#define F(a,b,c) c##c
);
-->
1: F(l,foo,r);
2: lbarr;
3: rr
;
4: rr
;
Note: the result 4! The arguments are macro expanded only when
the macro call F() is being computed, ie. after we've seen the
closing parenthesis.
- macro arguments must be parenthesis-balanced (only (), not {} or []).
Within (), commas don't split arguments:
#define F(X) ((X)+(X))
F((1,2))
-->
((1,2)+(1,2)) /* == 4 */
- unshielded commas in macro arguments are used as argument separators:
#define foo a,b
#define bar(x) lose(x)
#define lose(x) (1+(x))
bar(foo) --> lose(a,b) /* wrong argument count */
- arguments may be empty.
#define foo(a,b) {(0,a),(1,b)}
-->
foo(,) --> {(0,),(1,)}
- cf. variadic parameters.
ambiguity, with:
#define f() foo
#define g(x) bar
then
f() g()
have different argument counts :-)
concatenation
-------------
However, two tokens that don't together form a valid token cannot
be pasted together. For example, you cannot concatenate x with +
in either order. If you try, the preprocessor issues a warning and
emits the two tokens.
Also, ## concatenates only the first or last token of the argument:
#define CONCAT(A,B) A ## B
CONCAT(a b,c d)
-->
a bc d /* 3 tokens */
If the argument is empty, that ‘##’ has no effect.
|#
;; While macroexpanding function-like macros, we need to bind
;; arguments to parameters. Arguments are reified in this argument
;; structure, keeping both the tokens of the arguments, and their
;; macro-expanded form, and with lazy initialization of the
;; stringified version.
(defstruct argument
tokens
expanded
%stringified)
(defun stringify (tokens)
(let ((first-token (find-if-not (function null) tokens)))
(apply (function make-string-literal) (format nil "~S" (mapconcat (function token-text) tokens ""))
(if first-token
(list (token-column first-token)
(token-line first-token)
(token-file first-token))
(list (context-column *context*)
(context-line *context*)
(context-file *context*))))))
(defgeneric argument-stringified (argument))
(defmethod argument-stringified ((argument argument))
(or (argument-%stringified argument)
(setf (argument-%stringified argument) (stringify (argument-tokens argument)))))
(defmethod argument-stringified ((argument list))
(let ((strings (mapcar (lambda (arg)
(mapconcat (function token-text) (argument-tokens arg) ""))
argument))
(first-token (loop
:with args = argument
:while (and args (null (argument-tokens (first args))))
:do (pop args)
:finally (return (when args
(find-if-not (function null) (argument-tokens (first args))))))))
(apply (function make-string-literal)
(format nil "~S" (mapconcat (function identity) strings ","))
(if first-token
(list (token-column first-token)
(token-line first-token)
(token-file first-token))
(list (context-column *context*)
(context-line *context*)
(context-file *context*))))))
(defun concatenate-tokens (tokens)
(let* ((first-token (find-if-not (function null) tokens))
(concatenated
(tokenize-line (cons (mapconcat (function token-text) (remove nil tokens) "")
(if first-token
(list (token-line first-token)
(token-file first-token))
(list (context-line *context*)
(context-file *context*))))
:accept-unicode-escapes (option *context* :accept-unicode-escapes)
:dollar-is-punctuation (option *context* :dollar-is-punctuation))))
(when (rest concatenated)
(cpp-error (first tokens)
"Pasting ~{~A~^ ~} does not give a valid preprocessing token" (mapcar (function token-text) tokens)))
concatenated))
(defun substitute-concatenates (line)
(when line
(if (sharpsharpp (first line))
(progn
(cpp-error (first line) "'##' cannot appear at either end of a macro expansion")
(substitute-concatenates (rest line)))
(loop
:with result = ()
:while line
:do (let ((curr (pop line)))
(if (sharpsharpp (first line))
(let ((file (token-file (first line)))
(lino (token-line (first line))))
(loop
:with concat = (list curr)
:while (sharpsharpp (first line))
:do (pop line)
(unless line
(cpp-error (pseudo-token file lino) "'##' cannot appear at either end of a macro expansion"))
(unless (sharpsharpp (first line))
(push (pop line) concat))
:finally (setf result (nreconc (concatenate-tokens (nreverse concat)) result))))
(push curr result)))
:finally (return (nreverse result))))))
(defun macro-bind (name parameters arguments)
(loop
:with bindings := '()
:with args := arguments
:with pars := parameters
:with no-pars = (null pars)
:while pars
:do (let ((par (pop pars)))
(cond
((ellipsis-parameter-p par)
(push (list* (second par) :ellipsis args) bindings)
(setf args nil))
((null args)
(cpp-error *context* "Missing argument to function-like macro call ~S" (token-text name))
(return :error))
(t
(let ((arg (pop args)))
(push (cons par arg) bindings)))))
:finally (when (and args
(not (and no-pars
(null (cdr args))
(null (car args)))))
(cpp-error *context*
"Too many args for function-like macro call ~S, parameters = ~S, arguments = ~S"
(token-text name) parameters arguments)
(return :error))
(return bindings)))
(defmacro skip-nil (block-name macro-name-token-var line-var tokenized-lines-var)
`(loop :while (null ,line-var)
:do (if (null ,tokenized-lines-var)
(progn
(cpp-error *context* "Reached end of file in function-like macro call ~A"
(token-text ,macro-name-token-var))
(return-from ,block-name nil))
(progn
(setf (context-input-lines *context*) ,tokenized-lines-var)
(unwind-protect
(loop
:do (setf (context-current-line *context*) (pop (context-input-lines *context*)))
:while (sharpp (first (context-current-line *context*)))
:do (process-directive *context* (context-current-line *context*)))
(setf ,line-var (context-current-line *context*)
,tokenized-lines-var (context-input-lines *context*)))))))
(defun macro-bindings-expand-arguments (bindings)
(flet ((marg (tokens)
(make-argument
:tokens tokens
:expanded (reduce (function nconc) (macro-expand-macros *context* tokens '() '() nil
(context-macros-being-expanded *context*))))))
(dolist (binding bindings bindings)
(if (and (listp (cdr binding))
(eq :ellipsis (second binding)))
(setf (cddr binding) (mapcar (function marg) (cddr binding)))
(setf (cdr binding) (marg (cdr binding)))))))
(defun substitute-parameters (definition bindings)
(flet ((get-entry (ident)
(assoc (token-text ident) bindings
:test (function string=)
:key (function token-text))))
(loop :with result := '()
:while definition
:do (let ((item (pop definition)))
(if (atom item)
(cond
((and (commap item) ;; , ## __VA_ARGS__
(cdr definition)
(sharpsharpp (first definition))
(identifierp (second definition))
(listp (cdr (get-entry (second definition))))
(eq :ellipsis (cadr (get-entry (second definition)))))
;;DEBUG;; (print (list ", ##" item (first definition) (second definition) '/ (get-entry (second definition))))
(if (cddr (get-entry (second definition)))
(progn (push item result)
(pop definition)) ; pop ##
(setf definition (cddr definition))))
((identifierp item)
(let ((entry (get-entry item)))
(if entry
(if (and (listp (cdr entry))
(eq :ellipsis (cadr entry)))
(setf result (revappend (rest (loop
:with comma = (make-punctuation "," 0 0 "-")
:for item :in (cddr entry)
:collect comma
:append (argument-expanded item)))
result))
(setf result (revappend (or (argument-expanded (cdr entry)) '(())) result)))
(push item result))))
(t
(push item result)))
(ecase (first item)
(:stringify (let ((entry (get-entry (second item))))
(if entry
(push (argument-stringified (if (and (listp (cdr entry))
(eq :ellipsis (cadr entry)))
(cddr entry)
(cdr entry))) result)
(cpp-error (second item) "'#' is not followed by a macro parameter")))))))
:finally (return (nreverse result)))))
(defmethod expand-macro-definition ((macro-definition macro-definition/function) &optional (arguments '() argumentsp))
(unless argumentsp
(error "~S needs arguments for function-like macro ~A()" 'expand-macro-definition (macro-definition-name macro-definition)))
(let* ((name (macro-definition-name macro-definition))
(parameters (macro-definition-parameters macro-definition))
(definition (macro-definition-expansion macro-definition))
;; bind arguments to parameters, checking variadic parameters:
(bindings (macro-bind name parameters arguments)))
(when (eq :error bindings)
(return-from expand-macro-definition '()))
;; macroexpand arguments
;; we do that after the bindings loop so we don't macro-expand-macros if there's an argcount error.
;;DEBUG;; (print (list :before :bindings bindings))
(setf bindings (macro-bindings-expand-arguments bindings))
;; stringify arguments will be done lazily by argument-stringified.
;;DEBUG;; (print (list :name name :bindings bindings))
;; substitute parameters in definition.
(remove nil (substitute-concatenates (substitute-parameters definition bindings)))))
;;; ------------------------------------------------------------
;;; built-ins, computed macros.
;;; ------------------------------------------------------------
(defclass macro-definition/computed-mixin ()
((compute-expansion-function :initarg :compute-expansion-function
:accessor macro-definition-compute-expansion-function)))
(defclass macro-definition/object/computed (macro-definition/object macro-definition/computed-mixin)
()
(:documentation "Built-in, computed object-like macro."))
(defmethod print-object ((macro macro-definition/object/computed) stream)
(let ((*print-circle* nil))
(print-unreadable-object (macro stream :type t :identity t)
(format stream ":name ~S"
(macro-definition-name macro)))
macro))
(defmethod expand-macro-definition ((macro-definition macro-definition/object/computed) &optional (arguments '() argumentsp))
(declare (ignore arguments))
(when argumentsp
(error "~S cannot take arguments for object-like macro ~A" 'expand-macro-definition (macro-definition-name macro-definition)))
(funcall (macro-definition-compute-expansion-function macro-definition) macro-definition))
(defclass macro-definition/function/computed (macro-definition/function macro-definition/computed-mixin)
()
(:documentation "Built-in, computed function-like macro."))
(defmethod print-object ((macro macro-definition/function/computed) stream)
(let ((*print-circle* nil))
(print-unreadable-object (macro stream :type t :identity t)
(format stream ":name ~S :parameters ~S"
(macro-definition-name macro)
(macro-definition-parameters macro)))
macro))
(defmethod expand-macro-definition ((macro-definition macro-definition/function/computed) &optional (arguments '() argumentsp))
(unless argumentsp
(error "~S needs arguments for function-like macro ~A()" 'expand-macro-definition (macro-definition-name macro-definition)))
(funcall (macro-definition-compute-expansion-function macro-definition) macro-definition arguments))
;;; ------------------------------------------------------------
;;; context
;;; ------------------------------------------------------------
(deftype option-key ()
`(member :warn-date-time
;; Warns when using built-in __DATE__ __TIME__ and __TIMESTAMP__
;; as them may produce artificially different executables.
:directives-only
:substitute-trigraphs
;; allow trigraph substitutions.
:warn-on-trigraph
;; when trigraphs are substituted, warn about it.
:warn-spaces-in-continued-lines
:single-line-comments
;; allow // comments.
:accept-unicode-escapes
;;
:dollar-is-punctuation
;; when true, $ is considered punctuation.
;; when NIL, $ is considered a letter for identifiers.
:warn-on-undefined-identifier
;; in #if expressions warns about undefined identifiers
:generate-sharp-line
;; #line generates '# NN "file"' token lines.
:include-disable-current-directory
;; When true, files are not searched in the current directory.
;; NOTE: current directory is defined as:
;; (or *load-truename* *compile-file-truename*
;; *default-pathname-defaults*)
:include-quote-directories
;; Directories where #include \"\" files are searched.
:include-bracket-directories
;; Directories where #include <> files are searched.
;; May contain keywords indexing search functions in the following a-list:
:include-search-functions
;; An a-list mapping keywords to search functions (lambda (path kind directive) …)
;; kind (member :quote :bracket), directive (member :include :import)
;; RETURN: NIL if include-file is not found,
;; T if include-file is already included, or
;; a pathname to the include-file to be loaded.
))
(defparameter *default-options*
'((:warn-date-time . t)
(:directives-only . nil)
(:substitute-trigraphs . t)
(:warn-on-trigraph . t)
(:warn-spaces-in-continued-lines . t)
(:single-line-comments . t)
(:accept-unicode-escapes . t)
(:dollar-is-punctuation . nil)
(:warn-on-undefined-identifier . nil)
(:trace-includes . nil)
(:include-disable-current-directory . nil)
(:include-quote-directories . ())
(:include-bracket-directories . ())
(:include-search-functions . ())
(:external-format . :default)
(:generate-sharp-line . nil)))
(defvar *default-environment* (make-environment))
(defvar *default-pragma-interpreters* (make-hash-table :test 'equal))
(defclass context ()
((base-file :initarg :base-file
:initform "-"
:accessor context-base-file)
(directory :initarg :directory
:initform nil
:accessor context-directory
:documentation "Include directory of the currently included/imported file, for #include_next.")
(file :initarg :file
:initform "-"
:accessor context-file)
(line :initarg :line
:initform 1
:accessor context-line)
(column :initarg :column
:initform 1
:accessor context-column)
(token :initarg :token
:initform nil
:accessor context-token)
(if-level :initarg :if-level
:initform 0
:accessor context-if-level)
(file-stack :initarg :file-stack
:initform '()
:accessor context-file-stack)
;; file-stack saves (list file line column token if-level input-lines current-line)
(input-lines :initarg :input-lines
:initform '()
:accessor context-input-lines)
(current-line :initarg :current-line
:initform '()
:accessor context-current-line)
(output-lines :initarg :output
:initform '()
:accessor context-output-lines)
(counter :initarg :counter
:initform 0
:accessor context-counter)
(macros-being-expanded :initarg :macros-being-expanded
:initform '()
:accessor context-macros-being-expanded)
(options :initarg :options
:initform (copy-tree *default-options*)
:accessor context-options)
(environment :initarg :environment
:initform (copy-hash-table *default-environment*)
:accessor context-environment)
(pragma-interpreters :initarg :pragma-interpreters
:initform (copy-hash-table *default-pragma-interpreters*)
:accessor context-pragma-interpreters
:documentation "An a-list mapping module name string to a function taking two arguments: the context and a list of tokens.")
(pragmas :initarg :pragmas
:initform (make-hash-table :test 'equal)
:accessor context-pragmas
:documentation "An equal hash-table for pragmas defined by the program. Keys may be symbols or lists of symbols.")))
(defun option (context option)
(cdr (assoc option (context-options context))))
(defgeneric context-include-level (context))
(defmethod context-include-level ((context context))
(length (context-file-stack context)))
(defgeneric context-push-file (context path directory input-lines))
(defmethod context-push-file ((context context) path directory input-lines)
(push (list (context-directory context)
(context-file context)
(context-line context)
(context-column context)
(context-token context)
(context-if-level context)
(context-input-lines context)
(context-current-line context))
(context-file-stack context))
(setf (context-directory context) directory
(context-file context) path
(context-line context) 1
(context-column context) 1
(context-token context) nil
(context-if-level context) 0
(context-input-lines context) input-lines
(context-current-line context) nil)
context)
(defgeneric context-pop-file (context))
(defmethod context-pop-file ((context context))
(let ((data (pop (context-file-stack context))))
(setf (context-directory context) (pop data)
(context-file context) (pop data)
(context-line context) (pop data)
(context-column context) (pop data)
(context-token context) (pop data)
(context-if-level context) (pop data)
(context-input-lines context) (pop data)
(context-current-line context) (pop data)))
context)
(defgeneric update-context (context &key token line column file))
(defmethod update-context ((context context) &key
(token nil tokenp)
(line nil linep)
(column nil columnp)
(file nil filep))
(when tokenp (setf (context-token context) token))
(when linep (setf (context-line context) line))
(when columnp (setf (context-column context) column))
(when filep (setf (context-file context) file))
context)
;;; ------------------------------------------------------------
;;; macro-expand-macros, expands macro on one or more tokenized lines.
;;; ------------------------------------------------------------
(defmacro expect (macro-name-token-var token-predicate-name line-var tokenized-lines-var)
`(block expect
(skip-nil expect ,macro-name-token-var ,line-var ,tokenized-lines-var)
(if (,token-predicate-name (first ,line-var))
(return-from expect (pop ,line-var))
(progn
(cpp-error (first ,line-var) "Expected a ~A in function-like macro call ~A, not ~A"
(token-predicate-label ',token-predicate-name)
(token-text ,macro-name-token-var)
(token-text (first ,line-var)))
(return-from expect nil)))))
(defun parse-function-macro-call-arguments (macro-name-token line tokenized-lines)
;; function-macro-call ::= macro-name '(' arglist ')' .
;; arglist ::= argument | argument ',' arglist .
;; argument ::= | argument-item argument .
;; argument-item ::= non-parenthesis-or-comma-token | parenthesized-item-list .
;; parenthesized-item-list ::= '(' item-list ')' .
;; item-list ::= | non-parenthesis-or-comma-token | ',' | parenthesized-item-list .
(labels ((skip-nil-not-eof-p ()
(block skip
(skip-nil skip macro-name-token line tokenized-lines)
t))
(arglist ()
(loop
:collect (parse-argument)
:while (and (skip-nil-not-eof-p)
(commap (first line)))
:do (pop line)))
(parenthesized-item-list ()
(let ((left (expect macro-name-token openp line tokenized-lines))
(items (item-list))
(right (or (expect macro-name-token closep line tokenized-lines)
(list (make-punctuation ")" 1 1 "-")))))
(nconc (list left) items (list right))))
(item-list ()
(loop
:while (and (skip-nil-not-eof-p)
(not (closep (first line))))
:if (openp (first line))
:append (parenthesized-item-list)
:else
:collect (pop line)))
(parse-argument-item ()
(cond
((openp (first line))
(parenthesized-item-list))
((commap (first line))
'())
(t
(list (pop line)))))
(parse-argument ()
(when (skip-nil-not-eof-p)
(if (commap (first line))
'()
(loop
:while (and (skip-nil-not-eof-p)
(not (commap (first line)))
(not (closep (first line))))
:nconc (parse-argument-item))))))
(if (expect macro-name-token openp line tokenized-lines)
(values (let ((arglist (arglist)))
(unless (expect macro-name-token closep line tokenized-lines)
(setf line nil))
arglist)
line
tokenized-lines)
(values '() line tokenized-lines))))
(defgeneric macro-expand-macros (context line tokenized-lines output-lines allow-defined already-expanded))
(defmethod macro-expand-macros ((context context) line tokenized-lines output-lines allow-defined already-expanded)
(loop
:with environment = (context-environment context)
:with out-line := '()
:while line
:do (flet ((definedp (identifier)
(make-number (if (environment-macro-definedp (context-environment context) (token-text identifier))
"1" "0"))))
(let* ((token (pop line))
(name (and token (token-text token))))
(if (identifierp token)
(cond ((and allow-defined (string= "defined" name))
(let ((next (first line)))
(cond ((openp next)
(pop line)
(let ((name (pop line)))
(if (identifierp name)
(progn
(if (closep (first line))
(pop line)
(cpp-error name "Missing a closing parenthesis after defined(~A" (token-text name)))
(push (definedp name) out-line))
(progn
(cpp-error (or next context) "operator \"defined\" requires an identifier")
(push (make-number "0") out-line)))))
((identifierp next)
(pop line)
(push (definedp next) out-line))
(t
(cpp-error (or next context) "operator \"defined\" requires an identifier")
(push (make-number "0") out-line)))))
((environment-macro-definedp environment name)
(let ((definition (environment-macro-definition environment name)))
(etypecase definition
(macro-definition/object
(if (member name already-expanded :test (function string=))
(push token out-line)
(setf out-line (nreconc (first (macro-expand-macros context (expand-macro-definition definition)
'() '() allow-defined
(cons name already-expanded)))
out-line))))
(macro-definition/function
(if (and line (openp (first line)))
(if (member name already-expanded :test (function string=))
(push token out-line)
(let (arguments)
(multiple-value-setq (arguments line tokenized-lines) (parse-function-macro-call-arguments token line tokenized-lines))
(setf out-line (nreconc (first (macro-expand-macros context (expand-macro-definition definition arguments)
'() '() allow-defined
(cons name already-expanded)))
out-line))))
(push token out-line))))))
(t
(push token out-line)))
(push token out-line))))
:finally (push (nreverse out-line) output-lines))
(values output-lines tokenized-lines))
;;;; THE END ;;;;
| 38,020 | Common Lisp | .lisp | 755 | 37.202649 | 157 | 0.547391 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 52d9ad8f56a90cc0d7de504d5136b3be136162587ab53a83f93e78b62b469e5a | 5,240 | [
-1
] |
5,241 | cpp.lisp | informatimago_lisp/languages/cpp/cpp.lisp | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: cpp.lisp
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; This is a C preprocessor.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-06-23 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf *readtable* (copy-readtable nil)))
(in-package "COM.INFORMATIMAGO.LANGUAGES.CPP")
;;; --------------------
(declaim (inline trigraph-character))
(defun trigraph-character (char)
;; Trigraph: ??( ??) ??< ??> ??= ??/ ??' ??! ??-
;; Replacement: [ ] { } # \ ^ | ~
(case char
(#\( #\[)
(#\) #\])
(#\< #\{)
(#\> #\})
(#\= #\#)
(#\/ #\\)
(#\' #\^)
(#\! #\|)
(#\- #\~)
(otherwise nil)))
(defun substitute-trigraphs (line &key warn-on-trigraph)
(let ((text (line-text line)))
(when (search "??" text)
(loop
:with tri := nil
:with j := 0
:with i := 0
:while (< i (length text))
:if (and (< (+ 2 i) (length text))
(char= #\? (aref text i))
(char= #\? (aref text (1+ i)))
(setf tri (trigraph-character (aref text (+ 2 i)))))
:do (when warn-on-trigraph
(cpp-warning line "found trigraph ??~A converted to ~A" (aref text (+ 2 i)) tri))
(setf (aref text j) tri)
(incf j)
(incf i 3)
:else
:do (setf (aref text j) (aref text i))
(incf j)
(incf i)
:finally (setf (line-text line) (subseq text 0 j)))))
line)
;;; --------------------
(defun continued-line-p (line)
(let ((len (length line)))
(when (plusp len)
(let ((spaces (char= #\space (aref line (decf len))))
(last-char (find-if (lambda (ch) (char/= #\space ch))
line :from-end t)))
(values (when (eql last-char #\\)
(position #\\ line :from-end t))
spaces)))))
(defun merge-continued-lines (lines &key warn-spaces-in-continued-lines)
(loop
:while lines
:collect (let ((line (pop lines)))
(multiple-value-bind (continuedp spacesp) (continued-line-p (line-text line))
(if continuedp
(let ((lino (line-lino line))
(file (line-file line)))
(make-numbered-line
:text (concatenate-strings
(loop :with result = '()
:while continuedp
:do (when (and spacesp warn-spaces-in-continued-lines)
(cpp-warning (pseudo-token file lino) "spaces after line continuation character"))
(push (subseq (line-text line) 0 continuedp) result)
(setf line (pop lines))
(if (null line)
(progn
(cpp-warning (pseudo-token file lino) "last line is a continued line")
(setf continuedp nil))
(multiple-value-setq (continuedp spacesp) (continued-line-p (line-text line))))
:finally (push (line-text line) result)
(return (nreverse result))))
:lino lino
:file file))
line)))))
;;; --------------------
(defun remove-comments-in-line (comment-start-line current-line state single-line-comments)
(destructuring-bind (text lino file) current-line
(flet ((concatenate-chunks (chunks)
(if comment-start-line
(make-numbered-line :text (mapconcat (function identity)
(cons (line-text comment-start-line) chunks)
" ")
:lino (line-lino comment-start-line)
:file (line-file comment-start-line))
(make-numbered-line :text (mapconcat (function identity) chunks " ")
:lino (line-lino current-line)
:file (line-file current-line)))))
(loop
:with chunks := '()
:with start := (ecase state
(:top 0)
(:in-multiline-comment (length text)))
:with i := 0
:while (< i (length text))
:do (let ((ch (aref text i)))
(ecase state
(:top
(case ch
((#\") (incf i) (setf state :in-string))
((#\') (incf i) (setf state :in-character))
((#\/)
(incf i)
(when (< i (length text))
(let ((ch (aref text i)))
(case ch
((#\/) ;;single line comment
(when single-line-comments
(return-from remove-comments-in-line
(values (concatenate-chunks (nreverse (cons (subseq text start (1- i)) chunks)))
state))))
((#\*)
(incf i)
(push (subseq text start (- i 2)) chunks)
(setf state :in-multiline-comment
start (length text)))))))
(otherwise (incf i))))
(:in-multiline-comment
(case ch
((#\*)
(incf i)
(when (< i (length text))
(let ((ch (aref text i)))
(when (char= ch #\/)
(incf i)
(setf start i)
(setf state :top)))))
(otherwise
(incf i))))
(:in-string
(case ch
((#\\)
(incf i)
(if (< i (length text))
(incf i)
(progn (cpp-error (pseudo-token file lino) "backslash in string literal at the end of the line")
(setf state :top))))
((#\")
(incf i)
(setf state :top))
(otherwise (incf i))))
(:in-character
(case ch
((#\\)
(incf i)
(if (< i (length text))
(incf i)
(progn (cpp-error (pseudo-token file lino) "backslash in character literal at the end of the line")
(setf state :top))))
((#\')
(incf i)
(setf state :top))
(otherwise (incf i))))))
:finally (return (case state
(:in-string
(cpp-error (pseudo-token file lino) "unterminated string literal at the end of the line")
(values (concatenate-chunks (nreverse chunks)) :top))
(:in-character
(cpp-error (pseudo-token file lino) "unterminated character literal at the end of the line")
(values (concatenate-chunks (nreverse chunks)) :top))
(:top
(values (concatenate-chunks (nreverse (if (< start (length text))
(cons (subseq text start) chunks)
chunks)))
state))
(:in-multiline-comment
(values (concatenate-chunks (nreverse chunks))
state))))))))
(defun remove-comments (lines &key (single-line-comments t))
(loop
:with state := :top
:while lines
:collect (let* ((line (pop lines))
(lino (line-lino line))
(file (line-file line)))
(multiple-value-bind (new-line new-state)
(remove-comments-in-line nil line state single-line-comments)
(loop
:while (and (eql new-state :in-multiline-comment) lines)
:do (multiple-value-setq (new-line new-state)
(remove-comments-in-line new-line (pop lines) new-state single-line-comments)))
(when (eql new-state :in-multiline-comment)
(cpp-error (pseudo-token file lino) "end of file before end of multiline comment")
(setf new-state :top))
(setf state new-state)
new-line))))
;;; --------------------
(defun skip-spaces-in-text (text start)
(loop
:while (and (< start (length text))
(whitespacep (aref text start)))
:do (incf start))
start)
(defun skip-spaces-but-one (text start)
(let ((start (skip-spaces-in-text text start)))
(when (and (plusp start)
(whitespacep (aref text (1- start))))
(decf start))
start))
(defun small-unicode-escape-p (text start)
(and (<= (+ start 6) (length text))
(char= #\\ (aref text start))
(char= #\u (aref text (1+ start)))
(let ((hex (subseq text (+ 2 start) (+ 6 start))))
(and (every (lambda (ch) (digit-char-p ch 16)) hex)
(parse-integer hex :radix 16 :junk-allowed t)))))
(defun big-unicode-escape-p (text start)
(and (<= (+ start 10) (length text))
(char= #\\ (aref text start))
(char= #\U (aref text (1+ start)))
(let ((hex (subseq text (+ 2 start) (+ 10 start))))
(and (every (lambda (ch) (digit-char-p ch 16)) hex)
(parse-integer hex :radix 16 :junk-allowed t)))))
;; (small-unicode-escape-p "(\\uBEB)" 1)
(defun scan-identifier (line start special &key (accept-unicode-escapes nil))
"SPECIAL: The special characters allowed in identifiers (`_' or `_$')
RETURN: the token text; the end position."
;; /[_$a-zA-Z][_$a-zA-Z0-9]*/
;; $ is a gcc extension.
;; \uxxxx and \Uxxxxxxxx accepted here
;; (the 1999 C standard would allow extended characters too).
(loop
:with text := (line-text line)
:with end := start
:while (< end (length text))
:do (let ((ch (aref text end)))
(cond ((or (alphanumericp ch)
(find ch special))
(incf end))
((and accept-unicode-escapes (small-unicode-escape-p text end))
(incf end 6)) ;\uxxxx
((and accept-unicode-escapes (big-unicode-escape-p text end))
(incf end 10)) ;\Uxxxxxxxx
(t
(loop-finish))))
:finally (return (values (subseq text start end) end))))
(defun scan-number (line start)
;; preprocessing number, /.?[0-9]\([a-zA-Z0-9_.]\|[EepP][-+]\)+/
;; all normal integer and floating point constants.
;; 0xE+12 is a preprocessing number, not 0xE + 12.
;; We've already checked for /.[0-9]/ or /[0-9]/
(loop
:with text := (line-text line)
:with end := (if (and (char= #\. (aref text start))
(< (1+ start) (length text))
(digit-char-p (aref text (1+ start))))
(1+ start)
start)
:while (< end (length text))
:do (let ((ch (aref text end)))
(cond
((find ch "eEpP")
(if (and (< (1+ end) (length text))
(find (aref text (1+ end)) "-+"))
(incf end 2)
(incf end 1)))
((or (alphanumericp ch) (find ch "._"))
(incf end))
(t
(loop-finish))))
:finally (return (values (subseq text start end) end))))
(defun scan-delimited-literal (line start)
(loop
:with text := (line-text line)
:with terminator = (ecase (aref text start)
(#\" #\")
(#\' #\')
(#\< #\>))
:with end := (1+ start)
:while (< end (length text))
:do (let ((ch (aref text end)))
(cond
((char= terminator ch)
(incf end)
(loop-finish))
((char= #\\ ch)
(if (< (1+ end) (length text))
(incf end 2)
(cpp-error line "unterminated ~:[string~;character~] literal ending with incomplete escape"
(char= terminator #\'))))
(t
(incf end))))
:finally (return (values (subseq text start end) end))))
(defun scan-punctuation (line start)
;; Digraph: <% %> <: :> %: %:%:
;; Punctuator: { } [ ] # ##
(let* ((text (line-text line))
(ch (aref text start)))
(flet ((greedy2 (alternatives)
(if (and (< (1+ start) (length text))
(find (aref text (1+ start)) alternatives))
(values (subseq text start (+ 2 start)) (+ 2 start))
(values (subseq text start (1+ start) ) (1+ start))))
(greedy3 (alternatives token)
(cond
((and (<= (+ (length token) start) (length text))
(string= text token :start1 start :end1 (+ (length token) start)))
(values (subseq text start (+ (length token) start)) (+ (length token) start)))
((and (< (1+ start) (length text))
(find (aref text (1+ start)) alternatives))
(values (subseq text start (+ 2 start)) (+ 2 start)))
(t
(values (subseq text start (1+ start) ) (1+ start))))))
(case ch
((#\( #\) #\, #\; #\? #\@ #\[ #\] #\{ #\} #\~)
(values (subseq text start (1+ start)) (1+ start)))
((#\! #\* #\/ #\= #\^) (greedy2 "="))
((#\#) (greedy2 "#"))
((#\&) (greedy2 "&="))
((#\+) (greedy2 "+="))
((#\:) (greedy2 ":>"))
((#\|) (greedy2 "|="))
((#\.) (greedy3 "*" "..."))
((#\-) (greedy3 "-=>" "->*"))
((#\<) (greedy3 "%:<=" "<<="))
((#\>) (greedy3 "=>" ">>="))
((#\%) (greedy3 "=>:" "%:%:"))
(otherwise
(cpp-error line "invalid punctuation: ~S" ch)
(values "?" (1+ start)))))))
(defun punctuatorp (ch)
(find ch "!#%&()*+,-./:;<=>?[\\]^{|}~"))
(defun tokenize-line (line &key (accept-unicode-escapes nil)
(dollar-is-punctuation nil))
(destructuring-bind (text lino file) line
(loop
:with first-identifier := (if dollar-is-punctuation
"_"
"_$")
:with start := 0
:with header := 1 ; we track #import and #include to allow <header.h> delimited literals.
:with record-space-token := nil ; we track #define to detect the same in NAME ( vs. NAME(
:do (setf start (ecase record-space-token
((nil)
(skip-spaces-in-text text start))
((:before-name)
(setf record-space-token :after-name)
(skip-spaces-in-text text start))
(:after-name
(setf record-space-token nil)
(skip-spaces-but-one text start))))
:while (< start (length text))
:collect (let ((ch (aref text start)))
(cond
((or (find ch first-identifier)
(alpha-char-p ch)
(and accept-unicode-escapes
(char= #\\ ch)
(< (1+ start) (length text))
(char-equal #\u (aref text (1+ start)))))
(multiple-value-bind (token end) (scan-identifier line start first-identifier
:accept-unicode-escapes accept-unicode-escapes)
(when (eql 2 header)
(when (and (null record-space-token)
(string= "define" token))
(setf record-space-token :before-name))
(setf header (if (or (string= "include" token)
(string= "import" token))
3
nil)))
(prog1 (make-identifier token start lino file)
(setf start end))))
((whitespacep ch)
(prog1 (make-punctuation " " start lino file)
(incf start)))
((or (and (char= ch #\.)
(< (1+ start) (length text))
(digit-char-p (aref text (1+ start))))
(digit-char-p ch))
(multiple-value-bind (token end) (scan-number line start)
(setf header nil)
(prog1 (make-number token start lino file)
(setf start end))))
((char= #\" ch)
(multiple-value-bind (token end) (scan-delimited-literal line start)
(setf header nil)
(prog1 (make-string-literal token start lino file)
(setf start end))))
((char= #\' ch)
(multiple-value-bind (token end) (scan-delimited-literal line start)
(setf header nil)
(prog1 (make-character-literal token start lino file)
(setf start end))))
((and (eql 3 header) (char= #\< ch))
(multiple-value-bind (token end) (scan-delimited-literal line start)
(setf header nil)
(prog1 (make-string-literal token start lino file)
(setf start end))))
((punctuatorp ch)
(multiple-value-bind (token end) (scan-punctuation line start)
(if (and (eql 1 header) (string= "#" token))
(setf header 2)
(setf header nil))
(prog1 (make-punctuation token start lino file)
(setf start end))))
(t ;; others
(setf header nil)
(prog1 (make-other (subseq text start (1+ start)) start lino file)
(incf start))))))))
;;; --------------------
;; The preprocessor is greedy: a+++++b --> a ++ ++ + b
;; even when a ++ + ++ b could be legal c but not a ++ ++ + b.
;;
;;
;; The compiler doesn't retokenize: the pre-processor provides a token
;; stream to the compiler.
;;
;; Tokens:
;;
;; - identifiers, /[_$a-zA-Z][_$a-zA-Z0-9]*/
;; $ is a gcc extension.
;; \u and \U accepted here \uxxxx or \Uxxxxxxxx
;; (the 1999 C standard would allow extended characters too).
;;
;; - preprocessing number, /.?[0-9]\([a0zA0Z0-9_.]\|[EepP][-+]\)+/
;; all normal integer and floating point constants.
;; 0xE+12 is a preprocessing number, not 0xE + 12.
;;
;; - string literals, and character literals "…" '…' with \ escapes.
;; + "…" and <…> for header file names, where \ is a normal character.
;; NUL is preserved.
;;
;; - punctuators,
;; all ascii punctuation but `@’, ‘$’, and ‘`’.
;; and 2 and 3 character operators, including digraphs:
;;
;; Digraph: <% %> <: :> %: %:%:
;; Punctuator: { } [ ] # ##
;;
;; - others: `@’, ‘$’, and ‘`’.
;; control characters but NUL, 127<code,
;;
;; Outside of strings, NUL is considered a whitespace.
(defun read-cpp-tokens (character-stream
&key
(file-name "-")
(substitute-trigraphs nil)
(warn-on-trigraph nil)
(warn-spaces-in-continued-lines nil)
(single-line-comments t)
(accept-unicode-escapes nil)
(dollar-is-punctuation nil))
(let ((lines (number-lines (stream-to-string-list character-stream) file-name)))
(when substitute-trigraphs
(dolist (line lines)
(substitute-trigraphs line :warn-on-trigraph warn-on-trigraph)))
(mapcar (lambda (line)
(tokenize-line line
:accept-unicode-escapes accept-unicode-escapes
:dollar-is-punctuation dollar-is-punctuation))
(remove-comments (merge-continued-lines lines
:warn-spaces-in-continued-lines
warn-spaces-in-continued-lines)
:single-line-comments single-line-comments))))
;;;; --------------------
;;;; Processing directives
;;;; --------------------
(defmacro with-cpp-line (line &body body)
(let ((vtoken (gensym)))
`(let* ((,vtoken (pop ,line))
(file (token-file ,vtoken))
(lino (token-line ,vtoken)))
(update-context *context* :file file :line lino :column (token-column ,vtoken) :token ,vtoken)
(pop ,line)
(locally
,@body))))
;;; --------------------
;;; #define
;;; --------------------
(defun parse-stringifies (line parameters)
(loop
:while line
:if (sharpp (first line))
:collect (let* ((sharp (pop line))
(file (token-file sharp))
(lino (token-line sharp)))
(let ((parameter (pop line)))
(if (or (null parameter)
(not (find-if (lambda (par)
(string= (token-text parameter)
(token-text (if (and (listp par)
(eq :ellipsis (first par)))
(second par)
par))))
parameters)))
(progn
(cpp-error (pseudo-token file lino) "'#' is not followed by a macro parameter")
(if (null parameter)
sharp
parameter))
`(:stringify ,parameter))))
:else
:collect (pop line)))
(defun check-concatenates (line)
;; ^ ## A and A ## $ are invalid.
;; A ## ## B // valid because A ## empty = A
(loop
:while (and line (sharpsharpp (first line)))
:do (cpp-error (first line) "'##' cannot appear at either end of a macro expansion")
(pop line))
(loop
:while (and line (sharpsharpp (first (last line))))
:do (cpp-error (first line) "'##' cannot appear at either end of a macro expansion")
(setf line (butlast line)))
line)
(defun parse-function-macro-definition-body (line parameters)
(when line
(check-concatenates (parse-stringifies line parameters))))
(defun parse-object-macro-definition-body (line)
(when line
(check-concatenates line)))
(defun parse-macro-definition (name line)
;; (format t "(parse-macro-definition ~3A ~A ~S)~%" (openp (first line)) name line)
(cond
((null line)
(make-instance 'macro-definition/object
:name name
:expansion '()))
((openp (first line))
(let ((file (token-file (first line)))
(lino (token-line (first line))))
(pop line)
(let ((parameters (loop
:with result := '()
:for parameter := (first line)
:unless (closep parameter)
:do (let ((par (cond
((identifierp parameter)
(pop line)
(if (and line (ellipsisp (first line)))
(progn
(pop line)
(unless (and line (closep (first line)))
(cpp-error parameter "ellipsis should be the last macro parameter"))
(list :ellipsis parameter))
(progn
(unless (and line (or (commap (first line)) (closep (first line))))
(cpp-error "Missing a comma after parameter ~A" (token-text parameter)))
parameter)))
((ellipsisp parameter)
(pop line)
(unless (and line (closep (first line)))
(cpp-error parameter "ellipsis should be the last macro parameter"))
(list :ellipsis (make-identifier "__VA_ARGS__" 0 0 "-")))
(t
(cpp-error parameter "Expected a macro parameter name, not ~S" (token-text parameter))
(unless (commap parameter)
(pop line))
nil))))
(when par (push par result)))
:while (and line (commap (first line)))
:do (pop line) ; comma
:finally (if (and line (closep (first line)))
(pop line)
(cpp-error (pseudo-token file lino) "Expected a closing parentheses after the parameter list"))
(return (nreverse result)))))
(make-instance 'macro-definition/function
:name name
:parameters parameters
:expansion (parse-function-macro-definition-body line parameters)))))
((spacep (first line))
(pop line)
(make-instance 'macro-definition/object
:name name
:expansion (parse-object-macro-definition-body line)))
(t
(make-instance 'macro-definition/object
:name name
:expansion (parse-object-macro-definition-body line)))))
(defgeneric define (context))
(defmethod define ((context context))
(with-cpp-line (context-current-line context)
(if (context-current-line context)
(let ((name (pop (context-current-line context))))
(if (identifierp name)
(let ((old-definition (environment-macro-definition (context-environment context) (token-text name)))
(new-definition (parse-macro-definition name (context-current-line context))))
(when (environment-macro-definedp (context-environment context) (token-text name))
(unless (equal old-definition new-definition)
(cpp-warning name "Redefining the macro ~A with a different definition" (token-text name))))
(setf (environment-macro-definition (context-environment context) (token-text name)) new-definition))
(cpp-error (first (context-current-line context))
"Didn't expect anything after the macro name after #define, not ~S"
(token-text (first (context-current-line context))))))
(cpp-error context "Missing macro name after #define"))))
;;; --------------------
;;; #undef
;;; --------------------
(defgeneric undef (context))
(defmethod undef ((context context))
(with-cpp-line (context-current-line context)
(if (context-current-line context)
(let ((name (pop (context-current-line context))))
(if (identifierp name)
(environment-macro-undefine (context-environment context) (token-text name))
(cpp-error name "Expected an identifier as macro name after #undef, not ~S" (token-text name)))
(when (context-current-line context)
(cpp-error (first (context-current-line context))
"Didn't expect anything after the macro name after #undef, not ~S"
(token-text (first (context-current-line context))))))
(cpp-error context "Missing macro name after #undef"))))
;;; --------------------
;;; #include & #import
;;; --------------------
;; TODO: implement caching of already included files with #ifndef/#define and #import.
;; #include <> searches files only in *include-bracket-directories*
;;
;; #include "" searches files
;; in the current directory unless *include-disable-current-directory* is true,
;; then in *include-quote-directories*
;; and finally in *include-bracket-directories*.
(defun search-file-in-directories (include-file directories kind directive)
(loop
:with include-search-functions := (option *context* :include-search-functions)
:for directory :in directories
:for path := (if (keywordp directory)
(let ((search-function (cdr (assoc directory include-search-functions))))
(if search-function
(funcall search-function include-file kind directive)
(progn
(cpp-warning "No search function for key ~S" directory)
nil)))
(merge-pathnames include-file directory))
:when (and path (or (eq t path) (probe-file path)))
:do (return (values path directory))
:finally (return nil)))
(defun include-directories (kind)
(let ((include-disable-current-directory (option *context* :include-disable-current-directory))
(include-quote-directories (option *context* :include-quote-directories))
(include-bracket-directories (option *context* :include-bracket-directories)))
(append (if (eq kind :quote)
(remove-duplicates
(append (unless include-disable-current-directory
(list (make-pathname :name nil :type nil :version nil)))
include-quote-directories)
:test (function equal))
'())
(remove-duplicates include-bracket-directories :test (function equal)))))
(defgeneric perform-include (context include-file kind directive))
(defmethod perform-include ((context context) include-file kind directive)
;; TODO: skip duplicate #import and #ifndef/#define #include
(flet ((include (path directory)
(when (option context :trace-includes)
(format *trace-output* "Including ~S~%" path))
(read-and-process-file context path directory)))
(let ((include-directories (include-directories kind)))
(when (eq directive :include-next)
(setf include-directories (cdr (member (context-directory context)
include-directories
:test (function equal)))))
(multiple-value-bind (path directory)
(search-file-in-directories include-file include-directories kind directive)
(cond ((eq t path) #|done|#)
(path (include path directory))
(t (cpp-error context
"Cannot find a file ~C~A~C in the include directories ~S"
(if (eq kind :quote) #\" #\<)
include-file
(if (eq kind :quote) #\" #\>)
include-directories)))))))
(defgeneric token-string (token)
(:method ((token token))
(token-text token))
(:method ((token string-literal-token))
(with-input-from-string (in (token-text token))
(read-c-string in (read-char in))))
(:method ((token character-literal-token))
(with-input-from-string (in (token-text token))
(read-c-string in (read-char in)))))
;; (princ (token-string (make-instance 'string-literal-token :text "\"abc\\ndef\\t\\xe9t\\xe9\\a\"")))
(defun extract-path (directive line)
(let ((token (first line)))
(cond
((string-literal-p token)
(let ((text (token-text token)))
(cond ((zerop (length text))
(cpp-error token "Invalid empty path")
(values "" :quote (rest line)))
((char= #\< (aref text 0))
(values (subseq text 1 (1- (length text))) :bracket (rest line)))
(t
(values (token-string token) :quote (rest line))))))
((open-bracket-p token)
(pop line)
(values (mapconcat (function token-text) (loop
:with item
:while line
:do (setf item (pop line))
:until (close-bracket-p item)
:collect item) "") :bracket line))
(t
(cpp-error (first line) "In directive ~A, invalid path ~S"
directive (mapconcat (function token-text) line ""))
(values nil nil nil)))))
(defgeneric include-common (context directive))
(defmethod include-common ((context context) directive)
(with-cpp-line (context-current-line context)
(if (context-current-line context)
;; macro-functions must stand on a single line after #include/#import.
(let ((line (first (macro-expand-macros context (context-current-line context)
'() '() nil '()))))
(multiple-value-bind (path kind line) (extract-path directive line)
(when path
(perform-include context path kind directive))
(when line
(cpp-error (first line) "Didn't expect anything after the path after #~(~A~), not ~S"
directive (token-text (first line))))))
(cpp-error context "Missing path after #~(~A~)" directive)))
context)
(defgeneric include-next (context))
(defmethod include-next ((context context))
(include-common context :include-next))
(defgeneric include (context))
(defmethod include ((context context))
(include-common context :include))
(defgeneric import (context))
(defmethod import ((context context))
(include-common context :import))
;;; --------------------
;;; #ifdef
;;; --------------------
(defun parse-single-macro-name (line where)
(cond
((null line)
(cpp-error *context* "Missing a macro name after ~A" where)
nil)
((cddr line)
(cpp-error (first line) "Unexpected tokens after macro name ~A after ~A" (token-text (first line)) where)
nil)
((identifierp (first line))
(first line))
(t
(cpp-error (first line) "Invalid macro name ~A after ~A" (token-text (first line)) where)
nil)))
(defmacro define-cpp-line-predicate (name key)
`(defun ,name (line)
(and (cdr line)
(sharpp (car line))
(string= ,key (token-text (cadr line))))))
(define-cpp-line-predicate if-line-p "if")
(define-cpp-line-predicate ifdef-line-p "ifdef")
(define-cpp-line-predicate ifndef-line-p "ifndef")
(define-cpp-line-predicate elif-line-p "elif")
(define-cpp-line-predicate else-line-p "else")
(define-cpp-line-predicate endif-line-p "endif")
(defgeneric skip-if (context))
(defmethod skip-if ((context context))
;; PRE: current line is #if #ifdef #ifndef #elif or #else
;; POST: current line is nil or #endif
;; skips until the matching #endif
(let ((if-line (context-current-line context)))
(setf (context-current-line context) nil)
(incf (context-if-level context))
(unwind-protect
(loop
:while (context-input-lines context)
:do (let ((line (pop (context-input-lines context))))
(cond ((or (if-line-p line)
(ifdef-line-p line)
(ifndef-line-p line))
(skip-if context))
((endif-line-p line)
(setf (context-current-line context) line)
(return t))))
:finally (cpp-error if-line "End of file reached before a balanced #endif for #~A"
(token-text (second if-line)))
(return nil))
(decf (context-if-level context)))))
(defgeneric skip-branch (context))
(defmethod skip-branch ((context context))
;; skips a single branch
;; PRE: current line is #if #ifdef #ifndef or #elif
;; POST: current line is nil, #elif #else or #endif
(let ((if-line (context-current-line context)))
(setf (context-current-line context) nil)
(loop
:while (context-input-lines context)
:do (let ((line (pop (context-input-lines context))))
(cond ((or (if-line-p line)
(ifdef-line-p line)
(ifndef-line-p line))
(skip-if context))
((or (elif-line-p line)
(else-line-p line)
(endif-line-p line))
(setf (context-current-line context) line)
(return t))))
:finally (cpp-error if-line "End of file reached before a balanced #endif for #~A"
(token-text (second if-line)))
(return nil))))
(defgeneric process-branch-and-skip (context &optional no-else))
(defmethod process-branch-and-skip ((context context) &optional no-else)
;; current line is #if #ifdef #ifndef or #elif
;; processes the branch,
;; and then skip the branches until #endif
;; if no-else, the signals an error if a #else or #elif is found.
;; (there should be no-else after an #else).
(flet ((check-no-else ()
(when no-else
(cpp-error (context-current-line context) "Found a #~A line after a #else"
(token-text (second (context-current-line context)))))))
(process-file context) ; shall read the input-lines till the #elif #else or #endif
(loop
:while (elif-line-p (context-current-line context))
:do (check-no-else)
(skip-branch context))
(when (else-line-p (context-current-line context))
(check-no-else)
(skip-branch context))
(unless (or (null (context-current-line context))
(endif-line-p (context-current-line context)))
(check-no-else))
(loop
:until (or (null (context-current-line context))
(endif-line-p (context-current-line context)))
:do (skip-branch context))))
#-(and) (
(let ((*context* (make-instance 'context
:current-line (list (make-punctuation "#") (make-identifier "ifdef") (make-identifier "YES"))
:input-lines (list (list (make-number "1"))
(list (make-punctuation "#") (make-identifier "else"))
(list (make-number "2"))
(list (make-punctuation "#") (make-identifier "endif")))
:if-level 1)))
(process-branch-and-skip *context*)
(write-processed-lines (reverse (context-output-lines *context*))))
(let ((*context* (make-instance 'context
:input-lines (list (list (make-punctuation "#") (make-identifier "define") (make-identifier "YES") (make-number "1"))
(list (make-punctuation "#") (make-identifier "ifdef") (make-identifier "YES"))
(list (make-number "1"))
(list (make-punctuation "#") (make-identifier "else"))
(list (make-number "2"))
(list (make-punctuation "#") (make-identifier "endif"))))))
(process-file *context*)
(write-processed-lines (reverse (context-output-lines *context*))))
(let ((*context* (make-instance 'context
:input-lines (list (list (make-punctuation "#") (make-identifier "define") (make-identifier "YES") (make-number "1"))
(list (make-punctuation "#") (make-identifier "ifdef") (make-identifier "NO"))
(list (make-number "1"))
(list (make-punctuation "#") (make-identifier "else"))
(list (make-number "2"))
(list (make-punctuation "#") (make-identifier "endif"))))))
(process-file *context*)
(write-processed-lines (reverse (context-output-lines *context*))))
(let ((*context* (make-instance 'context
:input-lines (list (list (make-punctuation "#") (make-identifier "define") (make-identifier "YES") (make-number "1"))
(list (make-punctuation "#") (make-identifier "ifdef") (make-identifier "NO"))
(list (make-number "1"))
(list (make-punctuation "#") (make-identifier "elif") (make-identifier "defined") (make-identifier "YES"))
(list (make-number "2"))
(list (make-punctuation "#") (make-identifier "else"))
(list (make-number "3"))
(list (make-punctuation "#") (make-identifier "endif"))))))
(process-file *context*)
(write-processed-lines (reverse (context-output-lines *context*))))
)
(defgeneric skip-branch-and-process (context))
(defmethod skip-branch-and-process ((context context))
;; line is #if #ifdef #ifndef #elif
;; skip the branches,
;; and then process the next #elif or #else branch.
;; and then skip the end.
;; Note: #ifdef … #elif … #else … #endif is valid.
(skip-branch context)
(loop
:while (and (elif-line-p (context-current-line context))
(not (cpp-evaluate-expression context (cddr (context-current-line context)))))
:do (skip-branch context))
(if (elif-line-p (context-current-line context))
(process-branch-and-skip context)
(progn
(loop
:until (or (else-line-p (context-current-line context))
(endif-line-p (context-current-line context)))
:do (skip-branch context))
(when (else-line-p (context-current-line context))
(process-branch-and-skip context :no-else)))))
(defgeneric ifdef-common (context flip directive))
(defmethod ifdef-common ((context context) flip directive)
(incf (context-if-level context))
(unwind-protect
(let ((name (parse-single-macro-name (cddr (context-current-line context)) directive)))
(cond
((null name)
(skip-if context))
((funcall flip (environment-macro-definedp (context-environment context) (token-text name)))
(process-branch-and-skip context))
(t
(skip-branch-and-process context))))
(decf (context-if-level context))))
(defgeneric ifdef (context))
(defmethod ifdef ((context context))
(ifdef-common context (function identity) "#ifdef"))
(defgeneric ifndef (context))
(defmethod ifndef ((context context))
(ifdef-common context (function not) "#ifndef"))
(defun cpp-evaluate-expression (context line)
(not (zerop (eval (parse-expression context
(first (macro-expand-macros context line
'() '() :allow-defined '())))))))
(defgeneric cpp-if (context))
(defmethod cpp-if ((context context))
(incf (context-if-level context))
(unwind-protect
(if (cpp-evaluate-expression context (cddr (context-current-line context)))
(process-branch-and-skip context)
(skip-branch-and-process context))
(decf (context-if-level context))))
;;; --------------------
;;; #line
;;; --------------------
(defgeneric cpp-line (context))
(defmethod cpp-line ((context context))
(with-cpp-line (context-current-line context)
(labels ((generate (n file)
(let ((f (string-value file)))
(when (option context :generate-sharp-line)
(push (list (make-punctuation "#" 1 lino f)
(make-number (prin1-to-string n) 3 lino f)
file)
(context-output-lines context)))
(loop
:for line :in (context-input-lines context)
:do (loop :for token :in line
:do (setf (token-line token) n
(token-file token) f))
(incf n))))
(process-line (line)
(cond
((null line)
(cpp-error context "Missing arguments after #line"))
((and line (null (cdr line))
(number-token-p (first line)))
;; #line N
(generate (integer-value (first line)) (make-string-literal (format nil "~S" file) 10 lino file)))
((and line (null (cddr line))
(number-token-p (first line))
(string-literal-p (second line)))
;; #line N "file"
(generate (integer-value (first line)) (second line)))
(t
(process-line (first (macro-expand-macros context line '() '() nil '())))))))
(process-line (context-current-line context))))
context)
;;; --------------------
;;; #pragma
;;; --------------------
(defgeneric pragma (context))
(defmethod pragma ((context context))
;; TODO: unrecognized pragmas could be passed along on the output for the compiler.
(with-cpp-line (context-current-line context)
(when (context-current-line context)
(let ((key (pop (context-current-line context))))
(when (identifierp key)
(let ((interpreter (gethash (token-text key) (context-pragma-interpreters context))))
(when interpreter
(funcall interpreter context (context-current-line context)))))))))
;;; --------------------
;;; #error
;;; --------------------
(defgeneric cpp-error-line (context))
(defmethod cpp-error-line ((context context))
(cpp-message 'cpp-error (context-current-line context)))
;;; --------------------
;;; #warning
;;; --------------------
(defgeneric cpp-warning-line (context))
(defmethod cpp-warning-line ((context context))
(cpp-message 'cpp-warning (context-current-line context)))
;;; --------------------
(defun cpp-message (operation line)
(let ((directive (second line)))
(with-cpp-line line
(if line
(funcall operation directive "~{~A~^ ~}" (mapcar (function token-text) line))
(cpp-error directive "Missing an expression after #~(~A~)" directive)))))
;;; --------------------
;;; pre-processing files
;;; --------------------
(defgeneric cpp-macro-expand (context))
(defmethod cpp-macro-expand ((context context))
(multiple-value-bind (output input) (macro-expand-macros context
(context-current-line context)
(context-input-lines context)
(context-output-lines context)
nil
(context-macros-being-expanded context))
(setf (context-output-lines context) output
(context-input-lines context) input)
context))
(defgeneric process-directive (context line))
(defmethod process-directive ((context context) line)
(cond
((identifierp (second line))
(scase (token-text (second line))
(("define") (define context))
(("undef") (undef context))
(("include") (include context))
(("include_next") (include-next context))
(("import") (import context))
(("ifdef") (ifdef context))
(("ifndef") (ifndef context))
(("if") (cpp-if context))
(("elif" "else" "endif")
(if (plusp (context-if-level context))
(return-from process-directive nil)
(cpp-error (second line) "#~A without #if" (token-text (second line)))))
(("line") (cpp-line context))
(("pragma") (pragma context))
(("error") (cpp-error-line context))
(("warning") (cpp-warning-line context))
(("ident" "sccs"))
(otherwise (cpp-error line "invalid directive ~A" (token-text (second line))))))
((number-token-p (second line)) ;; skip # 1 "file"
(push line (context-output-lines context)))
((rest line)
(cpp-error line "invalid directive #~A" (token-text (second line))))
(t ;; skip # alone.
))
t)
(defgeneric process-file (context))
(defmethod process-file ((context context))
"Processes all the INPUT-LINES, pushing onto the OUTPUT-LINES."
(loop
:while (context-input-lines context)
:do (let ((line (pop (context-input-lines context))))
(setf (context-current-line context) line)
;;DEBUG;; (print line)
(if (sharpp (first line))
(unless (process-directive context line)
(return))
(cpp-macro-expand context)))
:finally (setf (context-current-line context) nil))
context)
(defgeneric read-and-process-stream (context stream &optional path directory))
(defmethod read-and-process-stream ((context context) stream &optional (path (pathname stream)) directory)
(context-push-file context path directory
(read-cpp-tokens
stream
:file-name (namestring path)
:substitute-trigraphs (option *context* :substitute-trigraphs)
:warn-on-trigraph (option *context* :warn-on-trigraph)
:warn-spaces-in-continued-lines (option *context* :warn-spaces-in-continued-lines)
:single-line-comments (option *context* :single-line-comments)
:accept-unicode-escapes (option *context* :accept-unicode-escapes)
:dollar-is-punctuation (option *context* :dollar-is-punctuation)))
(unwind-protect (process-file context)
(context-pop-file context)))
(defgeneric read-and-process-file (context path &optional directory))
(defmethod read-and-process-file ((context context) path &optional directory)
(with-open-file (input path :external-format (option *context* :external-format))
(read-and-process-stream context input path directory)))
(defun process-toplevel-file (path &key (options *default-options*) (environment (copy-hash-table *default-environment*)))
(let ((*context* (make-instance 'context :base-file path :file path :options options :environment environment)))
(read-and-process-file *context* path)
(values (reverse (context-output-lines *context*)) *context*)))
(defun write-processed-lines (lines &key (stream *standard-output*)
write-sharp-line)
(when lines
(let ((*print-circle* nil)
(*standard-output* stream))
(loop
:with file := nil
:with lino := nil
:for line :in lines
:when line
:do (when write-sharp-line
(if (and (equal file (token-file (first line)))
lino
(= (1+ lino) (token-line (first line))))
(incf lino)
(format t "#line ~D ~S~%"
(setf lino (token-line (first line)))
(setf file (token-file (first line))))))
(format t "~{~A~^ ~}~%" (mapcar (function token-text) line))))))
(defmacro with-cpp-error-logging (&body body)
`(handler-bind ((cpp-error (lambda (condition)
(princ condition *error-output*) (terpri *error-output*)
(let ((restart (find-restart 'continue condition)))
(when restart (invoke-restart restart)))))
(cpp-warning (lambda (condition)
(princ condition *error-output*) (terpri *error-output*)
(let ((restart (find-restart 'muffle-warning condition)))
(when restart (invoke-restart restart))))))
,@body))
(defun cpp-e (path &rest options &key (write-processed-lines t) defines includes write-sharp-line &allow-other-keys)
"
DEFINE: a plist of object-like macro definitions: (macro-name macro-value)
macro-name is a string designator.
macro-values can be any string that is parsed into tokens.
INCLUDES: This is a shortcut for :include-quote-directories.
If both are given, :include-quote-directories takes precedence.
WRITE-SHARP-LINE:
produces #line N \"file\" lines, in the output listing.
Other keys shall be context option keys.
"
(let ((environment (copy-hash-table *default-environment*)))
(loop :for (name definition) :on defines :by (function cddr)
:do (let ((name (string name))
(new-definition (parse-macro-definition
name
(with-input-from-string (input definition)
(first (read-cpp-tokens input :file-name "-"))))))
(when (prefixp "__" name)
(cpp-warning nil "Definining a system macro named ~S" name))
(setf (environment-macro-definition environment name) new-definition)))
(with-cpp-error-logging
(multiple-value-bind (lines context)
(process-toplevel-file path
:options (append (plist-alist options)
(acons :include-quote-directories includes
*default-options*))
:environment environment)
(when write-processed-lines
(terpri)
(write-processed-lines lines :write-sharp-line write-sharp-line))
;; (print-hashtable (context-environment context))
context))))
;;; --------------------
#-(and) (progn
(cpp-e "tests/test.c" :includes '("tests/") :write-sharp-line t
:define '("FOO" "1" "BAR" "FOO"))
(cpp-e "tests/test.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/variadic.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/built-ins.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/comment.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/concat.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/interface.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/shadow.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/stringify.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/substitute.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/trigraphs.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/errors.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/empty-macro.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/if.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/ifdef.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/recursive.c" :includes '("tests/") :write-sharp-line t)
(cpp-e "tests/if-embedded.c" :includes '("tests/") :write-sharp-line t)
(let ((file "tests/define.h"))
(with-open-file (in file)
(let ((environment (make-environment)))
(process-file (read-cpp-tokens in
:file-name file
:substitute-trigraphs t
:warn-on-trigraph nil)
environment)
(print-hashtable environment))))
(let ((file "tests/trigraphs.c"))
(with-open-file (in file)
(read-cpp-tokens in
:file-name file
:substitute-trigraphs t
:warn-on-trigraph nil)))
(let ((file "tests/comment.c"))
(with-open-file (in file)
(read-cpp-tokens in
:file-name file
:substitute-trigraphs t
:warn-on-trigraph nil)))
(let ((file "tests/test.c"))
(with-open-file (in file)
(read-cpp-tokens in
:file-name file
:substitute-trigraphs t
:warn-on-trigraph nil)))
(let ((file #P"~/src/macosx/emacs-24.5/src/lisp.c"))
(with-open-file (in file)
(read-cpp-tokens in
:file-name file
:substitute-trigraphs t
:warn-on-trigraph nil))))
;;; ---
;;;; THE END ;;;;
| 61,258 | Common Lisp | .lisp | 1,209 | 35.172043 | 168 | 0.487694 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 461273ae7e76835d587e81027f5370c036364c58afe0ffffb95c3c798d130b49 | 5,241 | [
-1
] |
5,242 | com.informatimago.test.asd | informatimago_lisp/com.informatimago.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.test system.
;;;; Tests the com.informatimago system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.test"
;; system attributes:
:description "Tests the com.informatimago system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago"
"com.informatimago.common-lisp.test"
"com.informatimago.clext.test"
"com.informatimago.clmisc.test"
"com.informatimago.rdp.test"
"com.informatimago.tools.test"
"com.informatimago.xcode.test"
"com.informatimago.lispdoc.test"
"com.informatimago.small-cl-pgms.test"
"com.informatimago.future.test"
"com.informatimago.editor.test" ; future
"com.informatimago.objcl.test" ; empty shell on non-ccl darwin
"com.informatimago.susv3.test" ; empty shell on non-clisp.
"com.informatimago.clisp.test" ; empty shell on non-clisp linux
)
:components ()
#+asdf3 :in-order-to
#+asdf3 ((asdf:test-op
(asdf:test-op "com.informatimago.common-lisp.test")
(asdf:test-op "com.informatimago.clext.test")
(asdf:test-op "com.informatimago.clmisc.test")
(asdf:test-op "com.informatimago.rdp.test")
(asdf:test-op "com.informatimago.tools.test")
(asdf:test-op "com.informatimago.xcode.test")
(asdf:test-op "com.informatimago.lispdoc.test")
(asdf:test-op "com.informatimago.small-cl-pgms.test")
(asdf:test-op "com.informatimago.future.test")
(asdf:test-op "com.informatimago.editor.test")
(asdf:test-op "com.informatimago.objcl.test")
(asdf:test-op "com.informatimago.susv3.test")
(asdf:test-op "com.informatimago.clisp.test")
(asdf:test-op "com.informatimago.languages.cpp.test"))))
;;;; THE END ;;;;
| 4,041 | Common Lisp | .asd | 90 | 37.733333 | 83 | 0.581413 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6a668ace571d8e9f663793c62ce6a4e596e93a2d89997c7d8bef98edba18a505 | 5,242 | [
-1
] |
5,243 | com.informatimago.asd | informatimago_lisp/com.informatimago.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load com.informatimago libraries.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(in-package "COMMON-LISP-USER")
(asdf:defsystem "com.informatimago"
;; system attributes:
:description "Informatimago Systems Agregate"
:long-description "This system gathers most of the Informatimago systems."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.6.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp"
"com.informatimago.clext"
"com.informatimago.clmisc"
"com.informatimago.rdp"
"com.informatimago.tools"
"com.informatimago.xcode"
"com.informatimago.lispdoc"
"com.informatimago.small-cl-pgms"
"com.informatimago.languages"
"com.informatimago.future"
"com.informatimago.editor" ; future
"com.informatimago.objcl" ; empty shell on non-ccl darwin
"com.informatimago.susv3" ; empty shell on non-clisp.
"com.informatimago.clisp" ; empty shell on non-clisp linux
)
:components ()
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.test"))))
(defun test-all-com.informatimago ()
(asdf:oos 'asdf:load-op :com.informatimago.test)
(eval (read-from-string "
(let ((com.informatimago.common-lisp.cesarum.simple-test::*current-test-name* 'test-all-com.informatimago)
(com.informatimago.common-lisp.cesarum.simple-test::*current-test-parameters* '()))
(com.informatimago.common-lisp.cesarum.simple-test:testing
(asdf:oos 'asdf:test-op :com.informatimago.test)))")))
;;;; THE END ;;;;
| 3,628 | Common Lisp | .asd | 76 | 41.710526 | 121 | 0.592728 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 74e15669ed73eb6bb21fcad5d85a65dd5f1e498a3a39f72c446a6b82beef993f | 5,243 | [
-1
] |
5,244 | com.informatimago.susv3.asd | informatimago_lisp/susv3/com.informatimago.susv3.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.susv3.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.susv3 library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.susv3"
;; system attributes:
:description "Informatimago Common Lisp POSIX SUSv3 API"
:long-description "
Currently implemented: DIRENT, IPC and PROCESS APIs.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.4.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2014")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.susv3/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.heap"
"com.informatimago.clisp")
:components
#+(and clisp linux) ((:file "tools")
(:file "dirent" :depends-on ("tools"))
(:file "ipc" :depends-on ("tools"))
(:file "process" :depends-on ("ipc")))
#-(and clisp linux) ()
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.susv3.test"))))
(eval-when (:compile-toplevel :load-toplevel :execute)
#+(and clisp (not linux)) (warn "System ~A is incomplete without the LINUX package." :com.informatimago.sysv3)
#-clisp (warn "System ~A is incomplete on ~A" :com.informatimago.sysv3 (lisp-implementation-type)))
;;;; THE END ;;;;
| 3,115 | Common Lisp | .asd | 66 | 42.727273 | 112 | 0.588564 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 942e1400efb4608c2ccf9dc0930242cdd63b4463f2db194c30ff582561ddfa6c | 5,244 | [
-1
] |
5,245 | com.informatimago.susv3.test.asd | informatimago_lisp/susv3/com.informatimago.susv3.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.susv3.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.susv3.test system.
;;;; Tests the com.informatimago.susv3 system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.susv3.test"
;; system attributes:
:description "Tests the com.informatimago.susv3 system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.susv3.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.susv3")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,878 | Common Lisp | .asd | 67 | 36.776119 | 83 | 0.539338 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | dd2d8f1cd36c7ae494b581410b60a7e0434d2653a6f01d6d85f032835deea257 | 5,245 | [
-1
] |
5,246 | com.informatimago.future.test.asd | informatimago_lisp/future/com.informatimago.future.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.future.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.future.test system.
;;;; Tests the com.informatimago.future system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.future.test"
;; system attributes:
:description "Tests the com.informatimago.future system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.future.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.future")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,813 | Common Lisp | .asd | 67 | 35.80597 | 83 | 0.533892 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 3e0cb0cb1a8876052d4ae606f21c98f0820114dc7d3a1e6bdc5cd91cc5b5ffb9 | 5,246 | [
-1
] |
5,247 | com.informatimago.future.empty.test.asd | informatimago_lisp/future/com.informatimago.future.empty.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.future.empty.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.future.empty.test system.
;;;; Tests the com.informatimago.future.empty system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.future.empty.test"
;; system attributes:
:description "Tests the com.informatimago.future.empty system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.future.empty.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.future.empty")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,855 | Common Lisp | .asd | 67 | 36.432836 | 83 | 0.538406 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6f6e81fec8167132baf016957ef4b77b12b82b7b7a1f81e8a06ee4fb4c41b873 | 5,247 | [
-1
] |
5,248 | com.informatimago.future.asd | informatimago_lisp/future/com.informatimago.future.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.future.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; This system loads what can be loaded of future Informatimago projects and sketches.
;;;; !!! This code is clearly not ready for consumption !!!
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.future"
:description "Future Informatimago Projects - Not ready for consumption."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "AGPL3"
:depends-on ()
:components ()
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.future.test"))))
;;;; THE END ;;;;
| 1,810 | Common Lisp | .asd | 43 | 40.72093 | 95 | 0.611898 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | cf3a696cde02f34aac268aafae6ab00a7507bcf2cabb5c87e8da95769a886874 | 5,248 | [
-1
] |
5,249 | com.informatimago.future.empty.asd | informatimago_lisp/future/com.informatimago.future.empty.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: empty.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Test an empty ASDF system.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-13 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2014 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.future.empty"
:description "Empty system."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "AGPL3"
:depends-on ()
:components ()
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.future.empty.test"))))
;;;; THE END ;;;;
| 1,639 | Common Lisp | .asd | 42 | 37.619048 | 101 | 0.594103 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 439a0c052cd958d60bbfd1c675ffc3910ecebfbea060aac325fce3fffc902d7d | 5,249 | [
-1
] |
5,252 | com.informatimago.pgl.examples.asd | informatimago_lisp/pgl/com.informatimago.pgl.examples.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.pgl.examples.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load all the examples for com.informatimago.pgl library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2017-03-10 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2017 - 2017
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.pgl.examples"
;; system attributes:
:description "Loads the examples for Portable Graphics Library (Stanford Portable Library)."
:long-description "
This system loads all the pgl examples.
They can be run with:
(com.informatimago.pgl.examples:run-all)
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2017")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.pgl")
:components (
(:file "examples/angles" :depends-on ())
(:file "examples/ball" :depends-on ())
(:file "examples/checkerboard" :depends-on ())
(:file "examples/felt-board" :depends-on ())
(:file "examples/image" :depends-on ())
(:file "examples/yarn-pattern" :depends-on ())
(:file "examples/yin-yang" :depends-on ())
(:file "examples/all" :depends-on ("examples/angles"
"examples/ball"
"examples/checkerboard"
"examples/felt-board"
"examples/image"
"examples/yarn-pattern"
"examples/yin-yang")))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.pgl.examples.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,512 | Common Lisp | .asd | 72 | 40.125 | 100 | 0.540099 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 6611434139acb9f5d5f08e38b1ba4eb82ca9ad9dcebbf4721b48724bbca6d76f | 5,252 | [
-1
] |
5,253 | com.informatimago.pgl.asd | informatimago_lisp/pgl/com.informatimago.pgl.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.pgl.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.pgl library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.pgl"
;; system attributes:
:description "Portable Graphics Library (Stanford Portable Library)"
:long-description "
This package implements a Portable Graphics Library using the
JavaBackEnd from the Stanford Portable Library.
http://cs.stanford.edu/~eroberts/papers/ITiCSE-2013/PortableGraphicsLibrary.pdf
https://github.com/cs50/spl
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Automn 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("trivial-gray-streams"
"parse-number"
"com.informatimago.common-lisp.cesarum")
:components ((:file "pgl" :depends-on ()))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.pgl.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
#-(or ccl clisp) (warn "Not yet completed on ~A" (lisp-implementation-type))
;;;; THE END ;;;;
| 2,840 | Common Lisp | .asd | 62 | 42.33871 | 91 | 0.604114 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 4898ddb88abd09082320ada6f1bce885a6722437ee6c52bf8dd331c2812d6155 | 5,253 | [
-1
] |
5,254 | com.informatimago.clmisc.asd | informatimago_lisp/clmisc/com.informatimago.clmisc.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clmisc.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clmisc library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clmisc"
;; system attributes:
:description "Informatimago Common Lisp Miscellaneous"
:long-description "
Various Common Lisp packages.
For now, only provides com.informatimago.clmisc.resource-utilization,
a package to gather resource utilization statistics and report then in
a format similar to what is used by LISTSERV.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.4.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clmisc/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("split-sequence"
"com.informatimago.clext.shell")
:components ((:file "resource-utilization"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clmisc.test"))))
;;;; THE END ;;;;
| 2,725 | Common Lisp | .asd | 60 | 42.116667 | 98 | 0.605719 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | abd5b4f150c48149ac755806c5a919ead04f1782006e7fa8eecd0b0a503649f2 | 5,254 | [
-1
] |
5,255 | com.informatimago.clmisc.test.asd | informatimago_lisp/clmisc/com.informatimago.clmisc.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.clmisc.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.clmisc.test system.
;;;; Tests the com.informatimago.clmisc system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.clmisc.test"
;; system attributes:
:description "Tests the com.informatimago.clmisc system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.clmisc.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clmisc")
:components ((:file "resource-utilization-test" :depends-on ()))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.CLMISC.RESOURCE-UTILIZATION.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.CLMISC.RESOURCE-UTILIZATION.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 2,969 | Common Lisp | .asd | 66 | 38.69697 | 114 | 0.559118 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 90df98a11fe7f987526431636d47014c429bfcf1341b4be8ec40e7859f9286eb | 5,255 | [
-1
] |
5,256 | com.informatimago.xcode.asd | informatimago_lisp/xcode/com.informatimago.xcode.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.xcode.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the com.informatimago.xcode system.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2012-12-11 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2012 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.xcode"
;; system attributes:
:description "Xcode related tools."
:long-description "
Various Xcode related tools. For now:
- a .pbxproj project files parser.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2012")
((#:albert #:output-dir) . "../documentation/com.informatimago.xcode/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.rdp"
"com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.parser")
:components ((:file "pbxproj"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.xcode.test"))))
;;;; THE END ;;;;
| 2,585 | Common Lisp | .asd | 59 | 40.254237 | 95 | 0.584689 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 40d460ce7c927d21c7257155c246899eab9d1dccce19f71a60589dd313c5f412 | 5,256 | [
-1
] |
5,257 | com.informatimago.xcode.test.asd | informatimago_lisp/xcode/com.informatimago.xcode.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.xcode.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.xcode.test system.
;;;; Tests the com.informatimago.xcode system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.xcode.test"
;; system attributes:
:description "Tests the com.informatimago.xcode system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.xcode.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.xcode"
"com.informatimago.rdp"
"com.informatimago.common-lisp.cesarum")
:components ((:file "pbxproj-test" :depends-on nil))
#+asdf3 :perform #+asdf3 (asdf:test-op (operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.XCODE.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.XCODE.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 2,973 | Common Lisp | .asd | 66 | 38.106061 | 105 | 0.545611 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 283394e2a9fe857cdedbe6680baeb7851828d1859edbc1cd7f36f0eb25a840b2 | 5,257 | [
-1
] |
5,259 | com.informatimago.tools.script.asd | informatimago_lisp/tools/com.informatimago.tools.script.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.script.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; System to load the script package.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-02-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.script"
:description "Utilities for scripts."
:author "Pascal J. Bourguignon"
:version "1.2.1"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum")
:components ((:file "script" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.tools.script.test"))))
;;;; THE END ;;;;
| 1,799 | Common Lisp | .asd | 43 | 40.418605 | 101 | 0.610034 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | cc9ced9e844b1ee004a0de16fd6e646f2d7f678055b2ed5816df2002daadfe19 | 5,259 | [
-1
] |
5,260 | com.informatimago.tools.check-asdf.asd | informatimago_lisp/tools/com.informatimago.tools.check-asdf.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: check-asdf.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Check asd file for circular dependencies.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-03-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.check-asdf"
:description "Checks ASD Files and reports circular dependencies."
:author "Pascal J. Bourguignon"
:version "1.3.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clext"
"com.informatimago.tools.source"
#-abcl "com.informatimago.tools.script")
:components (#-abcl (:file "check-asdf" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,873 | Common Lisp | .asd | 45 | 39.266667 | 83 | 0.604053 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 4d3a1a0aa4896ba0791d73d39f0bb970f78d03ad56a7e4cca08ae9eb32eca07d | 5,260 | [
-1
] |
5,261 | com.informatimago.tools.undefmethod.test.asd | informatimago_lisp/tools/com.informatimago.tools.undefmethod.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.undefmethod.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.undefmethod.test system.
;;;; Tests the com.informatimago.tools.undefmethod system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.undefmethod.test"
;; system attributes:
:description "Tests the com.informatimago.tools.undefmethod system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.undefmethod.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.tools.undefmethod"
"com.informatimago.common-lisp.cesarum")
:components ((:file "undefmethod-test" :depends-on nil))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.TOOLS.UNDEFMETHOD.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.TOOLS.UNDEFMETHOD.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 3,018 | Common Lisp | .asd | 66 | 39.439394 | 104 | 0.565763 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 632e377a9f153f0cfad6a4f00fb3d9c52c546c1972c69f0dbde56155595f2cc3 | 5,261 | [
-1
] |
5,262 | com.informatimago.tools.manifest.test.asd | informatimago_lisp/tools/com.informatimago.tools.manifest.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.manifest.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.manifest.test system.
;;;; Tests the com.informatimago.tools.manifest system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.manifest.test"
;; system attributes:
:description "Tests the com.informatimago.tools.manifest system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.manifest.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.manifest")
:components ((:file "manifest-test" :depends-on nil))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.TOOLS.MANIFEST.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.TOOLS.MANIFEST.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 2,908 | Common Lisp | .asd | 66 | 37.893939 | 101 | 0.557042 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 41cb72289e1be1d98ca1f72c96f7df737fafb8a182c0a2fada8a5e02ba1f5ca9 | 5,262 | [
-1
] |
5,263 | com.informatimago.tools.bad-system-with-cycles.asd | informatimago_lisp/tools/com.informatimago.tools.bad-system-with-cycles.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: bad-system-with-cycles.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Check asd file for circular dependencies.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-03-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
#+testing
(asdf:defsystem "com.informatimago.tools.bad-system-with-cycles"
:description "A bad system with cycles, to test check-asdf"
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clext")
:components ((:file "a")
(:file "b" :depends-on ("a" "c"))
(:file "c" :depends-on ("b" "a"))
(:file "d" :depends-on ("e"))
(:file "e" :depends-on ("f"))
(:file "f" :depends-on ("d")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,024 | Common Lisp | .asd | 49 | 37.612245 | 83 | 0.56665 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 73bcdc8ac4d804f624dd1a242688ac2171fa4912b98d566ddb50d28d7215002d | 5,263 | [
-1
] |
5,266 | com.informatimago.tools.try-systems.asd | informatimago_lisp/tools/com.informatimago.tools.try-systems.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.try-systems.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Symbol tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-09-15 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2014 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.tools.try-systems"
:description "Tries to compile systems like in quicklisp validation compilations."
:long-description "
Compiles all the systems found recursively in a directory,
in an environment similar to what quicklisp uses to check systems,
by forking an sbcl instance per system.
"
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "AGPL3"
:depends-on ()
:components ()
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
#-mocl
(asdf:defsystem "com.informatimago.tools.try-systems"
:description "Tries to compile systems like in quicklisp validation compilations."
:long-description "
Compiles all the systems found recursively in a directory,
in an environment similar to what quicklisp uses to check systems,
by forking an sbcl instance per system.
"
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.source"
"com.informatimago.tools.script"
"split-sequence"
"uiop")
:components (;; (:file "dummy-uiop")
(:file "try-systems" :depends-on (;; "dummy-uiop"
)))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,686 | Common Lisp | .asd | 68 | 36.088235 | 84 | 0.631801 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8df0ed5a5c351651a9795c2fbc75670b57627f4b5bbdfb16469da3232b0abafe | 5,266 | [
-1
] |
5,267 | com.informatimago.tools.summary.test.asd | informatimago_lisp/tools/com.informatimago.tools.summary.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.summary.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.summary.test system.
;;;; Tests the com.informatimago.tools.summary system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.summary.test"
;; system attributes:
:description "Tests the com.informatimago.tools.summary system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.summary.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.summary")
:components ((:file "summary-test" :depends-on nil))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.TOOLS.SUMMARY.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.TOOLS.SUMMARY.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 2,970 | Common Lisp | .asd | 66 | 38.833333 | 100 | 0.561337 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 69dfb2924cabddc1f9b540c651c58d7a44ca6fb9bbacf760079e34645e7b66de | 5,267 | [
-1
] |
5,268 | com.informatimago.tools.pathname.asd | informatimago_lisp/tools/com.informatimago.tools.pathname.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: pathname.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Pathname tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-12-06 <PJB> Extracted from ~/rc/common.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.pathname"
:description "Pathname tools."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "pathname"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,622 | Common Lisp | .asd | 42 | 37.238095 | 83 | 0.595057 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ed32150740f58c932ea5ef4dce5543764204f47a0c26fcdcdee973f9f4009f37 | 5,268 | [
-1
] |
5,269 | com.informatimago.tools.source.asd | informatimago_lisp/tools/com.informatimago.tools.source.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.source.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Symbol tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-09-15 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2014 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(if (find-package "UIOP")
(push :uiop *features*)
(setf *features* (remove :uiop *features*))))
#+mocl
(asdf:defsystem "com.informatimago.tools.source"
:description "Dummy Reads sources and headers to perform some analysis."
:long-description "
This system would use closer-mop which is not available on MOCL.
"
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ()
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
#-mocl
(asdf:defsystem "com.informatimago.tools.source"
:description "Reads sources and headers to perform some analysis."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.picture"
"com.informatimago.common-lisp.graphviz" ; used by dependency-cycles
"com.informatimago.clext"
"closer-mop"
"split-sequence")
:components ((:file "source")
(:file "dependency-cycles")
(:file "dummy-asdf")
(:file "dummy-uiop")
(:file "asdf-file" :depends-on ("dummy-asdf"
"dummy-uiop"
"dependency-cycles"
"source"))
#-(and) (:file "analyse-patchwork"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,897 | Common Lisp | .asd | 72 | 34.444444 | 83 | 0.580554 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 7609679df57fc9f43465b17b83cf237591e5bc5e26ef74ad1b84f82738ef1745 | 5,269 | [
-1
] |
5,270 | com.informatimago.tools.manifest.asd | informatimago_lisp/tools/com.informatimago.tools.manifest.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.manifest.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Produce a manifest of asdf systems.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-03-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.manifest"
:description "Produces a manifest of asdf systems."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "AGPL3"
:depends-on ("split-sequence"
"com.informatimago.common-lisp.cesarum"
"com.informatimago.clext.shell")
:components ((:file "manifest"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,784 | Common Lisp | .asd | 44 | 38.477273 | 83 | 0.603339 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | a04fdd9f3476d2b5b273bf47fa2e2d7a7124b30f5e78dec5f29001b03cbf6813 | 5,270 | [
-1
] |
5,271 | com.informatimago.tools.chatgpt.asd | informatimago_lisp/tools/com.informatimago.tools.chatgpt.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.chatgpt.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.tools.chatgpt tool.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2023-09-16 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2023 - 2023
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.chatgpt"
;; system attributes:
:description "Informatimago Common Lisp Chatgpt Tool"
:long-description "
Provides a function to make chatgpt queries.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2023")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.tools.chatgpt/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"split-sequence"
"cl-json")
:components ((:file "chatgpt" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,501 | Common Lisp | .asd | 57 | 40.263158 | 105 | 0.582206 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | c68cb4392d229f685878a51f364844f65efa0c8caf3498609034097074f26fea | 5,271 | [
-1
] |
5,272 | com.informatimago.tools.symbol.asd | informatimago_lisp/tools/com.informatimago.tools.symbol.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: symbol.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Symbol tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-12-06 <PJB> Extracted from ~/rc/common.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.symbol"
:description "Symbol tools."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ("cl-ppcre"
"com.informatimago.common-lisp.cesarum")
:components ((:file "symbol"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,677 | Common Lisp | .asd | 43 | 37.27907 | 83 | 0.59375 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 1587de3c5185e0861f62e4fc158b31b2d53e8c7c24ef2803a813d2d84f2953a1 | 5,272 | [
-1
] |
5,273 | com.informatimago.tools.summary.asd | informatimago_lisp/tools/com.informatimago.tools.summary.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.summary.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.tools.summary tool.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-02-23 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.tools.summary"
;; system attributes:
:description "Dummy Informatimago Common Lisp Summary Tool"
:long-description "
Since summary depends on source which is disabled on MoCL, we are therefore disabled on MoCL.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.common-lisp.summary/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ()
:components ()
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
#-mocl
(asdf:defsystem "com.informatimago.tools.summary"
;; system attributes:
:description "Informatimago Common Lisp Summary Tool"
:long-description "
This program generates an HTML summary page for packages.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.common-lisp.summary/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.html-generator"
"com.informatimago.clext"
"com.informatimago.tools.source")
:components ((:file "summary" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,672 | Common Lisp | .asd | 81 | 40.864198 | 111 | 0.591683 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 9856e9a9a3706eb854a733cfc2e9db59dad99a6506efe2a0d12490c51b1c5fe5 | 5,273 | [
-1
] |
5,274 | com.informatimago.tools.thread.asd | informatimago_lisp/tools/com.informatimago.tools.thread.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.thread.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.tools.thread package.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-02-23 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2017
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.thread"
;; system attributes:
:description "Informatimago Common Lisp Thread Tools"
:long-description "
Interactive commands to manipulate threads.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.3.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2017")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.common-lisp.thread/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("bordeaux-threads")
:components ((:file "thread" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,440 | Common Lisp | .asd | 55 | 41.218182 | 110 | 0.587148 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 76d47cbf9beddfdfc2fd75b3794d80aeef37c354a77a43128ee215284c96cbde | 5,274 | [
-1
] |
5,275 | com.informatimago.tools.reader-macro.asd | informatimago_lisp/tools/com.informatimago.tools.reader-macro.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.reader-macroasd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Symbol tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-12-06 <PJB> Extracted from ~/rc/common.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.reader-macro"
:description "Reader-macro tools."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "reader-macro"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,659 | Common Lisp | .asd | 42 | 38.119048 | 83 | 0.600619 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ad21ff2eb5b102402080a0a8b138f3a067ec7aadf0daa96a3fed24ac64d9dedb | 5,275 | [
-1
] |
5,276 | com.informatimago.tools.make-depends.test.asd | informatimago_lisp/tools/com.informatimago.tools.make-depends.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.make-depends.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.make-depends.test system.
;;;; Tests the com.informatimago.tools.make-depends system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.make-depends.test"
;; system attributes:
:description "Tests the com.informatimago.tools.make-depends system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.make-depends.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.make-depends")
:components ((:file "make-depends-test" :depends-on nil))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(dolist (p '("COM.INFORMATIMAGO.TOOLS.MAKE-DEPENDS.TEST"))
(let ((*package* (find-package p)))
(uiop:symbol-call p "TEST/ALL")))))
;;;; THE END ;;;;
| 2,980 | Common Lisp | .asd | 66 | 39.227273 | 86 | 0.563874 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 19d9fa8ccbdf8a485d301a22267425201e2ccd4e003b6c33db642b2c37accf46 | 5,276 | [
-1
] |
5,279 | com.informatimago.tools.script.test.asd | informatimago_lisp/tools/com.informatimago.tools.script.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.script.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.script.test system.
;;;; Tests the com.informatimago.tools.script system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.script.test"
;; system attributes:
:description "Tests the com.informatimago.tools.script system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.script.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum" ; simple-test
"com.informatimago.tools.script")
:components ((:file "script-test" :depends-on nil))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(dolist (p '("COM.INFORMATIMAGO.TOOLS.SCRIPT.TEST"))
(let ((*package* (find-package p)))
(uiop:symbol-call p "TEST/ALL")))))
;;;; THE END ;;;;
| 2,868 | Common Lisp | .asd | 66 | 37.530303 | 83 | 0.553571 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 9b8f09addbb1f340c9d9f965ae285f3f9c7efa9e165a049e5f6ace48ca36c02d | 5,279 | [
-1
] |
5,281 | com.informatimago.tools.test.asd | informatimago_lisp/tools/com.informatimago.tools.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.test system.
;;;; Tests the com.informatimago.tools systems.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.test"
;; system attributes:
:description "Tests the com.informatimago.tools system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.tools.check-asdf.test"
"com.informatimago.tools.make-depends.test"
"com.informatimago.tools.manifest.test"
"com.informatimago.tools.pathname.test"
"com.informatimago.tools.quicklisp.test"
"com.informatimago.tools.source.test"
"com.informatimago.tools.summary.test"
"com.informatimago.tools.symbol.test"
"com.informatimago.tools.script.test"
"com.informatimago.tools.undefmethod.test")
:components ()
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op
(asdf:test-op "com.informatimago.tools.check-asdf.test")
(asdf:test-op "com.informatimago.tools.make-depends.test")
(asdf:test-op "com.informatimago.tools.manifest.test")
(asdf:test-op "com.informatimago.tools.pathname.test")
(asdf:test-op "com.informatimago.tools.quicklisp.test")
(asdf:test-op "com.informatimago.tools.source.test")
(asdf:test-op "com.informatimago.tools.summary.test")
(asdf:test-op "com.informatimago.tools.symbol.test")
(asdf:test-op "com.informatimago.tools.script.test")
(asdf:test-op "com.informatimago.tools.undefmethod.test"))))
;;;; THE END ;;;;
| 3,735 | Common Lisp | .asd | 79 | 39.936709 | 83 | 0.578818 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 5734f32c8ba82cb68d85d1cf1d4c651d7dcb73d9fe18bebf253763f062ab31d0 | 5,281 | [
-1
] |
5,282 | com.informatimago.tools.dependency.asd | informatimago_lisp/tools/com.informatimago.tools.dependency.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: dependency.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Check for circular dependencies.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2013-03-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2018
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.dependency"
:description "Checks for circular dependencies."
:author "Pascal J. Bourguignon"
:version "1.3.1"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clext"
"com.informatimago.tools.source"
"quicklisp"
"asdf"
"split-sequence"
;; "com.informatimago.tools.asdf"
"com.informatimago.tools.quicklisp"
#-abcl "com.informatimago.tools.script")
:components (#-abcl (:file "dependency-cycles" :depends-on ())
(:file "dependencies" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,090 | Common Lisp | .asd | 51 | 36.960784 | 83 | 0.587715 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 62cd1df97d54113170c4a6c5652bea71be62f20d049b2cba524f9fa1cbaff792 | 5,282 | [
-1
] |
5,283 | com.informatimago.tools.symbol.test.asd | informatimago_lisp/tools/com.informatimago.tools.symbol.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.symbol.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.symbol.test system.
;;;; Tests the com.informatimago.tools.symbol system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.symbol.test"
;; system attributes:
:description "Tests the com.informatimago.tools.symbol system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.symbol.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.symbol")
:components ((:file "symbol-test" :depends-on nil))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.TOOLS.SYMBOL.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.TOOLS.SYMBOL.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 2,887 | Common Lisp | .asd | 66 | 37.575758 | 99 | 0.553742 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8bf5f6685c1f5dcf264eb41233930b20133d21cebc6cdb7902f2dd4913eab4e1 | 5,283 | [
-1
] |
5,285 | com.informatimago.tools.pathname.test.asd | informatimago_lisp/tools/com.informatimago.tools.pathname.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.pathname.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.pathname.test system.
;;;; Tests the com.informatimago.tools.pathname system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.pathname.test"
;; system attributes:
:description "Tests the com.informatimago.tools.pathname system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.pathname.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.pathname")
:components ((:file "pathname-test" :depends-on nil))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(dolist (p '("COM.INFORMATIMAGO.TOOLS.PATHNAME.TEST"))
(let ((*package* (find-package p)))
(uiop:symbol-call p "TEST/ALL")))))
;;;; THE END ;;;;
| 2,871 | Common Lisp | .asd | 66 | 37.575758 | 83 | 0.555476 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 82ffbc1ecdf1f7f73fefcb16dc50dc5fae11cee7fd20eaf22c354acbf56f74f6 | 5,285 | [
-1
] |
5,287 | com.informatimago.tools.check-asdf.test.asd | informatimago_lisp/tools/com.informatimago.tools.check-asdf.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.check-asdf.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.check-asdf.test system.
;;;; Tests the com.informatimago.tools.check-asdf system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.check-asdf.test"
;; system attributes:
:description "Tests the com.informatimago.tools.check-asdf system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.check-asdf.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.check-asdf"
"com.informatimago.tools.script")
:components ((:file "check-asdf-test" :depends-on nil)
(:file "dependency-cycles-test" :depends-on nil))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(dolist (p '("COM.INFORMATIMAGO.TOOLS.DEPENDENCY-CYCLES.TEST"
"COM.INFORMATIMAGO.TOOLS.CHECK-ASDF.TEST"))
(let ((*package* (find-package p)))
(uiop:symbol-call p "TEST/ALL")))))
;;;; THE END ;;;;
| 3,100 | Common Lisp | .asd | 69 | 38.072464 | 89 | 0.551667 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | a3c900ce5898c8dfe0a4499d81717bfb7191f23f5aec9bf2bdd54130b4321729 | 5,287 | [
-1
] |
5,288 | com.informatimago.tools.asd | informatimago_lisp/tools/com.informatimago.tools.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.tools libraries.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-03-08 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2014 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools"
;; system attributes:
:description "This system aggregates Informatimago Common Lisp Tools."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2014")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.tools/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on #-mocl ("com.informatimago.tools.check-asdf"
"com.informatimago.tools.make-depends"
"com.informatimago.tools.manifest"
"com.informatimago.tools.pathname"
"com.informatimago.tools.quicklisp"
"com.informatimago.tools.reader-macro"
"com.informatimago.tools.script"
"com.informatimago.tools.source"
"com.informatimago.tools.summary"
"com.informatimago.tools.symbol"
"com.informatimago.tools.thread"
"com.informatimago.tools.try-systems"
"com.informatimago.tools.undefmethod")
#+mocl ("com.informatimago.tools.manifest"
"com.informatimago.tools.pathname"
"com.informatimago.tools.symbol")
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.tools.test"))))
;; (com.informatimago.tools.check-asdf:check-asdf-system-file
;; #P"/some/system.asd" :report output-stream)
;;
;; (com.informatimago.common-lisp.tools.make-depends:generate-asd
;; system-name sources source-type
;; &key description (version "0.0.0")
;; author licence license
;; (predefined-packages '("COMMON-LISP"))
;; (implicit-dependencies '())
;; (depends-on '())
;; (load-paths (list (make-pathname :directory '(:relative))))
;; (vanillap nil))
;;
;; (com.informatimago.common-lisp.tools.make-depends:generate-summary
;; sources &key (summary-path #p"SUMMARY.HTML")
;; (character-set "US-ASCII")
;; (source-type "LISP")
;; (verbose nil) (repository-url nil))
;;
;; (com.informatimago.common-lisp.tools.make-depends:make-depends
;; object-files packages translations load-paths
;; &key (idf nil) (verbose nil))
;;
;; (com.informatimago.tools.manifest:distribution)
;; (com.informatimago.tools.manifest:print-manifest system)
;; (com.informatimago.tools.manifest:write-manifest-file program-name system)
;;
;; (com.informatimago.tools.pathname:make-pathname …)
;; (com.informatimago.tools.pathname:user-homedir-pathname)
;; (com.informatimago.tools.pathname:translate-logical-pathname pathname)
;;
;; (com.informatimago.tools.quicklisp:quick-*)
#-(and)
(defun use-tools ()
(use-package :com.informatimago.tools.check-asdf)
(use-package :com.informatimago.common-lisp.tools.make-depends)
(use-package :com.informatimago.tools.manifest)
(shadow '(make-pathname user-homedir-pathname translate-logical-pathname))
(use-package :com.informatimago.tools.pathname)
(use-package :com.informatimago.tools.symbol)
(use-package :com.informatimago.tools.quicklisp)
(values))
;;;; THE END ;;;;
| 4,960 | Common Lisp | .asd | 109 | 40.623853 | 97 | 0.634036 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 31ebad14eb76ae5fd824feecd2e3818860b67db70d4d19fb3591afda8c1ed0e0 | 5,288 | [
-1
] |
5,289 | com.informatimago.tools.undefmethod.asd | informatimago_lisp/tools/com.informatimago.tools.undefmethod.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.undefmethod.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; System to load Shinmera's undefmethod macro.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-26 <PJB> Created asd file.
;;;;BUGS
;;;;LEGAL
;;;; GPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2014 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.undefmethod"
:description "A macro that undefines the method instead of defining it."
:author "irc://[email protected]"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "undefmethod"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,721 | Common Lisp | .asd | 42 | 39.595238 | 83 | 0.609422 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | f5ed8322ea7c0249a64935a15a086ab5c9115c8e325a562e3fb665e6133ec41a | 5,289 | [
-1
] |
5,290 | com.informatimago.tools.source.test.asd | informatimago_lisp/tools/com.informatimago.tools.source.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.tools.source.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.tools.source.test system.
;;;; Tests the com.informatimago.tools.source system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.tools.source.test"
;; system attributes:
:description "Tests the com.informatimago.tools.source system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.tools.source.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.tools.source")
:components ((:file "source-test" :depends-on ())
(:file "asdf-file-test" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.TOOLS.SOURCE.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.TOOLS.SOURCE.TEST"
"TEST/ALL"))
(let ((*package* (find-package "COM.INFORMATIMAGO.TOOLS.ASDF-FILE.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.TOOLS.ASDF-FILE.TEST"
"TEST/ALL"))))
;;;; THE END ;;;;
| 3,201 | Common Lisp | .asd | 70 | 38.071429 | 102 | 0.540428 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 957eb187369e34b39fc22d0347b850c6e1ad2cc15d2421a7752d468c8162ccd2 | 5,290 | [
-1
] |
5,291 | com.informatimago.tools.make-depends.asd | informatimago_lisp/tools/com.informatimago.tools.make-depends.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.make-depends.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.tools.make-depends library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.tools.make-depends"
;; system attributes:
:description "Informatimago Common Lisp MAKE-DEPENDS for lisp sources Tools"
:long-description "
This program generates dependencies (and ASD files) for lisp sources,
based on \(require) sexps, a load-path, a set of logical pathname
translations and ad-hoc processing.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.5.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.common-lisp.make-depends/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.html-generator"
"com.informatimago.clext"
"com.informatimago.tools.source")
:components ((:file "make-depends" :depends-on ())))
;;;; THE END ;;;;
| 2,835 | Common Lisp | .asd | 60 | 42.833333 | 118 | 0.593649 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | e6121611f2fb771b3f167c137a92cebca3bb39993c070e0ea7693bfaae721971 | 5,291 | [
-1
] |
5,292 | com.informatimago.tools.make.asd | informatimago_lisp/tools/make/com.informatimago.tools.make.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.tools.make.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Make & makefile tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2023-04-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2023 - 2023
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(eval-when (:compile-toplevel :load-toplevel :execute)
(if (find-package "UIOP")
(push :uiop *features*)
(setf *features* (remove :uiop *features*))))
(asdf:defsystem "com.informatimago.tools.make"
:description "Make and makefile tools."
:author "Pascal J. Bourguignon"
:version "1.0.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"split-sequence")
:components ((:file "package")
(:file "parser" :depends-on ("package")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 1,925 | Common Lisp | .asd | 48 | 37.8125 | 83 | 0.599039 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8d265af4015f3bcee512aab101832df56f770b523202eb6c36b5bf8ddb2ac98a | 5,292 | [
-1
] |
5,293 | com.informatimago.tools.make-print-vars.asd | informatimago_lisp/tools/make/com.informatimago.tools.make-print-vars.asd | (asdf:defsystem "make-print-vars"
;; system attributes:
:description "Generate Makefile print-vars rule"
:long-description "
This program reads a makefile and extract all variable name from
variable definitions and generates a rule to print their value.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2023")
((#:albert #:output-dir) . "../documentation/make-print-vars/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on (:com.informatimago.common-lisp.cesarum
:com.informatimago.common-lisp.tools.make)
:components ((:file "make-print-vars" :depends-on ()))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
| 1,148 | Common Lisp | .asd | 23 | 43.130435 | 87 | 0.601249 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | abcc4d57acd2739f1c9bba69ea9920039d8ea2ed6666ae5c2815e643c26492c8 | 5,293 | [
-1
] |
5,296 | com.informatimago.editor.asd | informatimago_lisp/editor/com.informatimago.editor.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.editor.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Editor tools.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Added system dependencies.
;;;; 2013-12-06 <PJB> Extracted from ~/rc/common.lisp
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2013 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.editor"
:description "An emacs-like editor."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.lisp-sexp"
"com.informatimago.clext.run-program"
"split-sequence"
#-mocl "cl-charms")
:components ((:file "package")
(:file "macros" :depends-on ("package"))
(:file "screen" :depends-on ("package"
"macros"))
#+clisp (:file "clisp-screen" :depends-on ("package"
"macros" "screen"))
#+clisp (:file "clisp" :depends-on ("package"
"macros" "screen"
"clisp-screen"))
#-mocl (:file "charms-screen" :depends-on ("package"
"macros" "screen"))
(:file "editor" :depends-on ("package"
"macros" "screen"
#+clisp "clisp"
#-mocl "charms-screen")))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.editor.test"))))
;;;; THE END ;;;;
| 2,917 | Common Lisp | .asd | 61 | 37.016393 | 95 | 0.492992 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 4bc6f3db8b961deb6178ebeedaf7bff60dd0d77e48ced12a00a7d54cc2628cc2 | 5,296 | [
-1
] |
5,297 | com.informatimago.editor.test.asd | informatimago_lisp/editor/com.informatimago.editor.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.editor.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.editor.test system.
;;;; Tests the com.informatimago.editor system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.editor.test"
;; system attributes:
:description "Tests the com.informatimago.editor system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.editor.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.editor")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,813 | Common Lisp | .asd | 67 | 35.80597 | 83 | 0.533892 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 11c709775219b6e5bf24b380a7d399ec3a52ae59467a66437b5315090d0435cc | 5,297 | [
-1
] |
5,298 | com.informatimago.rdp.example.test.asd | informatimago_lisp/rdp/com.informatimago.rdp.example.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.rdp.example.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.rdp.example.test system.
;;;; Tests the com.informatimago.rdp.example system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.rdp.example.test"
;; system attributes:
:description "Tests the com.informatimago.rdp.example system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.rdp.example.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.rdp.example")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(dolist (p '("COM.INFORMATIMAGO.RDP.EXAMPLE"))
(let ((*package* (find-package p)))
(uiop:symbol-call p "TEST/ALL")))))
;;;; THE END ;;;;
| 2,876 | Common Lisp | .asd | 66 | 37.651515 | 83 | 0.555199 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 54d487ad30cd41654307d22102b62b9a93225200f465ecdadca4c125c92550e7 | 5,298 | [
-1
] |
5,299 | com.informatimago.rdp.basic.example.test.asd | informatimago_lisp/rdp/com.informatimago.rdp.basic.example.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.rdp.basic.example.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.rdp.basic.example.test system.
;;;; Tests the com.informatimago.rdp.basic.example system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.rdp.basic.example.test"
;; system attributes:
:description "Tests the com.informatimago.rdp.basic.example system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.rdp.basic.example.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.rdp.basic.example")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,962 | Common Lisp | .asd | 67 | 38.029851 | 85 | 0.547874 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | b9bbea45a54c87a466e26db74daf269dc323fe7b4f6651f6ffe9d683bae9067f | 5,299 | [
-1
] |
5,300 | com.informatimago.rdp.example.asd | informatimago_lisp/rdp/com.informatimago.rdp.example.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.rdp.example.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the com.informatimago.rdp.example system.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2012-02-24 <PJB> Added this header.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2012 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.rdp.example"
;; system attributes:
:description "Recursive Descent Parser Generator -- An example"
:long-description "
A couple of examples for a simple expression programm language, one
grammar without explicit actions (using the default generator of the
RDPG), and another with actions written in the lisp target-language,
both producing parsers in Lips.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2011")
((#:albert #:output-dir) . "../documentation/com.informatimago.rdp.example/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.rdp")
:components ((:file "example-lisp"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.rdp.example.test"))))
;;;; THE END ;;;;
| 2,748 | Common Lisp | .asd | 59 | 42.932203 | 103 | 0.598883 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 3ab21efad6d02b35d71405652e8354f56226bdd8f919db11f63ad0e40086e707 | 5,300 | [
-1
] |
5,301 | com.informatimago.rdp.test.asd | informatimago_lisp/rdp/com.informatimago.rdp.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.rdp.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.rdp.test system.
;;;; Tests the com.informatimago.rdp system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.rdp.test"
;; system attributes:
:description "Tests the com.informatimago.rdp system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.rdp.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.rdp")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,864 | Common Lisp | .asd | 67 | 36.567164 | 83 | 0.53703 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 2578897680ebd155ee32be8419fa9fc12a6f4fd4292fed0fac3bf3c83fffe477 | 5,301 | [
-1
] |
5,302 | com.informatimago.rdp.asd | informatimago_lisp/rdp/com.informatimago.rdp.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.rdp.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines the com.informatimago.rdp system.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-07-02 <PJB> Removed direct dependency on ppcre (still use it thru parser->regexp).
;;;; 2012-02-24 <PJB> Added this header.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2012 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.rdp"
;; system attributes:
:description "Recursive Descent Parser Generator"
:long-description "
A simple Recursive Descent Parser generator.
The client may define methods to generate the code of the parser in
different languages than lisp.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "../documentation/com.informatimago.rdp/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.scanner")
:components ((:file "packages")
(:file "rdp" :depends-on ("packages"))
(:file "rdp-lisp-boilerplate" :depends-on ("packages" "rdp"))
(:file "rdp-macro" :depends-on ("packages" "rdp"))))
;;;; THE END ;;;;
| 2,904 | Common Lisp | .asd | 62 | 42.258065 | 95 | 0.57611 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8e4d94090049343b0dc7e13a2f062fda8e2eb1121c2ca4db4b51fae8555a6305 | 5,302 | [
-1
] |
5,303 | com.informatimago.rdp.basic.example.asd | informatimago_lisp/rdp/com.informatimago.rdp.basic.example.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.rdp.basic.example.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Define the com.informatimago.rdp.basic.example system.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2012-02-24 <PJB> Added this header.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2012 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.rdp.basic.example"
;; system attributes
:description "Recursive Descent Parser Generator -- An example generated in BASIC"
:long-description "
The grammar of our simple expression programming language is
attributed with actions written in BASIC, which, along with the BASIC
target-language method will let the RDPG generate a parser in BASIC.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2011")
((#:albert #:output-dir) . "../documentation/com.informatimago.rdp.basic.example/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.rdp"
"com.informatimago.rdp.basic")
:components
#-bit-rotten ((:file "example-basic"))
#+bit-rotten ()
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.rdp.basic.example.test"))))
(eval-when (:compile-toplevel :load-toplevel :execute)
(warn "~S is bit-rotten, it needs an update."
:com.informatimago.rdp.basic.example))
;;;; THE END ;;;;
| 2,952 | Common Lisp | .asd | 64 | 42.78125 | 107 | 0.61221 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 59c05d75b532ea26827396b2c4c763538e40a81fc2a9bbb1ddd2ea504cf9ab47 | 5,303 | [
-1
] |
5,304 | com.informatimago.rdp.basic.asd | informatimago_lisp/rdp/com.informatimago.rdp.basic.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.rdp.basic.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Define the com.informatimago.rdp.basic system.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2012-02-24 <PJB> Added this header.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2012 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.rdp.basic"
;; system attributes:
:description "Recursive Descent Parser Generator -- BASIC Generator"
:long-description "
Provides methods specialized on the :basic target-language, to emit a generator in BASIC.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2011")
((#:albert #:output-dir) . "../documentation/com.informatimago.rdp.basic/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.rdp")
:components ((:file "rdp-basic-gen"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.rdp.basic.test"))))
;;;; THE END ;;;;
| 2,555 | Common Lisp | .asd | 56 | 42.482143 | 99 | 0.593186 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 4c59443e1d87bcc0bb84193ea2355e08e8ce626cfb1b8383a9cc8ef90f0aa996 | 5,304 | [
-1
] |
5,305 | com.informatimago.rdp.basic.test.asd | informatimago_lisp/rdp/com.informatimago.rdp.basic.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.rdp.basic.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.rdp.basic.test system.
;;;; Tests the com.informatimago.rdp.basic system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.rdp.basic.test"
;; system attributes:
:description "Tests the com.informatimago.rdp.basic system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.rdp.basic.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.rdp.basic")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,906 | Common Lisp | .asd | 67 | 37.19403 | 83 | 0.541417 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 2f1a5579d4e9d4fa106a50b72f53a3c4a675f9dbc062bb1a560606b704c2dfd2 | 5,305 | [
-1
] |
5,306 | com.informatimago.small-cl-pgms.test.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.small-cl-pgms.test system.
;;;; Tests the com.informatimago.small-cl-pgms system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.test"
;; system attributes:
:description "Tests the com.informatimago.small-cl-pgms system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.small-cl-pgms.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.small-cl-pgms"
"com.informatimago.small-cl-pgms.brainfuck"
"com.informatimago.small-cl-pgms.life"
"com.informatimago.small-cl-pgms.quine"
"com.informatimago.small-cl-pgms.what-implementation")
:components ()
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op
(asdf:test-op "com.informatimago.small-cl-pgms.brainfuck.test")
(asdf:test-op "com.informatimago.small-cl-pgms.life.test")
(asdf:test-op "com.informatimago.small-cl-pgms.quine.test")
(asdf:test-op "com.informatimago.small-cl-pgms.what-implementation.test"))))
;;;; THE END ;;;;
| 3,083 | Common Lisp | .asd | 69 | 39 | 93 | 0.575697 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 38c519c4b6461f2a1ddf5e9875fb86ae2b6dc1374553cc0e422b1af1ad030c22 | 5,306 | [
-1
] |
5,307 | com.informatimago.small-cl-pgms.life.test.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.life.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.life.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.small-cl-pgms.life.test system.
;;;; Tests the com.informatimago.small-cl-pgms.life system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.life.test"
;; system attributes:
:description "Tests the com.informatimago.small-cl-pgms.life system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.small-cl-pgms.life.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.small-cl-pgms.life")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,896 | Common Lisp | .asd | 67 | 37.044776 | 86 | 0.540149 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 5b64a7e88f1361de7e6682bae1f38ad213bbc2e90491967dd875884e336e3350 | 5,307 | [
-1
] |
5,308 | com.informatimago.small-cl-pgms.what-implementation.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.what-implementation.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.what-implementation.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; This system loads a tool to help choosing a Common Lisp implementation.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Added asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2005 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.what-implementation"
:description "A tool to help choosing a Common Lisp implementation."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "what-implementation"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.small-cl-pgms.what-implementation.test"))))
;;;; THE END ;;;;
| 1,895 | Common Lisp | .asd | 43 | 42.651163 | 122 | 0.623784 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | b4ba55f1b16a42d6e037e7c054bb2f7c302470b50e458a2d7dcb93a60f49f20f | 5,308 | [
-1
] |
5,309 | com.informatimago.small-cl-pgms.quine.test.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.quine.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.quine.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.small-cl-pgms.quine.test system.
;;;; Tests the com.informatimago.small-cl-pgms.quine system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.quine.test"
;; system attributes:
:description "Tests the com.informatimago.small-cl-pgms.quine system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.small-cl-pgms.quine.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.small-cl-pgms.quine")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "TESTED-PACKAGE")))
;; (uiop:symbol-call "TESTED-PACKAGE"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 2,903 | Common Lisp | .asd | 67 | 37.149254 | 87 | 0.541284 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | d1244a938eb0488581b289808bc98eaa26b452bb5b4a44c590e779665ed153b6 | 5,309 | [
-1
] |
5,310 | com.informatimago.small-cl-pgms.life.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.life.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.life.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; This system loads a simple Conway's Life game.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Added asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2005 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.life"
:description "A simple Conway's Life game."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "life"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.small-cl-pgms.life.test"))))
;;;; THE END ;;;;
| 1,736 | Common Lisp | .asd | 42 | 39.952381 | 107 | 0.602837 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | bfb45c4296de38a97551ace03143a17910bd1d7dac16692b8e1df61a647a6c31 | 5,310 | [
-1
] |
5,311 | com.informatimago.small-cl-pgms.quine.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.quine.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.quine.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; This system loads a few quines.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Added asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2005 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.quine"
:description "A few Quines."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "quine"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.small-cl-pgms.quine.test"))))
;;;; THE END ;;;;
| 1,710 | Common Lisp | .asd | 42 | 39.333333 | 108 | 0.60024 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 35cc17103debdb92cd7b2b85361eab1341337ca1143f7889c170035f2243a88e | 5,311 | [
-1
] |
5,312 | com.informatimago.small-cl-pgms.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; This system loads the various small-cl-pgms systems.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Added asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2005 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms"
:description "Small Common Lisp Programs"
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ("com.informatimago.small-cl-pgms.brainfuck"
"com.informatimago.small-cl-pgms.what-implementation"
"com.informatimago.small-cl-pgms.life"
"com.informatimago.small-cl-pgms.quine")
:components ()
#+not-yet ((:file "1024")
(:file "author-signature")
(:file "cube")
(:file "douze")
(:file "example-soft-opcodes")
(:file "index")
(:file "init")
(:file "minlisp")
(:file "moon")
(:file "puzzle")
(:file "solitaire")
(:file "toy-byte-code")
(:file "wang-cl"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.small-cl-pgms.test"))))
(eval-when (:compile-toplevel :load-toplevel :execute)
(warn "~S not ready yet (need some cleaning)"
':com.informatimago.small-cl-pgms))
;;;; THE END ;;;;
| 2,497 | Common Lisp | .asd | 61 | 36.163934 | 102 | 0.578709 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 247d63d87d44b079ae286b1c2ffeeada6fad7e87b7331ae855f8fefe385516ba | 5,312 | [
-1
] |
5,313 | com.informatimago.small-cl-pgms.what-implementation.test.asd | informatimago_lisp/small-cl-pgms/com.informatimago.small-cl-pgms.what-implementation.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.what-implementation.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.small-cl-pgms.what-implementation.test system.
;;;; Tests the com.informatimago.small-cl-pgms.what-implementation system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.what-implementation.test"
;; system attributes:
:description "Tests the com.informatimago.small-cl-pgms.what-implementation system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.small-cl-pgms.what-implementation.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.small-cl-pgms.what-implementation"
"com.informatimago.common-lisp.cesarum")
:components ()
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
;; (let ((*package* (find-package "COM.INFORMATIMAGO.SMALL-CL-PGMS.WHAT-IMPLEMENTATION.TEST")))
;; (uiop:symbol-call "COM.INFORMATIMAGO.SMALL-CL-PGMS.WHAT-IMPLEMENTATION.TEST"
;; "TEST/ALL"))
))
;;;; THE END ;;;;
| 3,085 | Common Lisp | .asd | 67 | 39.865672 | 123 | 0.562666 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 7a9d24e1448c8f36a2c53a027d1fc02472771e98e06ac1ff1ea1f88d44cf6048 | 5,313 | [
-1
] |
5,314 | com.informatimago.small-cl-pgms.botihn.asd | informatimago_lisp/small-cl-pgms/botihn/com.informatimago.small-cl-pgms.botihn.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.botihn.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Botihn: an IRC bot monitoring Hacker News.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-04-27 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2019
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.botihn"
:description "An IRC bot monitoring Hacker News."
:author "Pascal J. Bourguignon"
:version "1.4.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.interactive" ; date uptime
"cl-irc" "cl-json" "drakma" "split-sequence" "cl-ppcre")
:components ((:file "botihn")))
;;;; THE END ;;;;
| 1,814 | Common Lisp | .asd | 43 | 40.162791 | 83 | 0.603731 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 04006101d8f264ad6af52dc4b63932a4abfc9bd4a27ae494948330721b6969fa | 5,314 | [
-1
] |
5,315 | com.informatimago.small-cl-pgms.irclog.asd | informatimago_lisp/small-cl-pgms/irclog-prompter/com.informatimago.small-cl-pgms.irclog.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.irclog.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Irclog: fetch the irc logs for the last messages.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2020-10-30 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2020 - 2020
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.irclog"
:description "Irclog: fetch the irc logs for the last messages."
:author "Pascal J. Bourguignon"
:version "1.0.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.interactive"
;; "cl-irc" "cl-json"
"drakma" "split-sequence" "cl-ppcre")
:components ((:file "irclog")
(:file "swank-slime")
(:file "prompter" :depends-on ("swank-slime"))
(:file "prompter-test" :depends-on ("prompter"))
(:file "main" :depends-on ("prompter" "irclog" "swank-slime"))))
;;;; THE END ;;;;
| 2,086 | Common Lisp | .asd | 48 | 39.979167 | 83 | 0.585953 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | dbd144e2e5c01a4e930d8aeeff9bec3d57a9320706adaf1083a9f8c5e404e51c | 5,315 | [
-1
] |
5,316 | com.informatimago.small-cl-pgms.brainfuck.asd | informatimago_lisp/small-cl-pgms/brainfuck/com.informatimago.small-cl-pgms.brainfuck.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: brainfuck.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; A Brainfuck Compiler..
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2014-12-23 <PJB> Added asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2005 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.brainfuck"
:description "Brainfuck Compiler."
:author "Pascal J. Bourguignon"
:version "1.2.0"
:license "GPL3"
:depends-on ()
:components ((:file "brainfuck"))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.small-cl-pgms.bf.test"))))
;;;; THE END ;;;;
| 1,684 | Common Lisp | .asd | 42 | 38.714286 | 105 | 0.59878 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 37d6a41d4c0260ee30c80f12d52b91a3074a3bbbcd255e6d56779821cf6796a7 | 5,316 | [
-1
] |
5,317 | com.informatimago.small-cl-pgms.brainfuck.test.asd | informatimago_lisp/small-cl-pgms/brainfuck/com.informatimago.small-cl-pgms.brainfuck.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.brainfuck.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.small-cl-pgms.brainfuck.test system.
;;;; Tests the com.informatimago.small-cl-pgms.brainfuck system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.brainfuck.test"
;; system attributes:
:description "Tests the com.informatimago.small-cl-pgms.brainfuck system."
:author "Pascal J. Bourguignon"
:maintainer "Pascal J. Bourguignon"
:licence "GPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.small-cl-pgms.brainfuck.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.small-cl-pgms.brainfuck")
:components ((:file "brainfuck-test" :depends-on ()))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(dolist (p '("COM.INFORMATIMAGO.SMALL-CL-PGMS.BRAINFUCK.TEST"))
(let ((*package* (find-package p)))
(uiop:symbol-call p "TEST/ALL")))))
;;;; THE END ;;;;
| 2,943 | Common Lisp | .asd | 66 | 38.666667 | 91 | 0.560348 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 632d079e1d2518865c2e22798812716b41fcb68cccd6d2c9552d83f67efdbfdd | 5,317 | [
-1
] |
5,318 | com.informatimago.small-cl-pgms.botil.asd | informatimago_lisp/small-cl-pgms/botil/com.informatimago.small-cl-pgms.botil.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.botil.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Botil: an IRC bot implementing IRC Logs.
;;;; with timed and regexp queries.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-04-27 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2015
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.botil"
:description "An IRC bot monitoring Hacker News."
:author "Pascal J. Bourguignon"
:version "1.0.0"
:license "AGPL3"
:depends-on ("com.informatimago.rdp"
"com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.interactive" ; date uptime
"cl-irc" "cl-json" "drakma" "split-sequence"
"cl-date-time-parser" "cl-ppcre" "cl-smtp"
"montezuma")
:components ((:file "botil")))
;;;; THE END ;;;;
| 1,961 | Common Lisp | .asd | 47 | 38.829787 | 83 | 0.595188 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | b00f80da024e7fcae691fc2878d5d7302a019e513d80f1ec7d5711736642c854 | 5,318 | [
-1
] |
5,319 | com.informatimago.small-cl-pgms.botvot.asd | informatimago_lisp/small-cl-pgms/botvot/com.informatimago.small-cl-pgms.botvot.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.small-cl-pgms.botvot.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Botvot: An IRC bot to manage votes in irc.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2021-04-14 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2021 - 2021
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.small-cl-pgms.botvot"
:description "An IRC bot to manage votes in irc."
:author "Pascal J. Bourguignon"
:version "1.0.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.interactive"
"cl-irc" "split-sequence" "cl-ppcre"
"ironclad" "babel")
:components ((:file "botvot"))
#+asdf3 :in-order-to
#+asdf3 ((test-op (test-op "com.informatimago.small-cl-pgms.botvot.test"))))
(asdf:defsystem "com.informatimago.small-cl-pgms.botvot.test"
:description "Tests an IRC bot to manage votes in irc."
:author "Pascal J. Bourguignon"
:version "1.0.0"
:license "AGPL3"
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.small-cl-pgms.botvot")
:components ((:file "botvot-test"))
#+asdf3 :perform
#+asdf3 (test-op (operation system)
(let ((*package* (find-package "COM.INFORMATIMAGO.SMALL-CL-PGMS.BOTVOT")))
(uiop:symbol-call *package* "TEST/ALL"))))
;;;; THE END ;;;;
| 2,476 | Common Lisp | .asd | 58 | 39.344828 | 93 | 0.61309 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 20293214c6176fba2c9f4e2cb7bff8da7c5fb0084e1417ec0373ec0d0d90dcc2 | 5,319 | [
-1
] |
5,320 | com.informatimago.clext.queue.asd | informatimago_lisp/clext/com.informatimago.clext.queue.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.queue.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.queue library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.clext.queue"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Queues."
:long-description "
This system would use TRIVIAL-GRAY-STREAMS, which is not available on MOCL.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")"$HOME"/rc
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#-mocl
(asdf:defsystem "com.informatimago.clext.queue"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Queues."
:long-description "
This system provides QUEUES, a pair of input and output stream
with a synchronized queue in the middle.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("bordeaux-threads")
:components ((:file "queue"))
#+adsf3 :in-order-to
#+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.queue.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,597 | Common Lisp | .asd | 81 | 40.432099 | 97 | 0.591959 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ba6554593e18f6af8ed8a2ddba5f715732c4420aec2c78a799b74e8d39901a3f | 5,320 | [
-1
] |
5,321 | com.informatimago.clext.association.test.asd | informatimago_lisp/clext/com.informatimago.clext.association.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.association.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to test the com.informatimago.clext.association library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.association.test"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Associations - Tests."
:long-description "
Tests the system that provides a Common-Lisp package exporting a macro
to define CLOS associations. It uses CLOSER-MOP.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("closer-mop"
"com.informatimago.common-lisp.cesarum"
"com.informatimago.clext.association")
:components ((:file "association-test"))
#+asdf3 :perform #+asdf3 (asdf:test-op
(o s)
(let ((*package* (find-package "COM.INFORMATIMAGO.CLEXT.ASSOCIATION")))
(uiop:symbol-call "COM.INFORMATIMAGO.CLEXT.ASSOCIATION.TEST" "TEST/ALL"))))
;;;; THE END ;;;;
| 2,929 | Common Lisp | .asd | 62 | 42.403226 | 106 | 0.588605 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | bb49a7a750314a15f317571c83c1e6bad15d7d10745f460e845fd22266f33061 | 5,321 | [
-1
] |
5,322 | com.informatimago.clext.filter-stream.asd | informatimago_lisp/clext/com.informatimago.clext.filter-stream.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.filter-stream.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.filter-stream library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2017 - 2017
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.clext.filter-stream"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Filter-Streams."
:long-description "
This system would use TRIVIAL-GRAY-STREAMS, which is not available on MOCL.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#-mocl
(asdf:defsystem "com.informatimago.clext.filter-stream"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Filter-Streams."
:long-description "
This Gray stream filters the data.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2017")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("trivial-gray-streams"
"bordeaux-threads")
:components ((:file "filter-stream"))
;; #+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.filter-stream.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,622 | Common Lisp | .asd | 80 | 41.0875 | 110 | 0.591166 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 18b4ff52eb6efa3d6eded8b32725c70d5cfede6e39e43c1be0302dfc241951be | 5,322 | [
-1
] |
5,323 | com.informatimago.clext.character-sets.asd | informatimago_lisp/clext/com.informatimago.clext.character-sets.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.character-sets.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.character-sets library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.clext.character-sets"
;; system attributes:
:description "Dummy Informatimago Common Lisp Extensions: Character-Setss."
:long-description "
Portability layer over character sets and external-formats.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#-mocl
(asdf:defsystem "com.informatimago.clext.character-sets"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Character-Sets."
:long-description "
Portability layer over character sets and external-formats.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum")
:components ((:file "character-sets"))
;; #+adsf3 :in-order-to #+adsf3 ((test-op (test-op "com.informatimago.clext.character-sets.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,616 | Common Lisp | .asd | 79 | 41.746835 | 101 | 0.596655 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ded72654ddc9c6a3bcc2b2d5ab5e6e032dbbcf88b04259209dfd15f084be1538 | 5,323 | [
-1
] |
5,324 | com.informatimago.clext.pipe.test.asd | informatimago_lisp/clext/com.informatimago.clext.pipe.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.pipe.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to test the com.informatimago.clext.pipe library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-29 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.pipe.test"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Pipes - Tests."
:long-description "
Tests the pipes.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Automn 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clext.pipe")
:components ((:file "pipe-test"))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.CLEXT.PIPE")))
(uiop:symbol-call "COM.INFORMATIMAGO.CLEXT.PIPE.TEST" "TEST/ALL")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,804 | Common Lisp | .asd | 61 | 40.885246 | 98 | 0.571011 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 24ea723219e8cf020aa62950e17bc7a4d40fac2ca9ea9f8241a6af1c0ed50d3c | 5,324 | [
-1
] |
5,325 | com.informatimago.clext.closer-weak.asd | informatimago_lisp/clext/com.informatimago.clext.closer-weak.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.closer-weak.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.closer-weak library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#-(or ccl clisp sbcl cmu)
(asdf:defsystem "com.informatimago.clext.closer-weak"
;; system attributes:
:description "Dummy Informatimago Common Lisp Extensions: Closer-Weaks."
:long-description "
This system requires weak references, which either
are not available on this implementation,
or it hasn't been ported to this implementation yet.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#+(or ccl clisp sbcl cmu)
(asdf:defsystem "com.informatimago.clext.closer-weak"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Closer-Weak."
:long-description "
Closer to Weak objects.
Implements the specification: <http://clisp.cons.org/impnotes/weak.html>
for Common Lisp implementations that have weak-pointers.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ()
:components ((:file "closer-weak"))
#+adsf3 :in-order-to #+adsf3 ((test-op (test-op "com.informatimago.clext.closer-weak.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,768 | Common Lisp | .asd | 83 | 41.518072 | 97 | 0.603101 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8610684c7179fef34d00adf75b8e8d2fa4d452a0396d0220c481a8c336944fc2 | 5,325 | [
-1
] |
5,326 | com.informatimago.clext.queue.test.asd | informatimago_lisp/clext/com.informatimago.clext.queue.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.queue.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to test the com.informatimago.clext.queue library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-29 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.queue.test"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Queues - Tests."
:long-description "
Tests the queues.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Automn 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clext.queue")
:components ((:file "queue-test"))
#+asdf3 :perform #+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.CLEXT.QUEUE")))
(uiop:symbol-call "COM.INFORMATIMAGO.CLEXT.QUEUE.TEST" "TEST/ALL")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,813 | Common Lisp | .asd | 61 | 41.032787 | 99 | 0.572416 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | e6b0c4276336ea5f1ad53f016ba522e073243b17a2005d0b2c68d404a2fea8f8 | 5,326 | [
-1
] |
5,327 | com.informatimago.clext.redirecting-stream.asd | informatimago_lisp/clext/com.informatimago.clext.redirecting-stream.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.redirecting-stream.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.redirecting-stream library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2017 - 2017
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.clext.redirecting-stream"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Redirecting-Streams."
:long-description "
This system would use TRIVIAL-GRAY-STREAMS, which is not available on MOCL.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#-mocl
(asdf:defsystem "com.informatimago.clext.redirecting-stream"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Redirecting-Streams."
:long-description "
This Gray stream redirects to streams determined at I/O time.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2017")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("trivial-gray-streams"
"bordeaux-threads")
:components ((:file "redirecting-stream"))
;; #+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.redirecting-stream.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,689 | Common Lisp | .asd | 80 | 41.925 | 115 | 0.597388 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 7f5eec6067126ef844a867eadb1aced90e30007e8b83d40d98eda2780b4d0be3 | 5,327 | [
-1
] |
5,328 | com.informatimago.clext.shell.asd | informatimago_lisp/clext/com.informatimago.clext.shell.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.shell.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.shell library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2020-11-05 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2020
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.shell"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Shells."
:long-description "
This system provides functions to run commands using an externa shell.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2020")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("asdf")
:components ((:file "shell"))
;; #+adsf3 :in-order-to
;; #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.shell.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,539 | Common Lisp | .asd | 57 | 41.368421 | 97 | 0.588853 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 7ead791fd1fb606daba0564e65c3aed60525a9ab30fcc03ca6f28bcfaf8121fa | 5,328 | [
-1
] |
5,329 | com.informatimago.clext.association.asd | informatimago_lisp/clext/com.informatimago.clext.association.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.association.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.association library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.clext.association"
;; system attributes:
:description "Dummy Informatimago Common Lisp Extensions: Associations."
:long-description "
This system would use CLOSER-MOP, which is not available on MOCL.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#-mocl
(asdf:defsystem "com.informatimago.clext.association"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Associations."
:long-description "
This system provides a Common-Lisp package exporting a macro to define
CLOS associations. It uses CLOSER-MOP.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Autumn 2010")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("closer-mop"
"com.informatimago.common-lisp.cesarum")
:components ((:file "association"))
#+adsf3 :in-order-to #+adsf3 ((test-op (test-op "com.informatimago.clext.association.test"))))
;;;; THE END ;;;;
| 3,675 | Common Lisp | .asd | 81 | 41.234568 | 97 | 0.596653 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 98efd267596564129dca1b3dbfd20ce9fa0f488b5fa616aee0d2b5d148bbaa47 | 5,329 | [
-1
] |
5,330 | com.informatimago.clext.test.asd | informatimago_lisp/clext/com.informatimago.clext.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;***************************************************************************
;;;;FILE: com.informatimago.clext.test.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: None
;;;;USER-INTERFACE: None
;;;;DESCRIPTION:
;;;;
;;;; This file defines the com.informatimago.clext.test system.
;;;; Tests the com.informatimago.clext system.
;;;;
;;;;USAGE:
;;;;
;;;;AUTHORS:
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS:
;;;; 2015-02-23 <PJB> Created.
;;;;BUGS:
;;;;
;;;;LEGAL:
;;;;
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>
;;;;
;;;;***************************************************************************
(asdf:defsystem "com.informatimago.clext.test"
;; system attributes:
:description "Tests the com.informatimago.clext system."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Winter 2015")
((#:albert #:output-dir)
. "/tmp/documentation/com.informatimago.clext.test/")
((#:albert #:formats) "docbook")
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.clext")
:components ((:file "closer-weak-test" :depends-on nil))
#+asdf3 :perform
#+asdf3 (asdf:test-op
(operation system)
(declare (ignore operation system))
(let ((*package* (find-package "COM.INFORMATIMAGO.CLEXT.CLOSER-WEAK.TEST")))
(uiop:symbol-call "COM.INFORMATIMAGO.CLEXT.CLOSER-WEAK.TEST" "TEST/ALL")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 2,812 | Common Lisp | .asd | 66 | 38.166667 | 87 | 0.579082 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 501ea6cfb7c00a6179473e2d7fb337dd2684f68e5d9ff963b7f01c709adbe43e | 5,330 | [
-1
] |
5,331 | com.informatimago.clext.asd | informatimago_lisp/clext/com.informatimago.clext.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2010-10-31 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2010 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext"
;; system attributes:
:description "Informatimago Common Lisp Extensions"
:long-description "
This system provides Common-Lisp packages that are mostly portable,
but that use some extensions, packages out of the Common-Lisp
specifications, like GRAY or other portability libraries.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.6.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2017")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("com.informatimago.clext.association"
"com.informatimago.clext.character-sets"
#+(or ccl clisp sbcl cmu) "com.informatimago.clext.closer-weak"
#+(or ccl clisp sbcl cmu) "com.informatimago.clext.pipe"
"com.informatimago.clext.queue"
"com.informatimago.clext.filter-stream"
"com.informatimago.clext.redirecting-stream"
"com.informatimago.clext.shell")
:components ()
#+adsf3 :in-order-to
#+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.test")
(asdf:test-op "com.informatimago.clext.association.test")
(asdf:test-op "com.informatimago.clext.pipe.test")
(asdf:test-op "com.informatimago.clext.queue.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,284 | Common Lisp | .asd | 69 | 42.202899 | 97 | 0.598131 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 49f80eefc3b767a82e51a5aea74a4335d1f3817816896713993e27f5cbfb5a2f | 5,331 | [
-1
] |
5,332 | com.informatimago.clext.pipe.asd | informatimago_lisp/clext/com.informatimago.clext.pipe.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.pipe.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.pipe library.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2015-09-12 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2015 - 2016
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
#+mocl
(asdf:defsystem "com.informatimago.clext.pipe"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Pipes."
:long-description "
This system would use TRIVIAL-GRAY-STREAMS, which is not available on MOCL.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ()
:components ())
#-mocl
(asdf:defsystem "com.informatimago.clext.pipe"
;; system attributes:
:description "Informatimago Common Lisp Extensions: Pipes."
:long-description "
This system provides PIPES, a pair of input and output stream
with a synchronized queue in the middle.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.2.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Summer 2015")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
:depends-on ("trivial-gray-streams"
"bordeaux-threads"
"com.informatimago.clext.closer-weak") ; weak hash-tables are needed for gate.
:components ((:file "gate")
(:file "pipe" :depends-on ("gate")))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.pipe.test")))
#+asdf-unicode :encoding #+asdf-unicode :utf-8)
;;;; THE END ;;;;
| 3,758 | Common Lisp | .asd | 83 | 40.855422 | 98 | 0.589471 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | f74bfe3cf262c8c3e5a85db0b1929fef466a0c875a741cdca595ecd73f3edc74 | 5,332 | [
-1
] |
5,333 | com.informatimago.clext.gitlab.asd | informatimago_lisp/clext/gitlab/com.informatimago.clext.gitlab.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.gitlab.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the com.informatimago.clext.gitlab tool.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2019-03-25 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2019 - 2019
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.gitlab"
;; system attributes:
:description "This system provides an access to the gitlab API."
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.0"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2019")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext.gitlab/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("cl-json"
"drakma"
"babel"
"split-sequence"
"com.informatimago.common-lisp.cesarum")
:components ((:file "gitlab" :depends-on ()))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.tools.test"))))
;;;; THE END ;;;;
| 2,578 | Common Lisp | .asd | 57 | 41.122807 | 104 | 0.573471 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | ff7daee314edf506978b1cee420751f072f20d003e43e8d50e04e23bcbe6811d | 5,333 | [
-1
] |
5,334 | com.informatimago.clext.telnet.repl.test.asd | informatimago_lisp/clext/telnet/com.informatimago.clext.telnet.repl.test.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.telnet.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the Telnet REPL server.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2021-05-13 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2021 - 2021
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.telnet.repl.test"
;; system attributes:
:description "Tests the Telnet REPL Server."
:long-description "
This system tests the Telnet REPL Server.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.2"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2021")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext.telnet.repl.test/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("babel"
"usocket"
"bordeaux-threads"
"trivial-gray-streams"
"com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.interactive"
"com.informatimago.common-lisp.telnet"
"com.informatimago.clext.telnet.repl")
:components
((:file "interrupt" :depends-on ())
(:file "interrupt-test" :depends-on ("interrupt"))
(:file "packages" :depends-on ("interrupt"))
(:file "telnet-stream" :depends-on ("packages"))
(:file "babel-extension" :depends-on ("packages"))
(:file "telnet-repl" :depends-on ("packages"
"telnet-stream"
"babel-extension"))
(:file "babel-extension-test" :depends-on ("packages" "babel-extension"))
(:file "test-stub-nvt" :depends-on ("packages"))
(:file "telnet-stream-test" :depends-on ("packages"
"telnet-stream"
"test-stub-nvt"))))
;;;; THE END ;;;;
| 3,505 | Common Lisp | .asd | 75 | 39.84 | 114 | 0.548962 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 64a2287f9b53bcd79704c67a9e00adeecead18bf9b252579a991158124ef4e17 | 5,334 | [
-1
] |
5,335 | com.informatimago.clext.telnet.repl.asd | informatimago_lisp/clext/telnet/com.informatimago.clext.telnet.repl.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.telnet.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; ASD file to load the Telnet REPL server.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2021-05-13 <PJB> Created this .asd file.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2021 - 2021
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see http://www.gnu.org/licenses/
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.telnet.repl"
;; system attributes:
:description "A Telnet REPL Server."
:long-description "
This system implements a Telnet REPL Server.
"
:author "Pascal J. Bourguignon <[email protected]>"
:maintainer "Pascal J. Bourguignon <[email protected]>"
:licence "AGPL3"
;; component attributes:
:version "1.0.2"
:properties ((#:author-email . "[email protected]")
(#:date . "Spring 2021")
((#:albert #:output-dir) . "/tmp/documentation/com.informatimago.clext.telnet.repl/")
((#:albert #:formats) . ("docbook"))
((#:albert #:docbook #:template) . "book")
((#:albert #:docbook #:bgcolor) . "white")
((#:albert #:docbook #:textcolor) . "black"))
#+asdf-unicode :encoding #+asdf-unicode :utf-8
:depends-on ("com.informatimago.common-lisp.cesarum"
"com.informatimago.common-lisp.interactive"
"com.informatimago.common-lisp.telnet"
"babel"
"usocket"
"bordeaux-threads"
"trivial-gray-streams")
;; #+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.telnet.repl.test")))
:components
((:file "interrupt" :depends-on ())
(:file "packages" :depends-on ("interrupt"))
#+(and ccl debug-condition-variables)
(:file "bt-patch"
:depends-on ("packages"))
(:file "telnet-stream"
:depends-on ("packages"
"interrupt"
#+(and ccl debug-condition-variables) "bt-patch"))
(:file "babel-extension"
:depends-on ("packages"))
(:file "telnet-repl"
:depends-on ("packages"
"babel-extension"
"telnet-stream"
#+(and ccl debug-condition-variables) "bt-patch"))))
;;;; THE END ;;;;
| 3,316 | Common Lisp | .asd | 78 | 37.230769 | 109 | 0.57784 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 8f6ceb5635e387b278f57baca24e4f98f4252335a408f4e06069f9aa6c837470 | 5,335 | [
-1
] |
5,336 | com.informatimago.clext.pkcs11.asd | informatimago_lisp/clext/pkcs11/com.informatimago.clext.pkcs11.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.pkcs11.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Lispy interface over Cryptoki pkcs11 version 2.02
;;;;
;;;; Depends on [email protected]:fjames86/asinine.git
;;;; or [email protected]:informatimago/asinine.git
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2018-09-23 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2018 - 2018
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
(asdf:defsystem "com.informatimago.clext.pkcs11"
:description "PKCS11 wrapper."
:author "Pascal J. Bourguignon"
:version "0.0.0"
:license "AGPL3"
:depends-on ("cffi" "babel" "asinine")
:components ((:file "pkcs11-cffi" :depends-on ())
(:file "cffi-utils" :depends-on ())
(:file "cffi-debug" :depends-on ())
(:file "pkcs11" :depends-on ("pkcs11-cffi" "cffi-utils" "cffi-debug")))
#+adsf3 :in-order-to #+adsf3 ((asdf:test-op (asdf:test-op "com.informatimago.clext.pkcs11.tests"))))
;;;; THE END ;;;;
| 2,064 | Common Lisp | .asd | 48 | 40.729167 | 102 | 0.595333 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 0a9baf81f6b06fc4ba900a172f1ffe80390f5771b098485910e108f1f3390159 | 5,336 | [
-1
] |
5,337 | com.informatimago.clext.pkcs11.tests.asd | informatimago_lisp/clext/pkcs11/com.informatimago.clext.pkcs11.tests.asd | ;;;; -*- mode:lisp;coding:utf-8 -*-
;;;;**************************************************************************
;;;;FILE: com.informatimago.clext.pkcs11.tests.asd
;;;;LANGUAGE: Common-Lisp
;;;;SYSTEM: Common-Lisp
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; System to test the com.informatimago.clext.pkcs11 package.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal J. Bourguignon <[email protected]>
;;;;MODIFICATIONS
;;;; 2018-09-23 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; AGPL3
;;;;
;;;; Copyright Pascal J. Bourguignon 2018 - 2018
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 of the License, or
;;;; (at your option) any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;;; GNU Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;**************************************************************************
;;;;
(asdf:defsystem "com.informatimago.clext.pkcs11.tests"
:description "PKCS11 wrapper tests."
:author "Pascal J. Bourguignon"
:version "0.0.0"
:license "AGPL3"
:depends-on ("com.informatimago.clext.pkcs11"
"com.informatimago.common-lisp.interactive")
:components ((:file "tests" :depends-on ("pkcs11"))
(:file "debug" :depends-on ("pkcs11"))))
;;;; THE END ;;;;
| 1,814 | Common Lisp | .asd | 44 | 39.227273 | 83 | 0.597285 | informatimago/lisp | 20 | 6 | 0 | AGPL-3.0 | 9/19/2024, 11:26:28 AM (Europe/Amsterdam) | 547cf4a8e14a3187df5437de170261c791eeb6ece4c55228e6f2cc09a1590168 | 5,337 | [
-1
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.